cipd: accept a function in EnsureFile

client/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"
         "os"
@@ skipping 26 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 io.Reader) error
+        // EnsureFile creates a file and calls the function to write file content.
+        // It will create full directory path to the file if necessary.
+        EnsureFile(path string, write func(*os.File) error) 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).
         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}
 }
 
+// EnsureFile creates a file with the given content.
+// It will create full directory path to the file if necessary.
+func EnsureFile(fs FileSystem, path string, content io.Reader) error {
+        return fs.EnsureFile(path, func(f *os.File) error {
+                _, err := io.Copy(f, content)
+                return err
+        })
+}
+
 // fsImplErr implements FileSystem by returning given error from all methods.
 type fsImplErr struct {
         err error
 }
 
-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 io.Reader) 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, write func(*os.File) error) 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 28 matching lines @@
                 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?
         return path, nil
 }
 
-func (f *fsImpl) EnsureFile(path string, body io.Reader) error {
+func (f *fsImpl) EnsureFile(path string, write func(*os.File) error) 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 := tempFileName(path)
-        if err := createFile(temp, body); err != nil {
+        if err := createFile(temp, write); 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)
                 }
@@ skipping 146 matching lines @@
         ts := time.Now().UnixNano()
         lastUsedTimeLock.Lock()
         if ts <= lastUsedTime {
                 ts = lastUsedTime + 1
         }
         lastUsedTime = ts
         lastUsedTimeLock.Unlock()
         return fmt.Sprintf("%v_%v", os.Getpid(), ts)
 }
 
-// createFile creates a file with the given content.
-func createFile(path string, content io.Reader) (err error) {
+// createFile creates a file and calls the function to write file content.
+func createFile(path string, write func(*os.File) error) (err error) {
         file, err := os.Create(path)
         if err != nil {
                 return err
         }
         defer func() {
                 closeErr := file.Close()
                 if err == nil {
                         err = closeErr
                 }
         }()
-        _, err = io.Copy(file, content)
-        return err
+        return write(file)
 }