Remove ReadJSONFile

client/cmd/isolate/batch_archive.go

 // Copyright 2015 The LUCI Authors. All rights reserved.
 // Use of this source code is governed under the Apache License, Version 2.0
 // that can be found in the LICENSE file.
 
 package main
 
 import (
+        "encoding/json"
         "errors"
         "fmt"
+        "io"
         "os"
         "path/filepath"
         "strings"
         "sync"
         "time"
 
         "github.com/maruel/subcommands"
 
         "github.com/luci/luci-go/client/archiver"
         "github.com/luci/luci-go/client/internal/common"
@@ skipping 160 matching lines @@
                 stats := arch.Stats()
                 fmt.Fprintf(os.Stderr, "Hits    : %5d (%s)\n", stats.TotalHits(), stats.TotalBytesHits())
                 fmt.Fprintf(os.Stderr, "Misses  : %5d (%s)\n", stats.TotalMisses(), stats.TotalBytesPushed())
                 fmt.Fprintf(os.Stderr, "Duration: %s\n", units.Round(duration, time.Millisecond))
         }
         return err
 }
 
 // processGenJSON validates a genJSON file and returns the contents.
 func processGenJSON(genJSONPath string) (*isolate.ArchiveOptions, error) {
+        f, err := os.Open(genJSONPath)
+        if err != nil {
+                return nil, fmt.Errorf("opening %s: %s", genJSONPath, err)
+        }
+        defer f.Close()
+
+        opts, err := processGenJSONData(f)
+        if err != nil {
+                return nil, fmt.Errorf("processing %s: %s", genJSONPath, err)
+        }
+        return opts, nil
+}
+
+// processGenJSONData performs the function of processGenJSON, but operates on an io.Reader.
+func processGenJSONData(r io.Reader) (*isolate.ArchiveOptions, error) {
         data := &struct {
                 Args    []string
                 Dir     string
                 Version int
         }{}
-        if err := common.ReadJSONFile(genJSONPath, data); err != nil {
-                return nil, err
+        if err := json.NewDecoder(r).Decode(data); err != nil {
+                return nil, fmt.Errorf("failed to decode: %s", err)
         }
+
         if data.Version != isolate.IsolatedGenJSONVersion {
-                return nil, fmt.Errorf("invalid version %d in %s", data.Version, genJSONPath)
+                return nil, fmt.Errorf("invalid version %d", data.Version)
         }
         if !common.IsDirectory(data.Dir) {
-                return nil, fmt.Errorf("invalid dir %s in %s", data.Dir, genJSONPath)
+                return nil, fmt.Errorf("invalid dir %s", data.Dir)
         }
         opts, err := parseArchiveCMD(data.Args, data.Dir)
         if err != nil {
-                return nil, fmt.Errorf("invalid archive command in %s: %s", genJSONPath, err)
+                return nil, fmt.Errorf("invalid archive command: %s", err)
         }
         return opts, nil
 }
 
 // strippedIsolatedName returns the base name of an isolated path, with the extension (if any) removed.
 func strippedIsolatedName(isolated string) string {
         name := filepath.Base(isolated)
         // Strip the extension if there is one.
         if dotIndex := strings.LastIndex(name, "."); dotIndex != -1 {
                 return name[0:dotIndex]
@@ skipping 11 matching lines @@
                 fmt.Fprintf(a.GetErr(), "%s: %s\n", a.GetName(), err)
                 return 1
         }
         defer cl.Close()
         if err := c.main(a, args); err != nil {
                 fmt.Fprintf(a.GetErr(), "%s: %s\n", a.GetName(), err)
                 return 1
         }
         return 0
 }