func (p linux) SetupDataDir() error {
dataDir := p.dirProvider.DataDir()
sysDir := filepath.Join(dataDir, "sys")
logDir := filepath.Join(sysDir, "log")
err := p.fs.MkdirAll(logDir, os.FileMode(0750))
if err != nil {
return bosherr.WrapError(err, "Making %s dir", logDir)
}
_, _, _, err = p.cmdRunner.RunCommand("chown", "root:vcap", sysDir)
if err != nil {
return bosherr.WrapError(err, "chown %s", sysDir)
}
_, _, _, err = p.cmdRunner.RunCommand("chown", "root:vcap", logDir)
if err != nil {
return bosherr.WrapError(err, "chown %s", logDir)
}
runDir := filepath.Join(sysDir, "run")
err = p.fs.MkdirAll(runDir, os.FileMode(0750))
if err != nil {
return bosherr.WrapError(err, "Making %s dir", runDir)
}
_, _, _, err = p.cmdRunner.RunCommand("chown", "root:vcap", runDir)
if err != nil {
return bosherr.WrapError(err, "chown %s", runDir)
}
return nil
}
func TestExecutor_MakeExecutable(t *testing.T) {
// Create a temp file
f, err := ioutil.TempFile("", "")
if err != nil {
t.Fatal(err)
}
defer f.Close()
defer os.Remove(f.Name())
// Set its permissions to be non-executable
f.Chmod(os.FileMode(0610))
// Make a fake exececutor
ctx := testExecutorContext(t)
defer ctx.AllocDir.Destroy()
executor := NewExecutor(log.New(os.Stdout, "", log.LstdFlags))
err = executor.(*UniversalExecutor).makeExecutable(f.Name())
if err != nil {
t.Fatalf("makeExecutable() failed: %v", err)
}
// Check the permissions
stat, err := f.Stat()
if err != nil {
t.Fatalf("Stat() failed: %v", err)
}
act := stat.Mode().Perm()
exp := os.FileMode(0755)
if act != exp {
t.Fatalf("expected permissions %v; got %v", err)
}
}
// sameConfig reports whether src and dest config files are equal.
// Two config files are equal when they have the same file contents and
// Unix permissions. The owner, group, and mode must match.
// It return false in other cases.
func sameConfig(src, dest string) (bool, error) {
if !isFileExist(dest) {
return false, nil
}
d, err := fileStat(dest)
if err != nil {
return false, err
}
s, err := fileStat(src)
if err != nil {
return false, err
}
if d.Uid != s.Uid {
log.Info(fmt.Sprintf("%s has UID %d should be %d", dest, d.Uid, s.Uid))
}
if d.Gid != s.Gid {
log.Info(fmt.Sprintf("%s has GID %d should be %d", dest, d.Gid, s.Gid))
}
if d.Mode != s.Mode {
log.Info(fmt.Sprintf("%s has mode %s should be %s", dest, os.FileMode(d.Mode), os.FileMode(s.Mode)))
}
if d.Md5 != s.Md5 {
log.Info(fmt.Sprintf("%s has md5sum %s should be %s", dest, d.Md5, s.Md5))
}
if d.Uid != s.Uid || d.Gid != s.Gid || d.Mode != s.Mode || d.Md5 != s.Md5 {
return false, nil
}
return true, nil
}
func (r *RestoreSuite) createTestFiles(c *gc.C) {
tarDirE := path.Join(r.cwd, "TarDirectoryEmpty")
err := os.Mkdir(tarDirE, os.FileMode(0755))
c.Check(err, jc.ErrorIsNil)
tarDirP := path.Join(r.cwd, "TarDirectoryPopulated")
err = os.Mkdir(tarDirP, os.FileMode(0755))
c.Check(err, jc.ErrorIsNil)
tarSubFile1 := path.Join(tarDirP, "TarSubFile1")
tarSubFile1Handle, err := os.Create(tarSubFile1)
c.Check(err, jc.ErrorIsNil)
tarSubFile1Handle.WriteString("TarSubFile1")
tarSubFile1Handle.Close()
tarSubDir := path.Join(tarDirP, "TarDirectoryPopulatedSubDirectory")
err = os.Mkdir(tarSubDir, os.FileMode(0755))
c.Check(err, jc.ErrorIsNil)
tarFile1 := path.Join(r.cwd, "TarFile1")
tarFile1Handle, err := os.Create(tarFile1)
c.Check(err, jc.ErrorIsNil)
tarFile1Handle.WriteString("TarFile1")
tarFile1Handle.Close()
tarFile2 := path.Join(r.cwd, "TarFile2")
tarFile2Handle, err := os.Create(tarFile2)
c.Check(err, jc.ErrorIsNil)
tarFile2Handle.WriteString("TarFile2")
tarFile2Handle.Close()
r.testFiles = []string{tarDirE, tarDirP, tarFile1, tarFile2}
}
func createDevices() error {
err := os.MkdirAll(pathPrefix, 644)
if err != nil {
log.Warnf("Failed to ensure presence of tether device directory: %s", err)
}
// create serial devices
for i := 0; i < 3; i++ {
path := fmt.Sprintf("%s/ttyS%d", pathPrefix, i)
minor := 64 + i
err = syscall.Mknod(path, syscall.S_IFCHR|uint32(os.FileMode(0660)), tether.Mkdev(4, minor))
if err != nil {
return fmt.Errorf("failed to create %s for com%d: %s", path, i+1, err)
}
}
// make an access to urandom
path := fmt.Sprintf("%s/urandom", pathPrefix)
err = syscall.Mknod(path, syscall.S_IFCHR|uint32(os.FileMode(0444)), tether.Mkdev(1, 9))
if err != nil {
return fmt.Errorf("failed to create urandom access %s: %s", path, err)
}
return nil
}
// Write the pidfile based on the flag. It is an error if the pidfile hasn't
// been configured.
func Write() error {
if *pidfile == "" {
return errNotConfigured
}
if err := os.MkdirAll(filepath.Dir(*pidfile), os.FileMode(0755)); err != nil {
return err
}
file, err := atomicfile.New(*pidfile, os.FileMode(0644))
if err != nil {
return fmt.Errorf("error opening pidfile %s: %s", *pidfile, err)
}
defer file.Close() // in case we fail before the explicit close
_, err = fmt.Fprintf(file, "%d", os.Getpid())
if err != nil {
return err
}
err = file.Close()
if err != nil {
return err
}
return nil
}
// Close writes symlinks and dirs of the container, then closes
// the zip writer.
func (zwp *ZipWriterPool) Close() error {
for _, symlink := range zwp.container.Symlinks {
fh := zip.FileHeader{
Name: symlink.Path,
}
fh.SetMode(os.FileMode(symlink.Mode))
entryWriter, eErr := zwp.zw.CreateHeader(&fh)
if eErr != nil {
return errors.Wrap(eErr, 1)
}
entryWriter.Write([]byte(symlink.Dest))
}
for _, dir := range zwp.container.Dirs {
fh := zip.FileHeader{
Name: dir.Path + "/",
}
fh.SetMode(os.FileMode(dir.Mode))
fh.SetModTime(time.Now())
_, hErr := zwp.zw.CreateHeader(&fh)
if hErr != nil {
return errors.Wrap(hErr, 1)
}
}
err := zwp.zw.Close()
if err != nil {
return errors.Wrap(err, 1)
}
return nil
}
func (t *FlagsTest) Defaults() {
f := parseArgs([]string{})
// File system
ExpectNe(nil, f.MountOptions)
ExpectEq(0, len(f.MountOptions), "Options: %v", f.MountOptions)
ExpectEq(os.FileMode(0755), f.DirMode)
ExpectEq(os.FileMode(0644), f.FileMode)
ExpectEq(-1, f.Uid)
ExpectEq(-1, f.Gid)
ExpectFalse(f.ImplicitDirs)
// GCS
ExpectEq("", f.KeyFile)
ExpectEq(-1, f.EgressBandwidthLimitBytesPerSecond)
ExpectEq(5, f.OpRateLimitHz)
// Tuning
ExpectEq(time.Minute, f.StatCacheTTL)
ExpectEq(time.Minute, f.TypeCacheTTL)
ExpectEq(1<<24, f.GCSChunkSize)
ExpectEq("", f.TempDir)
ExpectEq(1<<31, f.TempDirLimit)
// Debugging
ExpectFalse(f.DebugCPUProfile)
ExpectFalse(f.DebugFuse)
ExpectFalse(f.DebugGCS)
ExpectFalse(f.DebugHTTP)
ExpectFalse(f.DebugInvariants)
ExpectFalse(f.DebugMemProfile)
}
func TestSetPermissions(t *testing.T) {
testPerm := 0755
resp, err := remote.Tell("setPermissions", struct {
Path string
Mode os.FileMode
Recursive bool
}{
Path: testfile1,
Mode: os.FileMode(testPerm),
})
if err != nil {
t.Fatal(err)
}
if !resp.MustBool() {
t.Fatal("setPermissions should return true")
}
f, err := os.Open(testfile1)
if err != nil {
t.Fatal(err)
}
fi, err := f.Stat()
if err != nil {
t.Fatal(err)
}
if fi.Mode() != os.FileMode(testPerm) {
t.Errorf("got %v expecting %v", fi.Mode(), testPerm)
}
}
func ProcessWriteFile(base string, wf *WriteFile) error {
fullPath := path.Join(base, wf.Path)
if err := os.MkdirAll(path.Dir(fullPath), os.FileMode(0744)); err != nil {
return err
}
// Parse string representation of file mode as octal
perm, err := strconv.ParseInt(wf.Permissions, 8, 32)
if err != nil {
return errors.New("Unable to parse file permissions as octal integer")
}
if err := ioutil.WriteFile(fullPath, []byte(wf.Content), os.FileMode(perm)); err != nil {
return err
}
if wf.Owner != "" {
// We shell out since we don't have a way to look up unix groups natively
cmd := exec.Command("chown", wf.Owner, fullPath)
if err := cmd.Run(); err != nil {
return err
}
}
return nil
}
// Add the flags accepted by run to the supplied flag set, returning the
// variables into which the flags will parse.
func populateFlags(c *cli.Context) (flags *flagStorage) {
flags = &flagStorage{
// File system
MountOptions: make(map[string]string),
DirMode: os.FileMode(c.Int("dir-mode")),
FileMode: os.FileMode(c.Int("file-mode")),
Uid: int64(c.Int("uid")),
Gid: int64(c.Int("gid")),
// GCS,
KeyFile: c.String("key-file"),
EgressBandwidthLimitBytesPerSecond: c.Float64("limit-bytes-per-sec"),
OpRateLimitHz: c.Float64("limit-ops-per-sec"),
// Tuning,
StatCacheTTL: c.Duration("stat-cache-ttl"),
TypeCacheTTL: c.Duration("type-cache-ttl"),
TempDir: c.String("temp-dir"),
ImplicitDirs: c.Bool("implicit-dirs"),
// Debugging,
DebugFuse: c.Bool("debug_fuse"),
DebugGCS: c.Bool("debug_gcs"),
DebugHTTP: c.Bool("debug_http"),
DebugInvariants: c.Bool("debug_invariants"),
}
// Handle the repeated "-o" flag.
for _, o := range c.StringSlice("o") {
mountpkg.ParseOptions(flags.MountOptions, o)
}
return
}
func TestUbuntuSetupSsh(t *testing.T) {
fakeFs, fakeCmdRunner, fakePartitioner, fakeFormatter := getUbuntuDependencies()
fakeFs.HomeDirHomeDir = "/some/home/dir"
ubuntu := newUbuntuPlatform(fakeFs, fakeCmdRunner, fakePartitioner, fakeFormatter)
ubuntu.SetupSsh("some public key", "vcap")
sshDirPath := "/some/home/dir/.ssh"
sshDirStat := fakeFs.GetFileTestStat(sshDirPath)
assert.Equal(t, fakeFs.HomeDirUsername, "vcap")
assert.NotNil(t, sshDirStat)
assert.Equal(t, sshDirStat.CreatedWith, "MkdirAll")
assert.Equal(t, sshDirStat.FileMode, os.FileMode(0700))
assert.Equal(t, sshDirStat.Username, "vcap")
authKeysStat := fakeFs.GetFileTestStat(filepath.Join(sshDirPath, "authorized_keys"))
assert.NotNil(t, authKeysStat)
assert.Equal(t, authKeysStat.CreatedWith, "WriteToFile")
assert.Equal(t, authKeysStat.FileMode, os.FileMode(0600))
assert.Equal(t, authKeysStat.Username, "vcap")
assert.Equal(t, authKeysStat.Content, "some public key")
}
func createDevices(rootDir string, uid, gid int) error {
nullDir := fp.Join(rootDir, os.DevNull)
if err := osutil.Mknod(nullDir, syscall.S_IFCHR|uint32(os.FileMode(0666)), 1*256+3); err != nil {
return err
}
if err := os.Lchown(nullDir, uid, gid); err != nil {
return errwrap.Wrapff(err, "Failed to lchown %s: {{err}}", nullDir)
}
zeroDir := fp.Join(rootDir, "/dev/zero")
if err := osutil.Mknod(zeroDir, syscall.S_IFCHR|uint32(os.FileMode(0666)), 1*256+3); err != nil {
return err
}
if err := os.Lchown(zeroDir, uid, gid); err != nil {
return errwrap.Wrapff(err, "Failed to lchown %s:", zeroDir)
}
for _, f := range []string{"/dev/random", "/dev/urandom"} {
randomDir := fp.Join(rootDir, f)
if err := osutil.Mknod(randomDir, syscall.S_IFCHR|uint32(os.FileMode(0666)), 1*256+9); err != nil {
return err
}
if err := os.Lchown(randomDir, uid, gid); err != nil {
return errwrap.Wrapff(err, "Failed to lchown %s: {{err}}", randomDir)
}
}
return nil
}
func WritePidfile(pidfile string, pid int) error {
if pidfile == "" {
return errors.New("pidfile not configured")
}
if err := os.MkdirAll(filepath.Dir(pidfile), os.FileMode(0755)); err != nil {
return err
}
file, err := atomicfile.New(pidfile, os.FileMode(0644))
if err != nil {
return fmt.Errorf("error opening pidfile %s: %s", pidfile, err)
}
defer file.Close()
_, err = fmt.Fprintf(file, "%d", pid)
if err != nil {
return err
}
err = file.Close()
if err != nil {
return err
}
return nil
}
func TestWriterReset(t *testing.T) {
b := new(bytes.Buffer)
w := NewWriter(b)
for i := 0; i < 2; i++ {
debian := &fileInfo{
name: "debian-binary",
mtime: time.Unix(1385068169, 0),
mode: os.FileMode(0100644) & os.ModePerm,
size: 4,
}
if _, err := w.WriteFile(debian, strings.NewReader("2.0\n")); err != nil {
t.Errorf("%d: %q", i, err)
return
}
control := &fileInfo{
name: "control.tar.gz",
mtime: time.Unix(1385068169, 0),
mode: os.FileMode(0100644) & os.ModePerm,
size: 0,
}
if _, err := w.WriteFile(control, strings.NewReader("")); err != nil {
t.Errorf("%d: %q", i, err)
return
}
if archive := b.String(); archive != testCommon {
t.Errorf("%d: got\n%q\nwant\n%q", i, archive, testCommon)
}
b.Reset()
w.Reset(b)
}
}
func make_file(store *FileStore, name string, contents string) {
file_location := store.OsPath(CloudPath(name))
os.MkdirAll(path.Dir(file_location), os.FileMode(0777))
if err := ioutil.WriteFile(file_location, []byte(contents), os.FileMode(0666)); err != nil {
log.Panic(err.Error())
}
}
// GenerateSelfSignedCert creates a self-signed certificate and key for the given host.
// Host may be an IP or a DNS name
// The certificate will be created with file mode 0644. The key will be created with file mode 0600.
// If the certificate or key files already exist, they will be overwritten.
// Any parent directories of the certPath or keyPath will be created as needed with file mode 0755.
func GenerateSelfSignedCert(host, certPath, keyPath string) error {
priv, err := rsa.GenerateKey(rand.Reader, 2048)
if err != nil {
return err
}
template := x509.Certificate{
SerialNumber: big.NewInt(1),
Subject: pkix.Name{
CommonName: fmt.Sprintf("%s@%d", host, time.Now().Unix()),
},
NotBefore: time.Now(),
NotAfter: time.Now().Add(time.Hour * 24 * 365),
KeyUsage: x509.KeyUsageKeyEncipherment | x509.KeyUsageDigitalSignature,
ExtKeyUsage: []x509.ExtKeyUsage{x509.ExtKeyUsageServerAuth},
BasicConstraintsValid: true,
}
if ip := net.ParseIP(host); ip != nil {
template.IPAddresses = append(template.IPAddresses, ip)
} else {
template.DNSNames = append(template.DNSNames, host)
}
derBytes, err := x509.CreateCertificate(rand.Reader, &template, &template, &priv.PublicKey, priv)
if err != nil {
return err
}
// Generate cert
certBuffer := bytes.Buffer{}
if err := pem.Encode(&certBuffer, &pem.Block{Type: "CERTIFICATE", Bytes: derBytes}); err != nil {
return err
}
// Generate key
keyBuffer := bytes.Buffer{}
if err := pem.Encode(&keyBuffer, &pem.Block{Type: "RSA PRIVATE KEY", Bytes: x509.MarshalPKCS1PrivateKey(priv)}); err != nil {
return err
}
// Write cert
if err := os.MkdirAll(filepath.Dir(certPath), os.FileMode(0755)); err != nil {
return err
}
if err := ioutil.WriteFile(certPath, certBuffer.Bytes(), os.FileMode(0644)); err != nil {
return err
}
// Write key
if err := os.MkdirAll(filepath.Dir(keyPath), os.FileMode(0755)); err != nil {
return err
}
if err := ioutil.WriteFile(keyPath, keyBuffer.Bytes(), os.FileMode(0600)); err != nil {
return err
}
return nil
}
func uploadBuildpackRequest(filename string) testnet.TestRequest {
return testnet.TestRequest{
Method: "PUT",
Path: "/v2/buildpacks/my-cool-buildpack-guid/bits",
Response: testnet.TestResponse{
Status: http.StatusCreated,
Body: `{ "metadata":{ "guid": "my-job-guid" } }`,
},
Matcher: func(request *http.Request) {
err := request.ParseMultipartForm(4096)
defer request.MultipartForm.RemoveAll()
Expect(err).NotTo(HaveOccurred())
Expect(len(request.MultipartForm.Value)).To(Equal(0))
Expect(len(request.MultipartForm.File)).To(Equal(1))
files, ok := request.MultipartForm.File["buildpack"]
Expect(ok).To(BeTrue(), "Buildpack file part not present")
Expect(len(files)).To(Equal(1), "Wrong number of files")
buildpackFile := files[0]
Expect(buildpackFile.Filename).To(Equal(filepath.Base(filename)), "Wrong file name")
file, err := buildpackFile.Open()
Expect(err).NotTo(HaveOccurred())
zipReader, err := zip.NewReader(file, 4096)
Expect(err).NotTo(HaveOccurred())
actualFileNames := []string{}
actualFileContents := []string{}
for _, f := range zipReader.File {
actualFileNames = append(actualFileNames, f.Name)
c, _ := f.Open()
content, _ := ioutil.ReadAll(c)
actualFileContents = append(actualFileContents, string(content))
}
sort.Strings(actualFileNames)
Expect(actualFileNames).To(Equal([]string{
"bin/compile",
"bin/detect",
"bin/release",
"lib/helper",
}))
Expect(actualFileContents).To(Equal([]string{
"the-compile-script\n",
"the-detect-script\n",
"the-release-script\n",
"the-helper-script\n",
}))
if runtime.GOOS != "windows" {
Expect(zipReader.File[0].Mode()).To(Equal(os.FileMode(0755)))
Expect(zipReader.File[1].Mode()).To(Equal(os.FileMode(0755)))
Expect(zipReader.File[2].Mode()).To(Equal(os.FileMode(0755)))
}
},
}
}
func WriteFile(src io.Reader, targetFile string, permFile, uid, gid int) error {
targetDir := filepath.Dir(targetFile)
permDir := permFile | 0111
if stat, err := os.Stat(targetDir); err != nil {
if os.IsNotExist(err) {
err = os.MkdirAll(targetDir, os.FileMode(permDir))
}
if err != nil {
return err
}
} else if !stat.IsDir() {
return errors.New("File target is not a dir: " + targetDir)
}
f, err := os.OpenFile(targetFile, os.O_RDWR|os.O_CREATE, os.FileMode(permFile))
if err != nil {
return err
}
defer f.Close()
_, err = io.Copy(f, src)
if err != nil {
return err
}
if err = syscall.Chown(targetFile, uid, gid); err != nil {
return err
}
return nil
}
func update(p string, f os.FileInfo, err error) error {
// Check the file mode.
if f.IsDir() {
m := os.FileMode(*cliChmodDir)
if f.Mode().Perm() != m.Perm() {
err := os.Chmod(p, m)
if err != nil {
log.Printf("Failed to chmod directory: %s", p)
}
log.Printf("Updated chmod directory: %s", p)
}
} else {
m := os.FileMode(*cliChmodFile)
if f.Mode().Perm() != m.Perm() {
err := os.Chmod(p, m)
if err != nil {
log.Printf("Failed to chmod file: %s", p)
}
log.Printf("Updated chmod file: %s", p)
}
}
// Check the file owner.
fu := f.Sys().(*syscall.Stat_t).Uid
fg := f.Sys().(*syscall.Stat_t).Gid
if int(fu) != uid && int(fg) != gid {
err := os.Chown(p, uid, gid)
if err != nil {
log.Printf("Failed to chown file: %s", p)
}
log.Printf("Updated chown file: %s", p)
}
return nil
}
// Mount mounts the remote at mountpoint.
//
// If noModTime is set then it
func Mount(f fs.Fs, mountpoint string) error {
if debugFUSE {
fuse.Debug = func(msg interface{}) {
fs.Debug("fuse", "%v", msg)
}
}
// Set permissions
dirPerms = 0777 &^ os.FileMode(umask)
filePerms = 0666 &^ os.FileMode(umask)
// Show stats if the user has specifically requested them
if cmd.ShowStats() {
stopStats := cmd.StartStats()
defer close(stopStats)
}
// Mount it
errChan, err := mount(f, mountpoint)
if err != nil {
return errors.Wrap(err, "failed to mount FUSE fs")
}
// Wait for umount
err = <-errChan
if err != nil {
return errors.Wrap(err, "failed to umount FUSE fs")
}
return nil
}
func (p *instanceManager) SaveMetadata(instanceName string, metadata instanceMetadata) (err error) {
if instanceName == "" {
err = ERR_INSTANCE_NAME_IS_EMPTY.New()
return
}
instanceHome := getInstanceHome(instanceName)
if e := os.MkdirAll(instanceHome, os.FileMode(0755)); e != nil {
err = ERR_INSTANCE_HOME_CREATE_FAILED.New(errors.Params{"dir": instanceHome})
return
}
metadata.UpdateTime = time.Now()
strMeta := ""
if strMeta, err = metadata.Serialize(); err != nil {
return
}
if e := ioutil.WriteFile(instanceHome+"/metadata", []byte(strMeta), os.FileMode(0644)); e != nil {
err = ERR_SAVE_INSTANCE_METADATA_FAILED.New(errors.Params{"name": instanceName, "err": e})
return
}
return
}
func TestReadLocalMachineIDFound(t *testing.T) {
dir, err := ioutil.TempDir(os.TempDir(), "fleet-")
if err != nil {
t.Fatalf("Failed creating tempdir: %v", err)
}
defer os.RemoveAll(dir)
tmpMachineIDPath := filepath.Join(dir, "/etc/machine-id")
err = os.MkdirAll(filepath.Dir(tmpMachineIDPath), os.FileMode(0755))
if err != nil {
t.Fatalf("Failed setting up fake mach ID path: %v", err)
}
err = ioutil.WriteFile(tmpMachineIDPath, []byte("pingpong"), os.FileMode(0644))
if err != nil {
t.Fatalf("Failed writing fake mach ID file: %v", err)
}
machID, err := readLocalMachineID(dir)
if err != nil {
t.Fatalf("Unexpected error reading machID: %v", err)
}
if machID != "pingpong" {
t.Fatalf("Received incorrect machID %q, expected 'pingpong'", machID)
}
}
func TestFileInfo(t *testing.T) {
f, err := os.Open(arTest[0].file)
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
defer f.Close()
ar := NewReader(f)
hdr, err := ar.Next()
if err != nil || hdr == nil {
t.Fatalf("didn't get first file: %v", err)
}
fi := hdr.FileInfo()
if name := fi.Name(); name != hdr.Name {
t.Errorf("fi.Name() = %v; want %v", name, hdr.Name)
}
if size := fi.Size(); size != hdr.Size {
t.Errorf("fi.Size() = %v; want %v", size, hdr.Size)
}
if mode := fi.Mode(); mode != os.FileMode(hdr.Mode).Perm() {
t.Errorf("fi.Mode() = %v; want %v", mode, os.FileMode(hdr.Mode).Perm())
}
if modTime := fi.ModTime(); modTime != hdr.ModTime {
t.Errorf("fi.ModTime() = %v; want %v", modTime, hdr.ModTime)
}
if isDir := fi.IsDir(); isDir != false {
t.Errorf("fi.IsDir() = %v; want %v", isDir, false)
}
}
func TestHeaderCreationFromExistingFile(t *testing.T) {
tmpFile, err := ioutil.TempFile("", "empty")
if err != nil {
t.Error(err)
return
}
defer tmpFile.Close()
err = tmpFile.Chmod(os.FileMode(0644))
if err != nil {
t.Error(err)
return
}
defer os.Remove(tmpFile.Name())
expected := &Operation{
Mode: os.FileMode(0644),
Size: 0,
Name: filepath.Base(tmpFile.Name()),
}
actual, err := OpenFile(tmpFile.Name(), os.O_RDONLY, 0)
if err != nil {
t.Error(err)
return
}
defer actual.Close()
err = checkHeader(expected, actual)
if err != nil {
t.Error(err)
return
}
}
func TestFileInfo(t *testing.T) {
test := &fileInfo{
name: "debian-binary",
mtime: time.Unix(1385068169, 0),
mode: os.FileMode(0644),
size: 4,
}
if test.IsDir() != false {
t.Error("IsDir")
}
if test.Mode() != os.FileMode(0644) {
t.Error("Mode")
}
if test.ModTime() != time.Unix(1385068169, 0) {
t.Error("ModTime")
}
if test.Name() != "debian-binary" {
t.Error("Name")
}
if test.Size() != 4 {
t.Error("Size")
}
if test.Sys() != nil {
t.Error("Sys")
}
}
// Add the flags accepted by run to the supplied flag set, returning the
// variables into which the flags will parse.
func PopulateFlags(c *cli.Context) (flags *FlagStorage) {
flags = &FlagStorage{
// File system
MountOptions: make(map[string]string),
DirMode: os.FileMode(c.Int("dir-mode")),
FileMode: os.FileMode(c.Int("file-mode")),
Uid: uint32(c.Int("uid")),
Gid: uint32(c.Int("gid")),
// Tuning,
StatCacheTTL: c.Duration("stat-cache-ttl"),
TypeCacheTTL: c.Duration("type-cache-ttl"),
// S3
Endpoint: c.String("endpoint"),
StorageClass: c.String("storage-class"),
UsePathRequest: c.Bool("use-path-request"),
// Debugging,
DebugFuse: c.Bool("debug_fuse"),
DebugS3: c.Bool("debug_s3"),
Foreground: c.Bool("f"),
}
// Handle the repeated "-o" flag.
for _, o := range c.StringSlice("o") {
parseOptions(flags.MountOptions, o)
}
return
}
func TestWriterBasics(t *testing.T) {
b := new(bytes.Buffer)
b.Grow(len(testCommon))
w := NewWriter(b)
debian := &fileInfo{
name: "debian-binary",
mtime: time.Unix(1385068169, 0),
mode: os.FileMode(0100644) & os.ModePerm,
size: 4,
}
if _, err := w.WriteFile(debian, strings.NewReader("2.0\n")); err != nil {
t.Error(err)
return
}
control := &fileInfo{
name: "control.tar.gz",
mtime: time.Unix(1385068169, 0),
mode: os.FileMode(0100644) & os.ModePerm,
size: 0,
}
if _, err := w.WriteFile(control, strings.NewReader("")); err != nil {
t.Error(err)
return
}
if archive := b.String(); archive != testCommon {
t.Errorf("got\n%q\nwant\n%q", archive, testCommon)
}
}
func (ca *CA) MakeClientCertificate(certFile, keyFile string, u user.Info) (*TLSCertificateConfig, error) {
glog.V(4).Infof("Generating client cert in %s and key in %s", certFile, keyFile)
// ensure parent dirs
if err := os.MkdirAll(filepath.Dir(certFile), os.FileMode(0755)); err != nil {
return nil, err
}
if err := os.MkdirAll(filepath.Dir(keyFile), os.FileMode(0755)); err != nil {
return nil, err
}
clientPublicKey, clientPrivateKey, _ := NewKeyPair()
clientTemplate, _ := newClientCertificateTemplate(x509request.UserToSubject(u))
clientCrt, _ := ca.signCertificate(clientTemplate, clientPublicKey)
certData, err := encodeCertificates(clientCrt)
if err != nil {
return nil, err
}
keyData, err := encodeKey(clientPrivateKey)
if err != nil {
return nil, err
}
if err = ioutil.WriteFile(certFile, certData, os.FileMode(0644)); err != nil {
return nil, err
}
if err = ioutil.WriteFile(keyFile, keyData, os.FileMode(0600)); err != nil {
return nil, err
}
return GetTLSCertificateConfig(certFile, keyFile)
}
func TestUbuntuSetupSsh(t *testing.T) {
fakeStats, fakeFs, fakeCmdRunner, fakeDiskManager, fakeCompressor := getUbuntuDependencies()
fakeFs.HomeDirHomePath = "/some/home/dir"
ubuntu := newUbuntuPlatform(fakeStats, fakeFs, fakeCmdRunner, fakeDiskManager, fakeCompressor)
ubuntu.SetupSsh("some public key", "vcap")
sshDirPath := "/some/home/dir/.ssh"
sshDirStat := fakeFs.GetFileTestStat(sshDirPath)
assert.Equal(t, fakeFs.HomeDirUsername, "vcap")
assert.NotNil(t, sshDirStat)
assert.Equal(t, fakesys.FakeFileTypeDir, sshDirStat.FileType)
assert.Equal(t, sshDirStat.FileMode, os.FileMode(0700))
assert.Equal(t, sshDirStat.Username, "vcap")
authKeysStat := fakeFs.GetFileTestStat(filepath.Join(sshDirPath, "authorized_keys"))
assert.NotNil(t, authKeysStat)
assert.Equal(t, authKeysStat.FileType, fakesys.FakeFileTypeFile)
assert.Equal(t, authKeysStat.FileMode, os.FileMode(0600))
assert.Equal(t, authKeysStat.Username, "vcap")
assert.Equal(t, authKeysStat.Content, "some public key")
}