cipd: Client can resolve tags to instance IDs.

go/src/infra/tools/cipd/remote.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
 
 import (
         "bytes"
         "encoding/json"
         "errors"
@@ skipping 164 matching lines @@
         case "PUBLISHED":
                 finished = true
         case "ERROR":
                 err = errors.New(reply.ErrorMessage)
         default:
                 err = fmt.Errorf("Unexpected upload session status: %s", reply.Status)
         }
         return
 }
 
+func (r *remoteImpl) resolveVersion(packageName, version string) (pin common.Pin, err error) {
+        if err = common.ValidatePackageName(packageName); err != nil {
+                return
+        }
+        if err = common.ValidateInstanceVersion(version); err != nil {
+                return
+        }
+        var reply struct {
+                Status       string `json:"status"`
+                ErrorMessage string `json:"error_message"`
+                InstanceID   string `json:"instance_id"`

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

I wish I warned you earlier, but from my small experience, I believe APIs should
be able to process many requests at a time. It happened in buildbucket with
heartbeats, build puts and build cancellations.

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

1) CIPD is not latency critical, thus I do not optimize it for latency.
2) It's Go. It's very easy and cheap to parallelize requests when needed. I
think 10 parallel requests to /resolve? should finish around the same time as a
single batched request.

+        }
+        params := url.Values{}
+        params.Add("package_name", packageName)
+        params.Add("version", version)
+        err = r.makeRequest("repo/v1/instance/resolve?"+params.Encode(), "GET", nil, &reply)
+        if err != nil {
+                return
+        }
+        switch reply.Status {
+        case "SUCCESS":
+                if common.ValidateInstanceID(reply.InstanceID) != nil {
+                        err = fmt.Errorf("Backend returned invalid instance ID: %s", reply.InstanceID)
+                } else {
+                        pin = common.Pin{PackageName: packageName, InstanceID: reply.InstanceID}
+                }
+        case "PACKAGE_NOT_FOUND":
+                err = fmt.Errorf("Package '%s' is not registered", packageName)
+        case "INSTANCE_NOT_FOUND":
+                err = fmt.Errorf("Package '%s' doesn't have instance with version '%s'", packageName, version)
+        case "AMBIGUOUS_VERSION":
+                err = fmt.Errorf("More than one instance of package '%s' match version '%s'", packageName, version)

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

What one is supposed to do in this case? Neither a tag, nor instance can be
removed. Once a tag is ambiguous, it is forever.
Add another tag?

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

The answer I was planning for is:
1) Add ACLs to tags.
2) Allow important tags to be set only by automated systems (buildbot).
3) Make sure automated system set tags in a unique way, so there's no
duplicates.

Also tags can be detached (there's endpoints API for this). And in general I do
not plan for tags to be used as version specifiers often. Refs will be used most
of the time (I hope).

[nodir, 2015/05/21 18:15:06]

Acknowledged.

+        case "ERROR":
+                err = errors.New(reply.ErrorMessage)
+        default:
+                err = fmt.Errorf("Unexpected backend response: %s", reply.Status)
+        }
+        return
+}
+
 func (r *remoteImpl) registerInstance(pin common.Pin) (*registerInstanceResponse, error) {
         endpoint, err := instanceEndpoint(pin)
         if err != nil {
                 return nil, err
         }
         var reply struct {
                 Status          string             `json:"status"`
                 Instance        packageInstanceMsg `json:"instance"`
                 UploadSessionID string             `json:"upload_session_id"`
                 UploadURL       string             `json:"upload_url"`
@@ skipping 47 matching lines @@
                 ts, err := convertTimestamp(reply.Instance.RegisteredTs)
                 if err != nil {
                         return nil, err
                 }
                 return &fetchInstanceResponse{
                         fetchURL:     reply.FetchURL,
                         registeredBy: reply.Instance.RegisteredBy,
                         registeredTs: ts,
                 }, nil
         case "PACKAGE_NOT_FOUND":
-                return nil, fmt.Errorf("Package '%s' is not registered or you do not have permission to fetch it", pin.PackageName)
+                return nil, fmt.Errorf("Package '%s' is not registered", pin.PackageName)
         case "INSTANCE_NOT_FOUND":
                 return nil, fmt.Errorf("Package '%s' doesn't have instance '%s'", pin.PackageName, pin.InstanceID)
         case "ERROR":
                 return nil, errors.New(reply.ErrorMessage)
         }
         return nil, fmt.Errorf("Unexpected reply status: %s", reply.Status)
 }
 
 func (r *remoteImpl) fetchACL(packagePath string) ([]PackageACL, error) {
         endpoint, err := aclEndpoint(packagePath)
@@ skipping 162 matching lines @@
 
 // convertTimestamp coverts string with int64 timestamp in microseconds since
 // to time.Time
 func convertTimestamp(ts string) (time.Time, error) {
         i, err := strconv.ParseInt(ts, 10, 64)
         if err != nil {
                 return time.Time{}, fmt.Errorf("Unexpected timestamp value '%s' in the server response", ts)
         }
         return time.Unix(0, i*1000), nil
 }