Sever isolate cmd dependency on Canceler.

client/cmd/isolate/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 (
         "errors"
         "fmt"
         "log"
         "os"
+        "os/signal"
         "path/filepath"
         "time"
 
         "github.com/golang/protobuf/proto"
         "github.com/maruel/subcommands"
 
         "github.com/luci/luci-go/client/archiver"
-        "github.com/luci/luci-go/client/internal/common"
         "github.com/luci/luci-go/client/isolate"
         "github.com/luci/luci-go/common/auth"
         "github.com/luci/luci-go/common/data/text/units"
         logpb "github.com/luci/luci-go/common/eventlog/proto"
         "github.com/luci/luci-go/common/isolatedclient"
 )
 
 func cmdArchive(defaultAuthOpts auth.Options) *subcommands.Command {
         return &subcommands.Command{
                 UsageLine: "archive <options>",
@@ skipping 38 matching lines @@
         if c.defaultFlags.Quiet {
                 prefix = ""
         }
         start := time.Now()
         client, 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)
-        common.CancelOnCtrlC(arch)
+        CancelOnCtrlC(arch)
         item := isolate.Archive(arch, &c.ArchiveOptions)
         item.WaitForHashed()
         if err = item.Error(); err != nil {
                 fmt.Printf("%s%s  %s\n", prefix, filepath.Base(c.Isolate), err)
         } else {
                 fmt.Printf("%s%s  %s\n", prefix, item.Digest(), filepath.Base(c.Isolate))
         }
         if err2 := arch.Close(); err == nil {
                 err = err2
         }
@@ skipping 34 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
 }
+
+// CancelOnCtrlC is a temporary copy of the CancelOnCtrlC in internal/common/concurrent.go
+// This is needed until the old archive and batcharchive code (which uses Cancelers) is removed.
+// It operates on a concrete Archiver to avoid the dependency on Canceler.
+func CancelOnCtrlC(arch *archiver.Archiver) {
+        interrupted := make(chan os.Signal, 1)
+        signal.Notify(interrupted, os.Interrupt)
+        go func() {
+                defer signal.Stop(interrupted)
+                select {
+                case <-interrupted:
+                        arch.Cancel(errors.New("Ctrl-C"))
+                case <-arch.Channel():
+                }
+        }()
+}