Pass a Writer to Finalize for JSON dumping.

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"
 )
@@ skipping 108 matching lines @@
                 })
         }
         return nil
 }
 
 // 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).
 // Finalize should only be called after UploadDeps.
-func (ut *UploadTracker) Finalize(isolatedPath, dumpJSONPath string) (isolated.HexDigest, error) {
+func (ut *UploadTracker) Finalize(isolatedPath string, dumpJSONWriter io.Writer) (isolated.HexDigest, error) {
         // Marshal the isolated file into JSON, and create an Item to describe it.
         isolJSON, err := json.Marshal(ut.isol)
         if err != nil {
                 return "", err
         }
         isolItem := &Item{
                 Path:    isolatedPath,
                 RelPath: filepath.Base(isolatedPath),
                 Digest:  isolated.HashBytes(isolJSON),
                 Size:    int64(len(isolJSON)),
@@ skipping 20 matching lines @@
                 return "", err
         }
 
         // Write the isolated file, and emit its digest to stdout.
         if err := ioutil.WriteFile(isolatedPath, isolJSON, 0644); err != nil {
                 return "", err
         }
 
         fmt.Printf("%s\t%s\n", isolItem.Digest, filepath.Base(isolatedPath))
 
-        if err := dumpJSON(isolatedPath, dumpJSONPath, isolItem); err != nil {
+        if err := dumpJSON(isolatedPath, dumpJSONWriter, isolItem); err != nil {
                 return "", err
         }
 
         return isolItem.Digest, nil
 }
 
-func dumpJSON(isolatedPath, dumpJSONPath string, isolItem *Item) error {
-        if dumpJSONPath == "" {
-                return nil
-        }
+func dumpJSON(isolatedPath string, dumpJSONWriter io.Writer, isolItem *Item) error {
         // The name is the base name of the isolated file, extension stripped.
         name := filepath.Base(isolatedPath)
         if i := strings.LastIndex(name, "."); i != -1 {
                 name = name[:i]
         }
-        j, err := json.Marshal(map[string]isolated.HexDigest{
+
+        enc := json.NewEncoder(dumpJSONWriter)
+        return enc.Encode(map[string]isolated.HexDigest{
                 name: isolItem.Digest,
         })
-        if err != nil {
-                return err
-        }
-        if err := ioutil.WriteFile(dumpJSONPath, j, 0644); err != nil {
-                return err
-        }
-        return nil
 }