cipd: Client can resolve tags to instance IDs.

go/src/infra/tools/cipd/client.go

 // Copyright 2015 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 implements client side of Chrome Infra Package Deployer.
 
 TODO: write more.
 
 Binary package file format (in free form representation):
@@ skipping 258 matching lines @@
                         return ErrFinalizationTimeout
                 }
                 client.Log.Infof("cipd: uploading - verifying")
                 client.clock.sleep(delay)
                 if delay < 4*time.Second {
                         delay += 500 * time.Millisecond
                 }
         }
 }
 
+// ResolveVersion converts an instance ID, a tag or a ref into a concrete Pin
+// by contacting the backend.
+func (client *Client) ResolveVersion(packageName, version string) (common.Pin, error) {
+        if err := common.ValidatePackageName(packageName); err != nil {
+                return common.Pin{}, err
+        }
+        // Is it instance ID already? Don't bother calling the backend.
+        if err := common.ValidateInstanceID(version); err == nil {

[nodir, 2015/05/21 17:07:48]

if common.ValidateInstanceID(version) == nil  {

[Vadim Sh., 2015/05/21 18:00:37]

Done.

+                return common.Pin{PackageName: packageName, InstanceID: version}, nil
+        }
+        if err := common.ValidateInstanceVersion(version); err != nil {
+                return common.Pin{}, err
+        }
+        client.Log.Infof("cipd: resolving version '%s' of '%s'...", version, packageName)

[nodir, 2015/05/21 17:07:48]

%q instead of '%s' ?

[Vadim Sh., 2015/05/21 18:00:37]

Done.

+        return client.remote.resolveVersion(packageName, version)
+}
+
 // RegisterInstance makes the package instance available for clients by
 // uploading it to the storage and registering it in the package repository.
 // 'instance' is a package instance to register.
 func (client *Client) RegisterInstance(instance local.PackageInstance) error {
         // Attempt to register.
         client.Log.Infof("cipd: registering %s", instance.Pin())
         result, err := client.remote.registerInstance(instance.Pin())
         if err != nil {
                 return err
         }
@@ skipping 118 matching lines @@
 
         // Deploy it. 'defer' will take care of removing the temp file if needed.
         _, err = local.DeployInstance(root, instance)
         return err
 }
 
 // ProcessEnsureFile parses text file that describes what should be installed
 // by EnsurePackages function. It is a text file where each line has a form:
 // <package name> <desired version>. Whitespaces are ignored. Lines that start
 // with '#' are ignored. Version can be specified as instance ID, tag or ref.
-// Will resolve tags and refs to concrete instance IDs.
+// Will resolve tags and refs to concrete instance IDs by calling the backend.
 func (client *Client) ProcessEnsureFile(r io.Reader) ([]common.Pin, error) {
-        // TODO(vadimsh): Resolve tags to instance IDs.
-
         lineNo := 0
         makeError := func(msg string) error {
                 return fmt.Errorf("Failed to parse desired state (line %d): %s", lineNo, msg)
         }
 
         out := []common.Pin{}
         scanner := bufio.NewScanner(r)
         for scanner.Scan() {
                 lineNo++
 
@@ skipping 12 matching lines @@
                 }
 
                 // Each line has a format "<package name> <version>".
                 if len(tokens) != 2 {
                         return nil, makeError("expecting '<package name> <version>' line")
                 }
                 err := common.ValidatePackageName(tokens[0])
                 if err != nil {
                         return nil, makeError(err.Error())
                 }
-                err = common.ValidateInstanceID(tokens[1])
+                err = common.ValidateInstanceVersion(tokens[1])
                 if err != nil {
                         return nil, makeError(err.Error())
                 }
 
                 // Good enough.
-                out = append(out, common.Pin{PackageName: tokens[0], InstanceID: tokens[1]})
+                pin, err := client.ResolveVersion(tokens[0], tokens[1])

[nodir, 2015/05/21 17:07:48]

You may want to have batch resolve

[Vadim Sh., 2015/05/21 18:00:37]

Yeah, I know. In practice CIPD is installing 1-2 packages, so no big deal doing
it sequentially (considering it simplifies code).

+                if err != nil {
+                        return nil, err
+                }
+                out = append(out, pin)
         }
 
         return out, nil
 }
 
 // EnsurePackages is high-level interface for installation, removal and updates
 // of packages inside some installation site root. Given a description of
 // what packages (and versions) should be installed it will do all necessary
 // actions to bring the state of the site root to the desired one.
 func (client *Client) EnsurePackages(root string, pins []common.Pin) error {
@@ skipping 88 matching lines @@
 
 type clock interface {
         now() time.Time
         sleep(time.Duration)
 }
 
 type remote interface {
         fetchACL(packagePath string) ([]PackageACL, error)
         modifyACL(packagePath string, changes []PackageACLChange) error
 
+        resolveVersion(packageName, version string) (common.Pin, error)
+
         initiateUpload(sha1 string) (*UploadSession, error)
         finalizeUpload(sessionID string) (bool, error)
         registerInstance(pin common.Pin) (*registerInstanceResponse, error)
 
         attachTags(pin common.Pin, tags []string) error
         fetchInstance(pin common.Pin) (*fetchInstanceResponse, error)
 }
 
 type storage interface {
         upload(url string, data io.ReadSeeker) error
@@ skipping 42 matching lines @@
 }
 
 // buildInstanceIDMap builds mapping {package name -> instance ID}.
 func buildInstanceIDMap(pins []common.Pin) map[string]string {
         out := map[string]string{}
         for _, p := range pins {
                 out[p.PackageName] = p.InstanceID
         }
         return out
 }