cipd: Refactor client to make it more readable.

go/src/infra/tools/cipd/local/builder.go

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-package cipd
+package local
 
 import (
         "archive/zip"
         "bytes"
         "fmt"
         "io"
         "io/ioutil"
         "os"
         "strings"
         "time"
+
+        "infra/libs/logging"
+        "infra/tools/cipd/common"
 )
 
 // BuildInstanceOptions defines options for BuildInstance function.
 type BuildInstanceOptions struct {
         // List of files to add to the package.
         Input []File
         // Where to write the package file to.
         Output io.Writer
         // Package name, e.g. 'infra/tools/cipd'.
         PackageName string
+        // Log defines logger to use.
+        Log logging.Logger
 }
 
 // BuildInstance builds a new package instance for package named opts.PackageName
 // by archiving input files (passed via opts.Input). The final binary is written
 // to opts.Output. Some output may be written even if BuildInstance eventually
 // returns an error.
 func BuildInstance(opts BuildInstanceOptions) error {
-        err := ValidatePackageName(opts.PackageName)
+        if opts.Log == nil {
+                opts.Log = logging.DefaultLogger
+        }
+        err := common.ValidatePackageName(opts.PackageName)
         if err != nil {
                 return err
         }
 
         // Make sure no files are written to package service directory.
         for _, f := range opts.Input {
                 if strings.HasPrefix(f.Name(), packageServiceDir+"/") {
                         return fmt.Errorf("Can't write to %s: %s", packageServiceDir, f.Name())
                 }
         }
 
         // Generate the manifest file, add to the list of input files.
         manifestFile, err := makeManifestFile(opts)
         if err != nil {
                 return err
         }
         files := append(opts.Input, manifestFile)
 
         // Make sure filenames are unique.
         seenNames := make(map[string]struct{}, len(files))
         for _, f := range files {
                 _, seen := seenNames[f.Name()]
                 if seen {
                         return fmt.Errorf("File %s is provided twice", f.Name())
                 }
                 seenNames[f.Name()] = struct{}{}
         }
 
         // Write the final zip file.
-        return zipInputFiles(files, opts.Output)
+        return zipInputFiles(files, opts.Output, opts.Log)
 }
 
 // zipInputFiles deterministically builds a zip archive out of input files and
 // writes it to the writer. Files are written in the order given.
-func zipInputFiles(files []File, w io.Writer) error {
+func zipInputFiles(files []File, w io.Writer, log logging.Logger) error {
         writer := zip.NewWriter(w)
         defer writer.Close()
 
         // Reports zipping progress to the log each second.
         lastReport := time.Time{}
         progress := func(count int) {
                 if time.Since(lastReport) > time.Second {
                         lastReport = time.Now()
                         log.Infof("Zipping files: %d files left", len(files)-count)
                 }
@@ skipping 86 matching lines @@
         err := writeManifest(&Manifest{
                 FormatVersion: manifestFormatVersion,
                 PackageName:   opts.PackageName,
         }, buf)
         if err != nil {
                 return nil, err
         }
         out := manifestFile(buf.Bytes())
         return &out, nil
 }