TUN-528: Move cloudflared into a separate repo

vendor/github.com/mholt/caddy/caddytls/storagetest/memorystorage.go

@@ -0,0 +1,148 @@
+// Copyright 2015 Light Code Labs, LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package storagetest
+
+import (
+	"errors"
+	"net/url"
+	"sync"
+
+	"github.com/mholt/caddy/caddytls"
+)
+
+// memoryMutex is a mutex used to control access to memoryStoragesByCAURL.
+var memoryMutex sync.Mutex
+
+// memoryStoragesByCAURL is a map keyed by a CA URL string with values of
+// instantiated memory stores. Do not access this directly, it is used by
+// InMemoryStorageCreator.
+var memoryStoragesByCAURL = make(map[string]*InMemoryStorage)
+
+// InMemoryStorageCreator is a caddytls.Storage.StorageCreator to create
+// InMemoryStorage instances for testing.
+func InMemoryStorageCreator(caURL *url.URL) (caddytls.Storage, error) {
+	urlStr := caURL.String()
+	memoryMutex.Lock()
+	defer memoryMutex.Unlock()
+	storage := memoryStoragesByCAURL[urlStr]
+	if storage == nil {
+		storage = NewInMemoryStorage()
+		memoryStoragesByCAURL[urlStr] = storage
+	}
+	return storage, nil
+}
+
+// InMemoryStorage is a caddytls.Storage implementation for use in testing.
+// It simply stores information in runtime memory.
+type InMemoryStorage struct {
+	// Sites are exposed for testing purposes.
+	Sites map[string]*caddytls.SiteData
+	// Users are exposed for testing purposes.
+	Users map[string]*caddytls.UserData
+	// LastUserEmail is exposed for testing purposes.
+	LastUserEmail string
+}
+
+// NewInMemoryStorage constructs an InMemoryStorage instance. For use with
+// caddytls, the InMemoryStorageCreator should be used instead.
+func NewInMemoryStorage() *InMemoryStorage {
+	return &InMemoryStorage{
+		Sites: make(map[string]*caddytls.SiteData),
+		Users: make(map[string]*caddytls.UserData),
+	}
+}
+
+// SiteExists implements caddytls.Storage.SiteExists in memory.
+func (s *InMemoryStorage) SiteExists(domain string) (bool, error) {
+	_, siteExists := s.Sites[domain]
+	return siteExists, nil
+}
+
+// Clear completely clears all values associated with this storage.
+func (s *InMemoryStorage) Clear() {
+	s.Sites = make(map[string]*caddytls.SiteData)
+	s.Users = make(map[string]*caddytls.UserData)
+	s.LastUserEmail = ""
+}
+
+// LoadSite implements caddytls.Storage.LoadSite in memory.
+func (s *InMemoryStorage) LoadSite(domain string) (*caddytls.SiteData, error) {
+	siteData, ok := s.Sites[domain]
+	if !ok {
+		return nil, caddytls.ErrNotExist(errors.New("not found"))
+	}
+	return siteData, nil
+}
+
+func copyBytes(from []byte) []byte {
+	copiedBytes := make([]byte, len(from))
+	copy(copiedBytes, from)
+	return copiedBytes
+}
+
+// StoreSite implements caddytls.Storage.StoreSite in memory.
+func (s *InMemoryStorage) StoreSite(domain string, data *caddytls.SiteData) error {
+	copiedData := new(caddytls.SiteData)
+	copiedData.Cert = copyBytes(data.Cert)
+	copiedData.Key = copyBytes(data.Key)
+	copiedData.Meta = copyBytes(data.Meta)
+	s.Sites[domain] = copiedData
+	return nil
+}
+
+// DeleteSite implements caddytls.Storage.DeleteSite in memory.
+func (s *InMemoryStorage) DeleteSite(domain string) error {
+	if _, ok := s.Sites[domain]; !ok {
+		return caddytls.ErrNotExist(errors.New("not found"))
+	}
+	delete(s.Sites, domain)
+	return nil
+}
+
+// TryLock implements Storage.TryLock by returning nil values because it
+// is not a multi-server storage implementation.
+func (s *InMemoryStorage) TryLock(domain string) (caddytls.Waiter, error) {
+	return nil, nil
+}
+
+// Unlock implements Storage.Unlock as a no-op because it is
+// not a multi-server storage implementation.
+func (s *InMemoryStorage) Unlock(domain string) error {
+	return nil
+}
+
+// LoadUser implements caddytls.Storage.LoadUser in memory.
+func (s *InMemoryStorage) LoadUser(email string) (*caddytls.UserData, error) {
+	userData, ok := s.Users[email]
+	if !ok {
+		return nil, caddytls.ErrNotExist(errors.New("not found"))
+	}
+	return userData, nil
+}
+
+// StoreUser implements caddytls.Storage.StoreUser in memory.
+func (s *InMemoryStorage) StoreUser(email string, data *caddytls.UserData) error {
+	copiedData := new(caddytls.UserData)
+	copiedData.Reg = copyBytes(data.Reg)
+	copiedData.Key = copyBytes(data.Key)
+	s.Users[email] = copiedData
+	s.LastUserEmail = email
+	return nil
+}
+
+// MostRecentUserEmail implements caddytls.Storage.MostRecentUserEmail in memory.
+func (s *InMemoryStorage) MostRecentUserEmail() string {
+	return s.LastUserEmail
+}

vendor/github.com/mholt/caddy/caddytls/storagetest/memorystorage_test.go

@@ -0,0 +1,26 @@
+// Copyright 2015 Light Code Labs, LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package storagetest
+
+import "testing"
+
+func TestMemoryStorage(t *testing.T) {
+	storage := NewInMemoryStorage()
+	storageTest := &StorageTest{
+		Storage:  storage,
+		PostTest: storage.Clear,
+	}
+	storageTest.Test(t, false)
+}

vendor/github.com/mholt/caddy/caddytls/storagetest/storagetest.go

@@ -0,0 +1,306 @@
+// Copyright 2015 Light Code Labs, LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Package storagetest provides utilities to assist in testing caddytls.Storage
+// implementations.
+package storagetest
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"testing"
+
+	"github.com/mholt/caddy/caddytls"
+)
+
+// StorageTest is a test harness that contains tests to execute all exposed
+// parts of a Storage implementation.
+type StorageTest struct {
+	// Storage is the implementation to use during tests. This must be
+	// present.
+	caddytls.Storage
+
+	// PreTest, if present, is called before every test. Any error returned
+	// is returned from the test and the test does not continue.
+	PreTest func() error
+
+	// PostTest, if present, is executed after every test via defer which
+	// means it executes even on failure of the test (but not on failure of
+	// PreTest).
+	PostTest func()
+
+	// AfterUserEmailStore, if present, is invoked during
+	// TestMostRecentUserEmail after each storage just in case anything
+	// needs to be mocked.
+	AfterUserEmailStore func(email string) error
+}
+
+// TestFunc holds information about a test.
+type TestFunc struct {
+	// Name is the friendly name of the test.
+	Name string
+
+	// Fn is the function that is invoked for the test.
+	Fn func() error
+}
+
+// runPreTest runs the PreTest function if present.
+func (s *StorageTest) runPreTest() error {
+	if s.PreTest != nil {
+		return s.PreTest()
+	}
+	return nil
+}
+
+// runPostTest runs the PostTest function if present.
+func (s *StorageTest) runPostTest() {
+	if s.PostTest != nil {
+		s.PostTest()
+	}
+}
+
+// AllFuncs returns all test functions that are part of this harness.
+func (s *StorageTest) AllFuncs() []TestFunc {
+	return []TestFunc{
+		{"TestSiteInfoExists", s.TestSiteExists},
+		{"TestSite", s.TestSite},
+		{"TestUser", s.TestUser},
+		{"TestMostRecentUserEmail", s.TestMostRecentUserEmail},
+	}
+}
+
+// Test executes the entire harness using the testing package. Failures are
+// reported via T.Fatal. If eagerFail is true, the first failure causes all
+// testing to stop immediately.
+func (s *StorageTest) Test(t *testing.T, eagerFail bool) {
+	if errs := s.TestAll(eagerFail); len(errs) > 0 {
+		ifaces := make([]interface{}, len(errs))
+		for i, err := range errs {
+			ifaces[i] = err
+		}
+		t.Fatal(ifaces...)
+	}
+}
+
+// TestAll executes the entire harness and returns the results as an array of
+// errors. If eagerFail is true, the first failure causes all testing to stop
+// immediately.
+func (s *StorageTest) TestAll(eagerFail bool) (errs []error) {
+	for _, fn := range s.AllFuncs() {
+		if err := fn.Fn(); err != nil {
+			errs = append(errs, fmt.Errorf("%v failed: %v", fn.Name, err))
+			if eagerFail {
+				return
+			}
+		}
+	}
+	return
+}
+
+var simpleSiteData = &caddytls.SiteData{
+	Cert: []byte("foo"),
+	Key:  []byte("bar"),
+	Meta: []byte("baz"),
+}
+var simpleSiteDataAlt = &caddytls.SiteData{
+	Cert: []byte("qux"),
+	Key:  []byte("quux"),
+	Meta: []byte("corge"),
+}
+
+// TestSiteExists tests Storage.SiteExists.
+func (s *StorageTest) TestSiteExists() error {
+	if err := s.runPreTest(); err != nil {
+		return err
+	}
+	defer s.runPostTest()
+
+	// Should not exist at first
+	siteExists, err := s.SiteExists("example.com")
+	if err != nil {
+		return err
+	}
+
+	if siteExists {
+		return errors.New("Site should not exist")
+	}
+
+	// Should exist after we store it
+	if err := s.StoreSite("example.com", simpleSiteData); err != nil {
+		return err
+	}
+
+	siteExists, err = s.SiteExists("example.com")
+	if err != nil {
+		return err
+	}
+
+	if !siteExists {
+		return errors.New("Expected site to exist")
+	}
+
+	// Site should no longer exist after we delete it
+	if err := s.DeleteSite("example.com"); err != nil {
+		return err
+	}
+
+	siteExists, err = s.SiteExists("example.com")
+	if err != nil {
+		return err
+	}
+
+	if siteExists {
+		return errors.New("Site should not exist after delete")
+	}
+	return nil
+}
+
+// TestSite tests Storage.LoadSite, Storage.StoreSite, and Storage.DeleteSite.
+func (s *StorageTest) TestSite() error {
+	if err := s.runPreTest(); err != nil {
+		return err
+	}
+	defer s.runPostTest()
+
+	// Should be a not-found error at first
+	_, err := s.LoadSite("example.com")
+	if _, ok := err.(caddytls.ErrNotExist); !ok {
+		return fmt.Errorf("Expected caddytls.ErrNotExist from load, got %T: %v", err, err)
+	}
+
+	// Delete should also be a not-found error at first
+	err = s.DeleteSite("example.com")
+	if _, ok := err.(caddytls.ErrNotExist); !ok {
+		return fmt.Errorf("Expected ErrNotExist from delete, got: %v", err)
+	}
+
+	// Should store successfully and then load just fine
+	if err := s.StoreSite("example.com", simpleSiteData); err != nil {
+		return err
+	}
+	if siteData, err := s.LoadSite("example.com"); err != nil {
+		return err
+	} else if !bytes.Equal(siteData.Cert, simpleSiteData.Cert) {
+		return errors.New("Unexpected cert returned after store")
+	} else if !bytes.Equal(siteData.Key, simpleSiteData.Key) {
+		return errors.New("Unexpected key returned after store")
+	} else if !bytes.Equal(siteData.Meta, simpleSiteData.Meta) {
+		return errors.New("Unexpected meta returned after store")
+	}
+
+	// Overwrite should work just fine
+	if err := s.StoreSite("example.com", simpleSiteDataAlt); err != nil {
+		return err
+	}
+	if siteData, err := s.LoadSite("example.com"); err != nil {
+		return err
+	} else if !bytes.Equal(siteData.Cert, simpleSiteDataAlt.Cert) {
+		return errors.New("Unexpected cert returned after overwrite")
+	}
+
+	// It should delete fine and then not be there
+	if err := s.DeleteSite("example.com"); err != nil {
+		return err
+	}
+	_, err = s.LoadSite("example.com")
+	if _, ok := err.(caddytls.ErrNotExist); !ok {
+		return fmt.Errorf("Expected caddytls.ErrNotExist after delete, got %T: %v", err, err)
+	}
+
+	return nil
+}
+
+var simpleUserData = &caddytls.UserData{
+	Reg: []byte("foo"),
+	Key: []byte("bar"),
+}
+var simpleUserDataAlt = &caddytls.UserData{
+	Reg: []byte("baz"),
+	Key: []byte("qux"),
+}
+
+// TestUser tests Storage.LoadUser and Storage.StoreUser.
+func (s *StorageTest) TestUser() error {
+	if err := s.runPreTest(); err != nil {
+		return err
+	}
+	defer s.runPostTest()
+
+	// Should be a not-found error at first
+	_, err := s.LoadUser("foo@example.com")
+	if _, ok := err.(caddytls.ErrNotExist); !ok {
+		return fmt.Errorf("Expected caddytls.ErrNotExist from load, got %T: %v", err, err)
+	}
+
+	// Should store successfully and then load just fine
+	if err := s.StoreUser("foo@example.com", simpleUserData); err != nil {
+		return err
+	}
+	if userData, err := s.LoadUser("foo@example.com"); err != nil {
+		return err
+	} else if !bytes.Equal(userData.Reg, simpleUserData.Reg) {
+		return errors.New("Unexpected reg returned after store")
+	} else if !bytes.Equal(userData.Key, simpleUserData.Key) {
+		return errors.New("Unexpected key returned after store")
+	}
+
+	// Overwrite should work just fine
+	if err := s.StoreUser("foo@example.com", simpleUserDataAlt); err != nil {
+		return err
+	}
+	if userData, err := s.LoadUser("foo@example.com"); err != nil {
+		return err
+	} else if !bytes.Equal(userData.Reg, simpleUserDataAlt.Reg) {
+		return errors.New("Unexpected reg returned after overwrite")
+	}
+
+	return nil
+}
+
+// TestMostRecentUserEmail tests Storage.MostRecentUserEmail.
+func (s *StorageTest) TestMostRecentUserEmail() error {
+	if err := s.runPreTest(); err != nil {
+		return err
+	}
+	defer s.runPostTest()
+
+	// Should be empty on first run
+	if e := s.MostRecentUserEmail(); e != "" {
+		return fmt.Errorf("Expected empty most recent user on first run, got: %v", e)
+	}
+
+	// If we store user, then that one should be returned
+	if err := s.StoreUser("foo1@example.com", simpleUserData); err != nil {
+		return err
+	}
+	if s.AfterUserEmailStore != nil {
+		s.AfterUserEmailStore("foo1@example.com")
+	}
+	if e := s.MostRecentUserEmail(); e != "foo1@example.com" {
+		return fmt.Errorf("Unexpected most recent email after first store: %v", e)
+	}
+
+	// If we store another user, then that one should be returned
+	if err := s.StoreUser("foo2@example.com", simpleUserDataAlt); err != nil {
+		return err
+	}
+	if s.AfterUserEmailStore != nil {
+		s.AfterUserEmailStore("foo2@example.com")
+	}
+	if e := s.MostRecentUserEmail(); e != "foo2@example.com" {
+		return fmt.Errorf("Unexpected most recent email after user key: %v", e)
+	}
+	return nil
+}

vendor/github.com/mholt/caddy/caddytls/storagetest/storagetest_test.go

@@ -0,0 +1,54 @@
+// Copyright 2015 Light Code Labs, LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package storagetest
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"testing"
+	"time"
+
+	"github.com/mholt/caddy/caddytls"
+)
+
+// TestFileStorage tests the file storage set with the test harness in this
+// package.
+func TestFileStorage(t *testing.T) {
+	emailCounter := 0
+	storageTest := &StorageTest{
+		Storage:  &caddytls.FileStorage{Path: "./testdata"}, // nameLocks isn't made here, but it's okay because the tests don't call TryLock or Unlock
+		PostTest: func() { os.RemoveAll("./testdata") },
+		AfterUserEmailStore: func(email string) error {
+			// We need to change the dir mod time to show a
+			// that certain dirs are newer.
+			emailCounter++
+			fp := filepath.Join("./testdata", "users", email)
+
+			// What we will do is subtract 10 days from today and
+			// then add counter * seconds to make the later
+			// counters newer. We accept that this isn't exactly
+			// how the file storage works because it only changes
+			// timestamps on *newly seen* users, but it achieves
+			// the result that the harness expects.
+			chTime := time.Now().AddDate(0, 0, -10).Add(time.Duration(emailCounter) * time.Second)
+			if err := os.Chtimes(fp, chTime, chTime); err != nil {
+				return fmt.Errorf("Unable to change file time for %v: %v", fp, err)
+			}
+			return nil
+		},
+	}
+	storageTest.Test(t, false)
+}