isolate: Move json dumping back into exparchive main

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,
 // 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"
         "errors"
         "fmt"
         "io"
-        "io/ioutil"
         "log"
         "os"
         "path/filepath"
         "time"
 
         humanize "github.com/dustin/go-humanize"
         "github.com/golang/protobuf/proto"
         "github.com/maruel/subcommands"
         "golang.org/x/net/context"
 
@@ skipping 176 matching lines @@
         numFiles := len(parts.filesToArchive.items) + len(parts.indivFiles.items)
         filesSize := uint64(parts.filesToArchive.totalSize + parts.indivFiles.totalSize)
         log.Printf("Isolate expanded to %d files (total size %s) and %d symlinks", numFiles, humanize.Bytes(filesSize), len(parts.links.items))
         log.Printf("\t%d files (%s) to be isolated individually", len(parts.indivFiles.items), humanize.Bytes(uint64(parts.indivFiles.totalSize)))
         log.Printf("\t%d files (%s) to be isolated in archives", len(parts.filesToArchive.items), humanize.Bytes(uint64(parts.filesToArchive.totalSize)))
 
         tracker := NewUploadTracker(checker, uploader, isol)
         if err := tracker.UploadDeps(parts); err != nil {
                 return err
         }
+        isolSummary, err := tracker.Finalize(archiveOpts.Isolated)
+        if err != nil {
+                return err
+        }
 
-        var dumpJSONWriter io.Writer = ioutil.Discard
-
+        printSummary(isolSummary)
         if c.dumpJSON != "" {
                 f, err := os.OpenFile(c.dumpJSON, os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0644)
                 if err != nil {
                         return err
                 }
-                defer f.Close()
-                dumpJSONWriter = f
-        }
-
-        isolDigest, err := tracker.Finalize(archiveOpts.Isolated, dumpJSONWriter)
-        if err != nil {
-                return err
+                writeSummaryJSON(f, isolSummary)
+                f.Close()
         }
 
         end := time.Now()
 
         archiveDetails := &logpb.IsolateClientEvent_ArchiveDetails{
                 HitCount:    proto.Int64(int64(checker.Hit.Count)),
                 MissCount:   proto.Int64(int64(checker.Miss.Count)),
                 HitBytes:    &checker.Hit.Bytes,
                 MissBytes:   &checker.Miss.Bytes,
-                IsolateHash: []string{string(isolDigest)},
+                IsolateHash: []string{string(isolSummary.Digest)},
         }
         eventlogger := NewLogger(ctx, c.loggingFlags.EventlogEndpoint)
         op := logpb.IsolateClientEvent_ARCHIVE.Enum()
         if err := eventlogger.logStats(ctx, op, start, end, archiveDetails); err != nil {
                 log.Printf("Failed to log to eventlog: %v", err)
         }
 
         return nil
 }
 
+func writeSummaryJSON(w io.Writer, summaries ...IsolatedSummary) error {
+        m := make(map[string]isolated.HexDigest)
+        for _, summary := range summaries {
+                m[summary.Name] = summary.Digest
+        }
+
+        return json.NewEncoder(w).Encode(m)
+}
+
+func printSummary(summary IsolatedSummary) {
+        fmt.Printf("%s\t%s\n", summary.Digest, summary.Name)
+}
+
 func (c *expArchiveRun) parseFlags(args []string) error {
         if len(args) != 0 {
                 return errors.New("position arguments not expected")
         }
         if err := c.commonServerFlags.Parse(); err != nil {
                 return err
         }
         cwd, err := os.Getwd()
         if err != nil {
                 return err
@@ skipping 18 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)
 }