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

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

+// Copyright 2015 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"
+        "os"
+        "path/filepath"
+        "strings"
+        "sync"
+        "time"
+
+        "github.com/luci/luci-go/common/logging"
+)
+
+// FileSystem is a high-level interface for operations that touch single file
+// system subpath. All functions operate in terms of native file paths. It
+// exists mostly to hide differences between file system semantic on Windows and
+// Linux\Mac.
+type FileSystem interface {
+        // Root returns absolute path to a directory FileSystem operates in. All FS
+        // actions are restricted to this directory.
+        Root() string
+
+        // ToAbsPath converts a relative path to an absolute one and verifies it is
+        // under the root path of the FileSystem object.
+        ToAbsPath(path string) (string, error)
+
+        // EnsureDirectory creates a directory at given native path if it doesn't
+        // exist yet. It takes an absolute path or a path relative to the current
+        // working directory and always returns absolute path.
+        EnsureDirectory(path string) (string, error)
+
+        // EnsureSymlink creates a symlink pointing to a target. It will create full
+        // directory path to the symlink if necessary.
+        EnsureSymlink(path string, target string) error
+
+        // EnsureFileGone removes a file, logging the errors (if any). Missing file is
+        // not an error.
+        EnsureFileGone(path string) error
+
+        // EnsureDirectoryGone recursively removes a directory.
+        EnsureDirectoryGone(path string) error
+
+        // Renames oldpath to newpath. If newpath already exists (be it a file or a
+        // directory), removes it first.
+        Replace(oldpath, newpath string) error
+}
+
+// NewFileSystem returns default FileSystem implementation that operates with
+// files under a given path. All methods accept absolute paths or paths relative
+// to current working directory. FileSystem will ensure they are under 'root'
+// directory.
+func NewFileSystem(root string, logger logging.Logger) FileSystem {
+        if logger == nil {
+                logger = logging.Null()
+        }
+        abs, err := filepath.Abs(root)
+        if err != nil {
+                return &fsImplErr{err}
+        }
+        return &fsImpl{abs, logger}
+}
+
+// fsImplErr implements FileSystem by returning given error from all methods.
+type fsImplErr struct {
+        err error
+}
+
+// Root returns absolute path to a directory FileSystem operates in. All FS
+// actions are restricted to this directory.
+func (f *fsImplErr) Root() string                                   { return "" }
+func (f *fsImplErr) ToAbsPath(path string) (string, error)          { return "", f.err }
+func (f *fsImplErr) EnsureDirectory(path string) (string, error)    { return "", f.err }
+func (f *fsImplErr) EnsureSymlink(path string, target string) error { return f.err }
+func (f *fsImplErr) EnsureFileGone(path string) error               { return f.err }
+func (f *fsImplErr) EnsureDirectoryGone(path string) error          { return f.err }
+func (f *fsImplErr) Replace(oldpath, newpath string) error          { return f.err }
+
+/// Implementation.
+
+type fsImpl struct {
+        root   string
+        logger logging.Logger
+}
+
+func (f *fsImpl) Root() string {
+        return f.root
+}
+
+func (f *fsImpl) ToAbsPath(p string) (string, error) {
+        p, err := filepath.Abs(p)
+        if err != nil {
+                return "", err
+        }
+        rel, err := filepath.Rel(f.root, p)
+        if err != nil {
+                return "", err
+        }
+        rel = filepath.ToSlash(rel)
+        if rel == ".." || strings.HasPrefix(rel, "../") {
+                return "", fmt.Errorf("fs: path %s is outside of %s", p, f.root)
+        }
+        return p, nil
+}
+
+func (f *fsImpl) EnsureDirectory(path string) (string, error) {
+        path, err := f.ToAbsPath(path)
+        if err != nil {
+                return "", err
+        }
+        // MkdirAll returns nil if path already exists.
+        if err = os.MkdirAll(path, 0777); err != nil {
+                return "", err
+        }
+        return path, nil
+}
+
+func (f *fsImpl) EnsureSymlink(path string, target string) error {
+        path, err := f.ToAbsPath(path)
+        if err != nil {
+                return err
+        }
+        if existing, _ := os.Readlink(path); existing == target {
+                return nil
+        }
+        if _, err := f.EnsureDirectory(filepath.Dir(path)); err != nil {
+                return err
+        }
+
+        // Create a new symlink file, can't modify existing one in place.
+        temp := fmt.Sprintf("%s_%s", path, pseudoRand())
+        if err := os.Symlink(target, temp); err != nil {
+                return err
+        }
+
+        // Atomically replace the current symlink with a new one.
+        if err := os.Rename(temp, path); err != nil {
+                err2 := os.Remove(temp)
+                if err2 != nil {
+                        f.logger.Warningf("fs: failed to remove %s - %s", temp, err2)
+                }
+                return err
+        }
+
+        return nil
+}
+
+func (f *fsImpl) EnsureFileGone(path string) error {
+        path, err := f.ToAbsPath(path)
+        if err != nil {
+                return err
+        }
+        err = os.Remove(path)
+        if err != nil && !os.IsNotExist(err) {
+                f.logger.Warningf("fs: failed to remove %s - %s", path, err)
+                return err
+        }
+        return nil
+}
+
+func (f *fsImpl) EnsureDirectoryGone(path string) error {
+        path, err := f.ToAbsPath(path)
+        if err != nil {
+                return err
+        }
+        // Make directory "disappear" instantly by renaming it first.
+        temp := fmt.Sprintf("%s_%v", path, pseudoRand())
+        if err = os.Rename(path, temp); err != nil {
+                if os.IsNotExist(err) {
+                        return nil
+                }
+                f.logger.Warningf("fs: failed to rename directory %s - %s", path, err)
+                return err
+        }
+        if err = os.RemoveAll(temp); err != nil {
+                f.logger.Warningf("fs: failed to remove directory %s - %s", temp, err)
+                return err
+        }
+        return nil
+}
+
+func (f *fsImpl) Replace(oldpath, newpath string) error {
+        oldpath, err := f.ToAbsPath(oldpath)
+        if err != nil {
+                return err
+        }
+        newpath, err = f.ToAbsPath(newpath)
+        if err != nil {
+                return err
+        }
+        if oldpath == newpath {
+                return nil
+        }
+
+        // Make sure oldpath exists before doing heavy stuff.
+        if _, err = os.Stat(oldpath); err != nil {
+                return err
+        }
+
+        // Make parent directory of newpath.
+        if _, err = f.EnsureDirectory(filepath.Dir(newpath)); err != nil {
+                return err
+        }
+
+        // Try a regular move first. Replaces files and empty directories.
+        if err = os.Rename(oldpath, newpath); err == nil {
+                return nil
+        }
+
+        // Move existing path away, if it is there.
+        temp := fmt.Sprintf("%s_%s", newpath, pseudoRand())
+        if err = os.Rename(newpath, temp); err != nil {
+                if !os.IsNotExist(err) {
+                        f.logger.Warningf("fs: failed to rename(%v, %v) - %s", newpath, temp, err)
+                        return err
+                }
+                temp = ""
+        }
+
+        // 'newpath' now should be available.
+        if err := os.Rename(oldpath, newpath); err != nil {
+                f.logger.Warningf("fs: failed to rename(%v, %v) - %s", oldpath, newpath, err)
+                // Try to return the path back... May be too late already.
+                if temp != "" {
+                        if err := os.Rename(temp, newpath); err != nil {
+                                f.logger.Errorf("fs: failed to rename(%v, %v) after unsuccessful move - %s", temp, newpath, err)
+                        }
+                }
+                return err
+        }
+
+        // Cleanup the garbage left. Not a error if fails.
+        if temp != "" {
+                if err := f.EnsureDirectoryGone(temp); err != nil {
+                        f.logger.Warningf("fs: failed to cleanup garbage after file replace - %s", err)
+                }
+        }
+        return nil
+}
+
+/// Internal stuff.
+
+var (
+        lastUsedTime     int64
+        lastUsedTimeLock sync.Mutex
+)
+
+// pseudoRand returns "random enough" string that can be used in file system
+// paths of temp files.
+func pseudoRand() string {
+        ts := time.Now().UnixNano()
+        lastUsedTimeLock.Lock()
+        if ts <= lastUsedTime {
+                ts = lastUsedTime + 1
+        }
+        lastUsedTime = ts
+        lastUsedTimeLock.Unlock()
+        return fmt.Sprintf("%v_%v", os.Getpid(), ts)
+}