cipd: Client can resolve tags to instance IDs.

go/src/infra/tools/cipd/remote.go

Index: go/src/infra/tools/cipd/remote.go
diff --git a/go/src/infra/tools/cipd/remote.go b/go/src/infra/tools/cipd/remote.go
index 7bb25f8e8f62f5a883967f4344721fe613e1f786..cf306402dc7360110b795b2bc0bd4648aa4e7c4c 100644
--- a/go/src/infra/tools/cipd/remote.go
+++ b/go/src/infra/tools/cipd/remote.go
@@ -182,6 +182,46 @@ func (r *remoteImpl) finalizeUpload(sessionID string) (finished bool, err error)
 	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 {
@@ -249,7 +289,7 @@ func (r *remoteImpl) fetchInstance(pin common.Pin) (*fetchInstanceResponse, erro
 			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":