isolate: Split UploadDeps into smaller chunks

client/cmd/isolate/exp_archive.go

 // Copyright 2015 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 169 matching lines @@
                 checker:  checker,
                 uploader: uploader,
                 files:    make(map[string]isolated.File),
         }
 }
 
 func (ut *uploadTracker) Files() map[string]isolated.File {
         return ut.files
 }
 
-func (ut *uploadTracker) UploadDeps(parts partitionedDeps) error {
-        // Handle the symlinks.
-        for _, item := range parts.links.items {
+// populateSymlinks adds an isolated.File to files for each provided symlink
+func (ut *uploadTracker) populateSymlinks(symlinks []*Item) error {
+        for _, item := range symlinks {
                 l, err := os.Readlink(item.Path)
                 if err != nil {
                         return fmt.Errorf("unable to resolve symlink for %q: %v", item.Path, err)
                 }
                 ut.files[item.RelPath] = isolated.SymLink(l)
         }
+        return nil
+}
 
-        // Handle the small to-be-archived files.
-        bundles := ShardItems(parts.filesToArchive.items, archiveMaxSize)
+// tarAndUploadFiles creates bundles of files, uploads them, and adds each bundle to files.
+func (ut *uploadTracker) tarAndUploadFiles(smallFiles []*Item) error {
+        bundles := ShardItems(smallFiles, archiveMaxSize)
         log.Printf("\t%d TAR archives to be isolated", len(bundles))
 
         for _, bundle := range bundles {
                 bundle := bundle
                 digest, tarSize, err := bundle.Digest()
                 if err != nil {
                         return err
                 }
 
                 log.Printf("Created tar archive %q (%s)", digest, humanize.Bytes(uint64(tarSize)))
@@ skipping 11 matching lines @@
                 ut.checker.AddItem(item, false, func(item *Item, ps *isolatedclient.PushState) {
                         if ps == nil {
                                 return
                         }
                         log.Printf("QUEUED %q for upload", item.RelPath)
                         ut.uploader.Upload(item.RelPath, bundle.Contents, ps, func() {
                                 log.Printf("UPLOADED %q", item.RelPath)
                         })
                 })
         }
+        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 parts.indivFiles.items {
+        for _, item := range files {
                 d, err := hashFile(item.Path)
                 if err != nil {
                         return err
                 }
                 item.Digest = d
                 ut.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)
                         ut.uploader.UploadFile(item, ps, func() {
                                 log.Printf("UPLOADED %q", item.RelPath)
                         })
                 })
         }
         return nil
 }
 
+func (ut *uploadTracker) UploadDeps(parts partitionedDeps) error {
+        if err := ut.populateSymlinks(parts.links.items); err != nil {
+                return err
+        }
+
+        if err := ut.tarAndUploadFiles(parts.filesToArchive.items); err != nil {
+                return err
+        }
+
+        if err := ut.uploadFiles(parts.indivFiles.items); err != nil {
+                return err
+        }
+        return nil
+}
+
 // main contains the core logic for experimental archive.
 func (c *expArchiveRun) main() error {
         // TODO(djd): This func is long and has a lot of internal complexity (like,
         // such as, archiveCallback). Refactor.
 
         start := time.Now()
         archiveOpts := &c.isolateFlags.ArchiveOptions
         // Parse the incoming isolate file.
         deps, rootDir, isol, err := isolate.ProcessIsolate(archiveOpts)
         if err != nil {
@@ skipping 145 matching lines @@
 }
 
 func hashFile(path string) (isolated.HexDigest, error) {
         f, err := os.Open(path)
         if err != nil {
                 return "", err
         }
         defer f.Close()
         return isolated.Hash(f)
 }