isolate: Move json dumping back into exparchive main

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,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
 package main
 
 import (
         "encoding/json"
         "fmt"
-        "io"
         "io/ioutil"
         "log"
         "os"
         "path/filepath"
         "strings"
 
         humanize "github.com/dustin/go-humanize"
         "github.com/luci/luci-go/common/isolated"
         "github.com/luci/luci-go/common/isolatedclient"
 )
 
 // UploadTracker uploads and keeps track of files.
 type UploadTracker struct {
         checker  *Checker
         uploader *Uploader
         isol     *isolated.Isolated
 }
 
 // NewUploadTracker constructs an UploadTracker.  It tracks uploaded files in isol.Files.
 func NewUploadTracker(checker *Checker, uploader *Uploader, isol *isolated.Isolated) *UploadTracker {
+        // TODO: share a Checker and Uploader with other UploadTrackers
+        // when batch uploading.
         isol.Files = make(map[string]isolated.File)
         return &UploadTracker{
                 checker:  checker,
                 uploader: uploader,
                 isol:     isol,
         }
 }
 
 // UploadDeps uploads all of the items in parts.
 func (ut *UploadTracker) UploadDeps(parts partitionedDeps) error {
@@ skipping 83 matching lines @@
                         }
                         log.Printf("QUEUED %q for upload", item.RelPath)
                         ut.uploader.UploadFile(item, ps, func() {
                                 log.Printf("UPLOADED %q", item.RelPath)
                         })
                 })
         }
         return nil
 }
 
+// IsolatedSummary contains an isolate name and its digest.
+type IsolatedSummary struct {
+        // Name is the base name an isolated file with any extension stripped
+        Name   string
+        Digest isolated.HexDigest
+}
+
 // Finalize creates and uploads the isolate JSON at the isolatePath, and closes the checker and uploader.
-// It returns the isolate digest.
-// If dumpJSONPath is non-empty, the digest is also written to that path as
-// JSON (in the same format as batch_archive).
+// It returns the isolate name and digest.
 // Finalize should only be called after UploadDeps.
-func (ut *UploadTracker) Finalize(isolatedPath string, dumpJSONWriter io.Writer) (isolated.HexDigest, error) {
+func (ut *UploadTracker) Finalize(isolatedPath string) (IsolatedSummary, error) {
         isolFile, err := newIsolatedFile(ut.isol, isolatedPath)
         if err != nil {
-                return "", err
+                return IsolatedSummary{}, err
         }
 
         // Check and upload isolate JSON.
         ut.checker.AddItem(isolFile.item(), true, func(item *Item, ps *isolatedclient.PushState) {
                 if ps == nil {
                         return
                 }
                 log.Printf("QUEUED %q for upload", item.RelPath)
                 ut.uploader.UploadBytes(item.RelPath, isolFile.contents(), ps, func() {
                         log.Printf("UPLOADED %q", item.RelPath)
                 })
         })
 
         // Make sure that all pending items have been checked.
         if err := ut.checker.Close(); err != nil {
-                return "", err
+                return IsolatedSummary{}, err
         }
 
         // Make sure that all the uploads have completed successfully.
         if err := ut.uploader.Close(); err != nil {
-                return "", err
+                return IsolatedSummary{}, err
         }
 
-        // Write the isolated file, and emit its digest to stdout.
+        // Write the isolated file...
         if err := isolFile.writeJSONFile(); err != nil {
-                return "", err
+                return IsolatedSummary{}, err
         }
 
-        fmt.Printf("%s\t%s\n", isolFile.item().Digest, filepath.Base(isolatedPath))
-
-        if err := dumpJSON(isolFile.name(), dumpJSONWriter, isolFile.item()); err != nil {
-                return "", err
-        }
-
-        return isolFile.item().Digest, nil
-}
-
-func dumpJSON(isolName string, dumpJSONWriter io.Writer, isolItem *Item) error {
-        enc := json.NewEncoder(dumpJSONWriter)
-        return enc.Encode(map[string]isolated.HexDigest{
-                isolName: isolItem.Digest,
-        })
+        return IsolatedSummary{
+                Name:   isolFile.name(),
+                Digest: isolFile.item().Digest,
+        }, nil
 }
 
 // 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
 }
 
@@ skipping 25 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
 }