isolate: Finalize the isolate in UploadTracker

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/ioutil"
         "log"
         "os"
         "path/filepath"
-        "strings"
         "time"
 
         humanize "github.com/dustin/go-humanize"
         "github.com/golang/protobuf/proto"
         "github.com/maruel/subcommands"
         "golang.org/x/net/context"
 
         "github.com/luci/luci-go/client/internal/common"
         "github.com/luci/luci-go/client/isolate"
         "github.com/luci/luci-go/common/auth"
@@ skipping 174 matching lines @@
         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
         }
 
-        isolItem, isolJSON, err := tracker.Finalize(archiveOpts.Isolated)
+        isolDigest, err := tracker.Finalize(archiveOpts.Isolated, c.dumpJSON)
         if err != nil {
                 return err
         }
 
-        // Make sure that all pending items have been checked.
-        if err := checker.Close(); err != nil {
-                return err
-        }
-
-        // Make sure that all the uploads have completed successfully.
-        if err := uploader.Close(); err != nil {
-                return err
-        }
-
-        // Write the isolated file, and emit its digest to stdout.
-        if err := ioutil.WriteFile(archiveOpts.Isolated, isolJSON, 0644); err != nil {
-                return err
-        }
-        fmt.Printf("%s\t%s\n", isolItem.Digest, filepath.Base(archiveOpts.Isolated))
-
-        // Optionally, write the digest of the isolated file as JSON (in the same
-        // format as batch_archive).
-        if c.dumpJSON != "" {
-                // The name is the base name of the isolated file, extension stripped.
-                name := filepath.Base(archiveOpts.Isolated)
-                if i := strings.LastIndex(name, "."); i != -1 {
-                        name = name[:i]
-                }
-                j, err := json.Marshal(map[string]isolated.HexDigest{
-                        name: isolItem.Digest,
-                })
-                if err != nil {
-                        return err
-                }
-                if err := ioutil.WriteFile(c.dumpJSON, j, 0644); err != nil {
-                        return err
-                }
-        }
-
         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(isolItem.Digest)},
+                IsolateHash: []string{string(isolDigest)},
         }
         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
 }
 
@@ skipping 28 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)
 }