cipd: Make it work on Windows.

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"
+        "io/ioutil"
         "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
@@ skipping 17 matching lines @@
 
         // 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
 
+        // EnsureFile creates a file with given content. If will create full directory
+        // path to the file if necessary.
+        EnsureFile(path string, body []byte, perm os.FileMode) 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. If oldpath is a symlink, it's moved as is
         // (e.g. as a symlink).
@@ skipping 15 matching lines @@
         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) CwdRelToAbs(path string) (string, error)        { return "", f.err }
-func (f *fsImplErr) RootRelToAbs(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 }
+func (f *fsImplErr) Root() string                                                { return "" }
+func (f *fsImplErr) CwdRelToAbs(path string) (string, error)                     { return "", f.err }
+func (f *fsImplErr) RootRelToAbs(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) EnsureFile(path string, body []byte, perm os.FileMode) 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
@@ skipping 24 matching lines @@
 
 func (f *fsImpl) EnsureDirectory(path string) (string, error) {
         path, err := f.CwdRelToAbs(path)
         if err != nil {
                 return "", err
         }
         // MkdirAll returns nil if path already exists.
         if err = os.MkdirAll(path, 0777); err != nil {
                 return "", err
         }
+        // TODO(vadimsh): Do not fail if path already exists and is a regular file?

[nodir, 2015/07/29 20:43:47]

probably not, because this func must ensure that a directory at that path exists

[Vadim Sh., 2015/07/29 21:04:28]

I mean if a/b/c exists and is a regular file, EnsureDirectory("a/b/c") currently
will fail. This TODO is to make it work. Though I'm not sure it's needed, thus
"?".

[nodir, 2015/07/29 21:08:59]

Acknowledged.

         return path, nil
 }
 
+func (f *fsImpl) EnsureFile(path string, body []byte, perm os.FileMode) error {
+        path, err := f.CwdRelToAbs(path)
+        if err != nil {
+                return err
+        }
+        if _, err := f.EnsureDirectory(filepath.Dir(path)); err != nil {
+                return err
+        }
+
+        // Create a temp file with new content.
+        temp := fmt.Sprintf("%s_%s", path, pseudoRand())
+        if err := ioutil.WriteFile(temp, body, perm); err != nil {
+                return err
+        }
+
+        // Replace the current file (if there's one) with a new one. Use nuclear
+        // version (f.Replace) instead of simple atomicReplace to handle various edge
+        // cases handled by the nuclear version (e.g replacing a non-empty directory).
+        if err := f.Replace(temp, path); err != nil {
+                if err2 := os.Remove(temp); err2 != nil && !os.IsNotExist(err2) {
+                        f.logger.Warningf("fs: failed to remove %s - %s", temp, err2)
+                }
+                return err
+        }
+
+        return nil
+}
+
 func (f *fsImpl) EnsureSymlink(path string, target string) error {
         path, err := f.CwdRelToAbs(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 {
+        // Replace the current symlink with a new one. Use nuclear version (f.Replace)
+        // instead of simple atomicReplace to handle various edge cases handled by
+        // the nuclear version (e.g replacing a non-empty directory).

[Vadim Sh., 2015/07/28 01:20:18]

it's a prep work for "replace locked files". The corresponding code will be
concentrated in Replace(...).

+        if err := f.Replace(temp, path); err != nil {
+                if err2 := os.Remove(temp); err2 != nil && !os.IsNotExist(err2) {
                         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.CwdRelToAbs(path)
         if err != nil {
                 return err
         }
-        err = os.Remove(path)
-        if err != nil && !os.IsNotExist(err) {
+        if err = os.Remove(path); 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.CwdRelToAbs(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 err = atomicRename(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
         }
@@ skipping 17 matching lines @@
         if _, err = os.Lstat(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 {
+        if err = atomicRename(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 err = atomicRename(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 {
+        if err := atomicRename(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 {
+                        if err := atomicRename(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)
@@ skipping 14 matching lines @@
 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)
 }