isolate: pull exparchive and archive into functions with similar signatures.

client/cmd/isolate/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 (
+        "context"
         "errors"
         "fmt"
         "log"
         "os"
         "os/signal"
         "path/filepath"
         "time"
 
         "github.com/golang/protobuf/proto"
         "github.com/maruel/subcommands"
@@ skipping 38 matching lines @@
         if err := c.isolateFlags.Parse(cwd, RequireIsolatedFile); err != nil {
                 return err
         }
         if len(args) != 0 {
                 return errors.New("position arguments not expected")
         }
         return nil
 }
 
 func (c *archiveRun) main(a subcommands.Application, args []string) error {
-        out := os.Stdout
-        prefix := "\n"
-        if c.defaultFlags.Quiet {
-                prefix = ""
-        }
         start := time.Now()
-        client, err := c.createAuthClient()
+        authCl, err := c.createAuthClient()
         if err != nil {
                 return err
         }
         ctx := c.defaultFlags.MakeLoggingContext(os.Stderr)
-        arch := archiver.New(ctx, isolatedclient.New(nil, client, c.isolatedFlags.ServerURL, c.isolatedFlags.Namespace, nil, nil), out)
+        client := isolatedclient.New(nil, authCl, c.isolatedFlags.ServerURL, c.isolatedFlags.Namespace, nil, nil)
+
+        eventlogger := NewLogger(ctx, c.loggingFlags.EventlogEndpoint)
+
+        archiveDetails, err := doArchive(ctx, client, &c.ArchiveOptions, c.defaultFlags.Quiet, start)
+        if err != nil {
+                return err
+        }
+
+        end := time.Now()
+        op := logpb.IsolateClientEvent_LEGACY_ARCHIVE.Enum()
+        if err := eventlogger.logStats(ctx, op, start, end, archiveDetails); err != nil {
+                log.Printf("Failed to log to eventlog: %v", err)
+        }
+        return nil
+}
+
+// doArchive performs the archive operation for an isolate specified by archiveOpts.
+func doArchive(ctx context.Context, client *isolatedclient.Client, archiveOpts *isolate.ArchiveOptions, quiet bool, start time.Time) (*logpb.IsolateClientEvent_ArchiveDetails, error) {

[mithro, 2017/08/02 04:28:34]

It seems a bit weird to pass in start time here, but I can't think of a better
option....

[mcgreevy, 2017/08/02 05:16:38]

Yeah, I hesitated to do so, but didn't want to change the logging right now, and
other options I can think of seemed just as bad.

+        prefix := "\n"
+        if quiet {
+                prefix = ""
+        }
+
+        arch := archiver.New(ctx, client, os.Stdout)
         CancelOnCtrlC(arch)
-        item := isolate.Archive(arch, &c.ArchiveOptions)
+        item := isolate.Archive(arch, archiveOpts)
         item.WaitForHashed()
+        var err error
         if err = item.Error(); err != nil {
-                fmt.Printf("%s%s  %s\n", prefix, filepath.Base(c.Isolate), err)
+                fmt.Printf("%s%s  %s\n", prefix, filepath.Base(archiveOpts.Isolate), err)
         } else {
-                fmt.Printf("%s%s  %s\n", prefix, item.Digest(), filepath.Base(c.Isolate))
+                fmt.Printf("%s%s  %s\n", prefix, item.Digest(), filepath.Base(archiveOpts.Isolate))
         }
         if err2 := arch.Close(); err == nil {
                 err = err2
         }
         stats := arch.Stats()
-        if !c.defaultFlags.Quiet {
+        if !quiet {
                 duration := time.Since(start)
                 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))
         }
 
-        end := time.Now()
-
         archiveDetails := &logpb.IsolateClientEvent_ArchiveDetails{
                 HitCount:  proto.Int64(int64(stats.TotalHits())),
                 MissCount: proto.Int64(int64(stats.TotalMisses())),
                 HitBytes:  proto.Int64(int64(stats.TotalBytesHits())),
                 MissBytes: proto.Int64(int64(stats.TotalBytesPushed())),
         }
         if item.Error() != nil {
                 archiveDetails.IsolateHash = []string{string(item.Digest())}
         }
-        eventlogger := NewLogger(ctx, c.loggingFlags.EventlogEndpoint)
-        op := logpb.IsolateClientEvent_LEGACY_ARCHIVE.Enum()
-        if err := eventlogger.logStats(ctx, op, start, end, archiveDetails); err != nil {
-                log.Printf("Failed to log to eventlog: %v", err)
-        }
-        return err
+        return archiveDetails, nil
 }
 
 func (c *archiveRun) Run(a subcommands.Application, args []string, _ subcommands.Env) int {
         if err := c.Parse(a, args); err != nil {
                 fmt.Fprintf(a.GetErr(), "%s: %s\n", a.GetName(), err)
                 return 1
         }
         cl, err := c.defaultFlags.StartTracing()
         if err != nil {
                 fmt.Fprintf(a.GetErr(), "%s: %s\n", a.GetName(), err)
@@ skipping 15 matching lines @@
         signal.Notify(interrupted, os.Interrupt)
         go func() {
                 defer signal.Stop(interrupted)
                 select {
                 case <-interrupted:
                         arch.Cancel(errors.New("Ctrl-C"))
                 case <-arch.Channel():
                 }
         }()
 }