isolate: test uploading of individual regular files

client/cmd/isolate/upload_tracker.go

 // Copyright 2017 The LUCI Authors.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //      http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
@@ skipping 14 matching lines @@
         "strings"
 
         humanize "github.com/dustin/go-humanize"
         "github.com/luci/luci-go/common/isolated"
         "github.com/luci/luci-go/common/isolatedclient"
 )
 
 // limitedOS contains a subset of the functions from the os package.
 type limitedOS interface {
         Readlink(string) (string, error)
+
+        // Open is like os.Open, but returns an io.ReadCloser since
+        // that's all we need and it's easier to implment with a fake.
+        Open(string) (io.ReadCloser, error)
+
         openFiler
 }
 
 type openFiler interface {
         // OpenFile is like os.OpenFile, but returns an io.WriteCloser since
         // that's all we need and it's easier to implment with a fake.
         OpenFile(string, int, os.FileMode) (io.WriteCloser, error)
 }
 
 // standardOS implements limitedOS by delegating to the standard library's os package.
 type standardOS struct{}
 
 func (sos standardOS) Readlink(name string) (string, error) {
         return os.Readlink(name)
 }
 
+func (sos standardOS) Open(name string) (io.ReadCloser, error) {
+        return os.Open(name)
+}
+
 func (sos standardOS) OpenFile(name string, flag int, perm os.FileMode) (io.WriteCloser, error) {
         return os.OpenFile(name, flag, perm)
 }
 
 // UploadTracker uploads and keeps track of files.
 type UploadTracker struct {
         checker  Checker
         uploader Uploader
         isol     *isolated.Isolated
 
@@ skipping 83 matching lines @@
                         })
                 })
         }
         return nil
 }
 
 // uploadFiles uploads each file and adds it to files.
 func (ut *UploadTracker) uploadFiles(files []*Item) error {
         // Handle the large individually-uploaded files.
         for _, item := range files {
-                d, err := hashFile(item.Path)
+                d, err := ut.hashFile(item.Path)
                 if err != nil {
                         return err
                 }
                 item.Digest = d
                 ut.isol.Files[item.RelPath] = isolated.BasicFile(item.Digest, int(item.Mode), item.Size)
                 ut.checker.AddItem(item, false, func(item *Item, ps *isolatedclient.PushState) {
                         if ps == nil {
                                 return
                         }
                         log.Printf("QUEUED %q for upload", item.RelPath)
@@ skipping 36 matching lines @@
         if err := isolFile.writeJSONFile(ut.lOS); err != nil {
                 return IsolatedSummary{}, err
         }
 
         return IsolatedSummary{
                 Name:   isolFile.name(),
                 Digest: isolFile.item().Digest,
         }, nil
 }
 
+func (ut *UploadTracker) hashFile(path string) (isolated.HexDigest, error) {
+        f, err := ut.lOS.Open(path)
+        if err != nil {
+                return "", err
+        }
+        defer f.Close()
+        return isolated.Hash(f)
+}
+
 // isolatedFile is an isolated file which is stored in memory.
 // It can produce a corresponding Item, for upload to the server,
 // and also write its contents to the filesystem.
 type isolatedFile struct {
         json []byte
         path string
 }
 
 func newIsolatedFile(isol *isolated.Isolated, path string) (*isolatedFile, error) {
         j, err := json.Marshal(isol)
@@ skipping 32 matching lines @@
 }
 
 // name returns the base name of the isolated file, extension stripped.
 func (ij *isolatedFile) name() string {
         name := filepath.Base(ij.path)
         if i := strings.LastIndex(name, "."); i != -1 {
                 name = name[:i]
         }
         return name
 }