cipd: Extract high level file system operations into the separate interface.

go/src/infra/tools/cipd/local/files.go

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 package local
 
 import (
         "fmt"
         "io"
         "io/ioutil"
@@ skipping 216 matching lines @@
         }
         return strings.HasPrefix(path, root)
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // FileSystemDestination implementation.
 
 type fileSystemDestination struct {
         // Destination directory.
         dir string
+        // FileSystem implementation to use.
+        fs FileSystem
         // Root temporary directory.
         tempDir string
         // Where to extract all temp files, subdirectory of tempDir.
         outDir string
         // Currently open files.
         openFiles map[string]*os.File
 }
 
 // NewFileSystemDestination returns a destination in the file system (directory)
-// to extract a package to.
-func NewFileSystemDestination(dir string) Destination {
+// to extract a package to. Will use a provided FileSystem object to operate on
+// files if given, otherwise use a default one. If FileSystem is provided, dir
+// must be in a subdirectory of the given FileSystem root.
+func NewFileSystemDestination(dir string, fs FileSystem) Destination {
+        if fs == nil {
+                fs = NewFileSystem(filepath.Dir(dir), nil)
+        }
         return &fileSystemDestination{
                 dir:       dir,
+                fs:        fs,
                 openFiles: map[string]*os.File{},
         }
 }
 
-func (d *fileSystemDestination) Begin() (err error) {
+func (d *fileSystemDestination) Begin() error {
         if d.tempDir != "" {
                 return fmt.Errorf("Destination is already open")
         }
 
-        // Ensure parent directory of destination directory exists.
-        d.dir, err = filepath.Abs(filepath.Clean(d.dir))
-        if err != nil {
+        // Ensure a parent directory of the destination directory exists.
+        var err error
+        if d.dir, err = d.fs.ToAbsPath(d.dir); err != nil {
                 return err
         }
-        err = os.MkdirAll(filepath.Dir(d.dir), 0777)
-        if err != nil {
+        if _, err := d.fs.EnsureDirectory(filepath.Dir(d.dir)); err != nil {
                 return err
         }
 
         // Called in case something below fails.
         cleanup := func() {
                 if d.tempDir != "" {
-                        os.RemoveAll(d.tempDir)
+                        d.fs.EnsureDirectoryGone(d.tempDir)
                 }
                 d.tempDir = ""
                 d.outDir = ""
         }
 
-        // Create root temp dir, on the same level as destination directory.
+        // Create root temp dir, on the same level as the destination directory.
         d.tempDir, err = ioutil.TempDir(filepath.Dir(d.dir), filepath.Base(d.dir)+"_")
         if err != nil {
                 cleanup()
                 return err
         }
 
         // Create a staging output directory where everything will be extracted.
-        d.outDir = filepath.Join(d.tempDir, "out")
-        err = os.MkdirAll(d.outDir, 0777)
+        d.outDir, err = d.fs.EnsureDirectory(filepath.Join(d.tempDir, "out"))
         if err != nil {
                 cleanup()
                 return err
         }
 
         return nil
 }
 
 func (d *fileSystemDestination) CreateFile(name string, executable bool) (io.WriteCloser, error) {
-        _, ok := d.openFiles[name]
-        if ok {
+        if _, ok := d.openFiles[name]; ok {
                 return nil, fmt.Errorf("File %s is already open", name)
         }
 
         path, err := d.prepareFilePath(name)
         if err != nil {
                 return nil, err
         }
 
         // Let the umask trim the file mode. Do not set 'writable' bit though.
         var mode os.FileMode
@@ skipping 25 matching lines @@
 
         // Forbid relative symlinks to files outside of the destination root.
         target = filepath.FromSlash(target)
         if !filepath.IsAbs(target) {
                 targetAbs := filepath.Clean(filepath.Join(filepath.Dir(path), target))
                 if !isSubpath(targetAbs, d.outDir) {
                         return fmt.Errorf("Relative symlink is pointing outside of the destination dir: %s", name)
                 }
         }
 
-        return os.Symlink(target, path)
+        return d.fs.EnsureSymlink(path, target)
 }
 
 func (d *fileSystemDestination) End(success bool) error {
         if d.tempDir == "" {
                 return fmt.Errorf("Destination is not open")
         }
         if len(d.openFiles) != 0 {
                 return fmt.Errorf("Not all files were closed. Leaking.")
         }
 
         // Clean up temp dir and the state no matter what.
         defer func() {
-                os.RemoveAll(d.tempDir)
+                d.fs.EnsureDirectoryGone(d.tempDir)
                 d.tempDir = ""
                 d.outDir = ""
         }()
 
         if success {
-                // Move existing directory away, if it is there.
-                old := filepath.Join(d.tempDir, "old")
-                if os.Rename(d.dir, old) != nil {
-                        old = ""
-                }
-
-                // Move new directory in place.
-                err := os.Rename(d.outDir, d.dir)
-                if err != nil {
-                        // Try to return the original directory back...
-                        if old != "" {
-                                os.Rename(old, d.dir)
-                        }
-                        return err
-                }
+                return d.fs.Replace(d.outDir, d.dir)
         }
-
+        // Let the defer to clean the garbage in tempDir.
         return nil
 }
 
 // prepareFilePath performs steps common to CreateFile and CreateSymlink: it
 // does some validation, expands "name" to an absolute path and creates parent
 // directories for a future file. Returns absolute path where the file should
 // be put.
 func (d *fileSystemDestination) prepareFilePath(name string) (string, error) {
         if d.tempDir == "" {
                 return "", fmt.Errorf("Destination is not open")
         }
         path := filepath.Clean(filepath.Join(d.outDir, filepath.FromSlash(name)))
         if !isSubpath(path, d.outDir) {
                 return "", fmt.Errorf("Invalid relative file name: %s", name)
         }
-        err := os.MkdirAll(filepath.Dir(path), 0777)
-        if err != nil {
+        if _, err := d.fs.EnsureDirectory(filepath.Dir(path)); err != nil {
                 return "", err
         }
         return path, nil
 }
 
 type fileSystemDestinationFile struct {
         nested        io.WriteCloser
         parent        *fileSystemDestination
         closeCallback func()
 }
 
 func (f *fileSystemDestinationFile) Write(p []byte) (n int, err error) {
         return f.nested.Write(p)
 }
 
 func (f *fileSystemDestinationFile) Close() error {
         f.closeCallback()
         return f.nested.Close()
 }