Exemplo n.º 1
0
func TestGetRealPath(t *testing.T) {
	if runtime.GOOS == "windows" && os.Getenv("CI") == "" {
		t.Skip("Skip TestGetRealPath as os.Symlink needs administrator rights on Windows")
	}

	d1, err := ioutil.TempDir("", "d1")
	defer os.Remove(d1)
	fs := afero.NewOsFs()

	rp1, err := GetRealPath(fs, d1)
	require.NoError(t, err)
	assert.Equal(t, d1, rp1)

	sym := filepath.Join(os.TempDir(), "d1sym")
	err = os.Symlink(d1, sym)
	require.NoError(t, err)
	defer os.Remove(sym)

	rp2, err := GetRealPath(fs, sym)
	require.NoError(t, err)

	// On OS X, the temp folder is itself a symbolic link (to /private...)
	// This has to do for now.
	assert.True(t, strings.HasSuffix(rp2, d1))

}
Exemplo n.º 2
0
Arquivo: app.go Projeto: zqzca/back
// Run the application, start http and scp server.
func Run(appConfig Config) {
	config = appConfig

	// Connect to DB
	db, err := lib.Connect()
	if err != nil {
		fmt.Printf("Failed to connect to db")
		return
	}

	// Logging
	log := logrus.New()
	log.Level = logrus.DebugLevel
	log.Out = os.Stdout
	log.Formatter = &logrus.TextFormatter{}

	// Websockets
	ws := ws.NewServer()

	// Shared dependencies between all controller
	deps := dependencies.Dependencies{
		Fs:     afero.NewOsFs(),
		Logger: log,
		DB:     db,
		WS:     ws,
	}

	ws.Dependencies = &deps
	go ws.Start()

	// // Start SCP
	// scp := scp.Server{}
	// scp.DB = deps.DB
	// scp.Logger = deps.Logger
	// scp.CertPath = "certs/scp.rsa"
	// scp.BindAddr = config.SCPBindAddr
	// go scp.ListenAndServe()

	if config.Secure {
		c := autocert.DirCache("certs")
		m := autocert.Manager{
			Cache:      c,
			Prompt:     autocert.AcceptTOS,
			HostPolicy: autocert.HostWhitelist("x.zqz.ca"),
		}

		s := &http.Server{
			Addr:      config.HTTPBindAddr,
			TLSConfig: &tls.Config{GetCertificate: m.GetCertificate},
		}

		deps.Info("Listening for HTTP1.1 Connections", "addr", ":3001")
		deps.Info("Listening for HTTP2 Connections", "addr", config.HTTPBindAddr)
		go http.ListenAndServe(":3001", secureRedirect())
		s.ListenAndServeTLS("", "")
	} else {
		deps.Info("Listening for HTTP1.1 Connections", "addr", config.HTTPBindAddr)
		http.ListenAndServe(config.HTTPBindAddr, Routes(deps))
	}
}
Exemplo n.º 3
0
func New(config Config, provider Provider) *Exporter {
	return &Exporter{
		Config:   config,
		Fs:       afero.NewOsFs(),
		provider: provider,
	}
}
Exemplo n.º 4
0
func TestFilename(t *testing.T) {
	fs := afero.NewOsFs()
	filename := "lazy_file_reader_test.go"
	rd, err := NewLazyFileReader(fs, filename)
	if err != nil {
		t.Fatalf("NewLazyFileReader %s: %v", filename, err)
	}
	if rd.Filename() != filename {
		t.Errorf("Filename: expected filename %q, got %q", filename, rd.Filename())
	}
}
Exemplo n.º 5
0
func TestNewLazyFileReader(t *testing.T) {
	fs := afero.NewOsFs()
	filename := "itdoesnotexistfile"
	_, err := NewLazyFileReader(fs, filename)
	if err == nil {
		t.Errorf("NewLazyFileReader %s: error expected but no error is returned", filename)
	}

	filename = "lazy_file_reader_test.go"
	_, err = NewLazyFileReader(fs, filename)
	if err != nil {
		t.Errorf("NewLazyFileReader %s: %v", filename, err)
	}
}
Exemplo n.º 6
0
func TestStdlib(t *testing.T) {
	// We need to specify that we read from disk because other tests may have switched
	// the filesystem to MemMap.
	util.AppFs = afero.NewOsFs()

	checkMachines := func(code, expectedCode string, expected ...Machine) {
		ctx := parseTestImport(t, code, expectedCode, "../specs")
		machineResult := Stitch{"", ctx}.QueryMachines()
		if !reflect.DeepEqual(machineResult, expected) {
			t.Error(spew.Sprintf("test: %s, result: %v, expected: %v",
				code, machineResult, expected))
		}
	}

	code := `(import "stdlib/machines")
	         (machines.Boot
	           1
	           2
			   (list (provider "Amazon")
					 (size "m4.large")
					 (sshkey "key")))`
	expCode := `(module "machines" (list)
                (list)
                (list)
                (list))
                (list (machine (provider "Amazon") (size "m4.large") (role "Master")
                        (sshkey "key"))
                      (machine (provider "Amazon") (size "m4.large") (role "Worker")
                        (sshkey "key"))
                      (machine (provider "Amazon") (size "m4.large") (role "Worker")
                        (sshkey "key")))`
	expMachines := []Machine{
		{Provider: "Amazon",
			Size:    "m4.large",
			Role:    "Master",
			SSHKeys: []string{"key"},
		},
		{Provider: "Amazon",
			Size:    "m4.large",
			Role:    "Worker",
			SSHKeys: []string{"key"},
		},
		{Provider: "Amazon",
			Size:    "m4.large",
			Role:    "Worker",
			SSHKeys: []string{"key"},
		},
	}
	checkMachines(code, expCode, expMachines...)
}
Exemplo n.º 7
0
func init() {

	// file system
	filesystem := afero.NewOsFs()

	// locate the home directory
	userHomeDir, homeDirError := homedir.Dir()
	if homeDirError != nil {
		fmt.Fprintf(os.Stderr, "Unable to determine home directory: %s\n", homeDirError.Error())
		os.Exit(1)
	}

	// base folder
	baseFolder := getSettingsFolder(filesystem, userHomeDir)

	// credential store
	credentialFilePath := filepath.Join(baseFolder, "credentials.json")
	credentialStore := filesystemCredentialStore{filesystem, credentialFilePath}

	// DNS client factory
	dnsClientFactory := dnsimpleClientFactory{credentialStore}

	// create DNSimple info provider
	dnsInfoProviderFactory := dnsimpleInfoProviderFactory{dnsClientFactory}

	// create a DNS editor instance
	dnsEditorFactory := dnsEditorFactory{dnsClientFactory, dnsInfoProviderFactory}

	actions = []action{
		loginAction{credentialStore},
		logoutAction{credentialStore},
		listAction{dnsInfoProviderFactory},
		createAction{dnsEditorFactory, os.Stdin},
		updateAction{dnsEditorFactory, os.Stdin},
		deleteAction{dnsEditorFactory},
		createOrUpdateAction{dnsEditorFactory, dnsInfoProviderFactory, os.Stdin},
	}

	// override the help information printer
	// of the flag package
	executablePath := os.Args[0]
	executableName := path.Base(executablePath)
	usagePrinter := newUsagePrinter(executableName, version(), actions)

	flag.Usage = func() {
		usagePrinter.PrintUsageInformation(os.Stdout)
	}

}
Exemplo n.º 8
0
// Returns an initialized Viper instance.
func New() *Viper {
	v := new(Viper)
	v.keyDelim = "."
	v.configName = "config"
	v.fs = afero.NewOsFs()
	v.config = make(map[string]interface{})
	v.override = make(map[string]interface{})
	v.defaults = make(map[string]interface{})
	v.kvstore = make(map[string]interface{})
	v.pflags = make(map[string]FlagValue)
	v.env = make(map[string]string)
	v.aliases = make(map[string]string)
	v.typeByDefValue = false

	return v
}
Exemplo n.º 9
0
func TestWriteTo(t *testing.T) {
	fs := afero.NewOsFs()
	filename := "lazy_file_reader_test.go"
	fi, err := fs.Stat(filename)
	if err != nil {
		t.Fatalf("os.Stat: %v", err)
	}

	b, err := afero.ReadFile(fs, filename)
	if err != nil {
		t.Fatalf("afero.ReadFile: %v", err)
	}

	rd, err := NewLazyFileReader(fs, filename)
	if err != nil {
		t.Fatalf("NewLazyFileReader %s: %v", filename, err)
	}

	tst := func(testcase string, expectedSize int64, checkEqual bool) {
		buf := bytes.NewBuffer(make([]byte, 0, bytes.MinRead))
		n, err := rd.WriteTo(buf)
		if err != nil {
			t.Fatalf("WriteTo %s case: %v", testcase, err)
		}
		if n != expectedSize {
			t.Errorf("WriteTo %s case: written bytes length expected %d, got %d", testcase, expectedSize, n)
		}
		if checkEqual && !bytes.Equal(b, buf.Bytes()) {
			t.Errorf("WriteTo %s case: written bytes are different from expected", testcase)
		}
	}
	tst("No cache", fi.Size(), true)
	tst("No cache 2nd", 0, false)

	p := make([]byte, fi.Size())
	_, err = rd.Read(p)
	if err != nil && err != io.EOF {
		t.Fatalf("Read: %v", err)
	}
	_, err = rd.Seek(0, 0)
	if err != nil {
		t.Fatalf("Seek: %v", err)
	}

	tst("Cache", fi.Size(), true)
}
Exemplo n.º 10
0
func TestRead(t *testing.T) {
	fs := afero.NewOsFs()
	filename := "lazy_file_reader_test.go"
	fi, err := fs.Stat(filename)
	if err != nil {
		t.Fatalf("os.Stat: %v", err)
	}

	b, err := afero.ReadFile(fs, filename)
	if err != nil {
		t.Fatalf("afero.ReadFile: %v", err)
	}

	rd, err := NewLazyFileReader(fs, filename)
	if err != nil {
		t.Fatalf("NewLazyFileReader %s: %v", filename, err)
	}

	tst := func(testcase string) {
		p := make([]byte, fi.Size())
		n, err := rd.Read(p)
		if err != nil {
			t.Fatalf("Read %s case: %v", testcase, err)
		}
		if int64(n) != fi.Size() {
			t.Errorf("Read %s case: read bytes length expected %d, got %d", testcase, fi.Size(), n)
		}
		if !bytes.Equal(b, p) {
			t.Errorf("Read %s case: read bytes are different from expected", testcase)
		}
	}
	tst("No cache")
	_, err = rd.Seek(0, 0)
	if err != nil {
		t.Fatalf("Seek: %v", err)
	}
	tst("Cache")
}
Exemplo n.º 11
0
func TestSeek(t *testing.T) {
	type testcase struct {
		seek     int
		offset   int64
		length   int
		moveto   int64
		expected []byte
	}
	fs := afero.NewOsFs()
	filename := "lazy_file_reader_test.go"
	b, err := afero.ReadFile(fs, filename)
	if err != nil {
		t.Fatalf("afero.ReadFile: %v", err)
	}

	// no cache case
	for i, this := range []testcase{
		{seek: os.SEEK_SET, offset: 0, length: 10, moveto: 0, expected: b[:10]},
		{seek: os.SEEK_SET, offset: 5, length: 10, moveto: 5, expected: b[5:15]},
		{seek: os.SEEK_CUR, offset: 5, length: 10, moveto: 5, expected: b[5:15]}, // current pos = 0
		{seek: os.SEEK_END, offset: -1, length: 1, moveto: int64(len(b) - 1), expected: b[len(b)-1:]},
		{seek: 3, expected: nil},
		{seek: os.SEEK_SET, offset: -1, expected: nil},
	} {
		rd, err := NewLazyFileReader(fs, filename)
		if err != nil {
			t.Errorf("[%d] NewLazyFileReader %s: %v", i, filename, err)
			continue
		}

		pos, err := rd.Seek(this.offset, this.seek)
		if this.expected == nil {
			if err == nil {
				t.Errorf("[%d] Seek didn't return an expected error", i)
			}
		} else {
			if err != nil {
				t.Errorf("[%d] Seek failed unexpectedly: %v", i, err)
				continue
			}
			if pos != this.moveto {
				t.Errorf("[%d] Seek failed to move the pointer: got %d, expected: %d", i, pos, this.moveto)
			}

			buf := make([]byte, this.length)
			n, err := rd.Read(buf)
			if err != nil {
				t.Errorf("[%d] Read failed unexpectedly: %v", i, err)
			}
			if !bytes.Equal(this.expected, buf[:n]) {
				t.Errorf("[%d] Seek and Read got %q but expected %q", i, buf[:n], this.expected)
			}
		}
	}

	// cache case
	rd, err := NewLazyFileReader(fs, filename)
	if err != nil {
		t.Fatalf("NewLazyFileReader %s: %v", filename, err)
	}
	dummy := make([]byte, len(b))
	_, err = rd.Read(dummy)
	if err != nil {
		t.Fatalf("Read failed unexpectedly: %v", err)
	}

	for i, this := range []testcase{
		{seek: os.SEEK_SET, offset: 0, length: 10, moveto: 0, expected: b[:10]},
		{seek: os.SEEK_SET, offset: 5, length: 10, moveto: 5, expected: b[5:15]},
		{seek: os.SEEK_CUR, offset: 1, length: 10, moveto: 16, expected: b[16:26]}, // current pos = 15
		{seek: os.SEEK_END, offset: -1, length: 1, moveto: int64(len(b) - 1), expected: b[len(b)-1:]},
		{seek: 3, expected: nil},
		{seek: os.SEEK_SET, offset: -1, expected: nil},
	} {
		pos, err := rd.Seek(this.offset, this.seek)
		if this.expected == nil {
			if err == nil {
				t.Errorf("[%d] Seek didn't return an expected error", i)
			}
		} else {
			if err != nil {
				t.Errorf("[%d] Seek failed unexpectedly: %v", i, err)
				continue
			}
			if pos != this.moveto {
				t.Errorf("[%d] Seek failed to move the pointer: got %d, expected: %d", i, pos, this.moveto)
			}

			buf := make([]byte, this.length)
			n, err := rd.Read(buf)
			if err != nil {
				t.Errorf("[%d] Read failed unexpectedly: %v", i, err)
			}
			if !bytes.Equal(this.expected, buf[:n]) {
				t.Errorf("[%d] Seek and Read got %q but expected %q", i, buf[:n], this.expected)
			}
		}
	}
}
Exemplo n.º 12
0
Arquivo: util.go Projeto: NetSys/quilt
	ed := 0
	for _, label := range b {
		if _, ok := amap[label]; ok {
			delete(amap, label)
		} else {
			ed++
		}
	}

	ed += len(amap)
	return ed
}

// AppFs is an aero filesystem.  It is stored in a variable so that we can replace it
// with in-memory filesystems for unit tests.
var AppFs = afero.NewOsFs()

// Open opens a new aero file.
func Open(path string) (afero.File, error) {
	return AppFs.Open(path)
}

// WriteFile writes 'data' to the file 'filename' with the given permissions.
func WriteFile(filename string, data []byte, perm os.FileMode) error {
	a := afero.Afero{
		Fs: AppFs,
	}
	return a.WriteFile(filename, data, perm)
}

// ReadFile returns the contents of `filename`.
Exemplo n.º 13
0
Arquivo: io.go Projeto: NetSys/quilt
	"errors"
	"fmt"
	"io/ioutil"
	"net/http"
	"os"
	"os/exec"
	"path/filepath"
	"time"

	"github.com/Sirupsen/logrus"
	"github.com/spf13/afero"
)

// appFs is an aero filesystem.  It is stored in a variable so that we can replace it
// with in-memory filesystems for unit tests.
var appFs = afero.NewOsFs()

type logger struct {
	rootDir      string
	cmdLogger    fileLogger
	testerLogger fileLogger
	ip           string
}

// Creates a new fileLogger for the given test, in the appropriate
// "passed" or "failed" directory.
func (l logger) testLogger(passed bool, testName string) fileLogger {
	filename := fmt.Sprintf("%s.txt", testName)
	folder := filepath.Join(l.rootDir, "passed")
	if !passed {
		folder = filepath.Join(l.rootDir, "failed")