Add counter-write and counter-read commands.

cipd/client/cipd/remote.go

 // Copyright 2014 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 cipd
 
 import (
         "bytes"
         "encoding/json"
         "errors"
@@ skipping 622 matching lines @@
                 for i, instance := range reply.Instances {
                         pins[i] = common.Pin{instance.PackageName, instance.InstanceID}
                 }
                 return pins, nil
         case "ERROR":
                 return nil, errors.New(reply.ErrorMessage)
         }
         return nil, fmt.Errorf("unexpected searchInstances status: %s", reply.Status)
 }
 
+func (r *remoteImpl) incrementCounter(ctx context.Context, pin common.Pin, counter string, delta int) error {
+        endpoint, err := counterEndpoint(pin, counter)
+        if err != nil {
+                return err
+        }
+
+        var request struct {
+                Delta int `json:"delta"`
+        }
+        request.Delta = delta
+
+        var reply struct {
+                Status       string `json:"status"`
+                ErrorMessage string `json:"error_message"`
+        }
+        err = r.makeRequest(ctx, endpoint, "POST", &request, &reply)
+        if err != nil {
+                return err
+        }
+        switch reply.Status {
+        case "SUCCESS":
+                return nil
+        case "ERROR":
+                return errors.New(reply.ErrorMessage)
+        }
+        return fmt.Errorf("unexpected incrementCounter status: %s", reply.Status)
+}
+
+func (r *remoteImpl) readCounter(ctx context.Context, pin common.Pin, counter string) (Counter, error) {
+        endpoint, err := counterEndpoint(pin, counter)
+        if err != nil {
+                return Counter{}, err
+        }
+
+        var reply struct {
+                Status       string `json:"status"`
+                ErrorMessage string `json:"error_message"`
+
+                Value     string `json:"value"`
+                CreatedTS string `json:"created_ts"`
+                UpdatedTS string `json:"updated_ts"`
+        }
+        err = r.makeRequest(ctx, endpoint, "GET", nil, &reply)
+        if err != nil {
+                return Counter{}, err
+        }
+        switch reply.Status {
+        case "SUCCESS":
+                ret := Counter{Name: counter}
+                if ret.Value, err = strconv.ParseInt(reply.Value, 10, 64); err != nil {
+                        return Counter{}, fmt.Errorf("unexpected counter value %q in the server response", reply.Value)
+                }
+                if reply.CreatedTS != "" {
+                        ts, err := convertTimestamp(reply.CreatedTS)
+                        if err != nil {
+                                return Counter{}, err
+                        }
+                        ret.CreatedTS = UnixTime(ts)
+                }
+                if reply.UpdatedTS != "" {
+                        ts, err := convertTimestamp(reply.UpdatedTS)
+                        if err != nil {
+                                return Counter{}, err
+                        }
+                        ret.UpdatedTS = UnixTime(ts)
+                }
+                return ret, nil
+        case "ERROR":
+                return Counter{}, errors.New(reply.ErrorMessage)
+        }
+        return Counter{}, fmt.Errorf("unexpected readCounter status: %s", reply.Status)
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 
 func packageEndpoint(packageName string) (string, error) {
         if err := common.ValidatePackageName(packageName); err != nil {
                 return "", err
         }
         params := url.Values{}
         params.Add("package_name", packageName)
         return "repo/v1/package?" + params.Encode(), nil
 }
@@ skipping 77 matching lines @@
         }
         params := url.Values{}
         params.Add("package_name", pin.PackageName)
         params.Add("instance_id", pin.InstanceID)
         for _, tag := range tags {
                 params.Add("tag", tag)
         }
         return "repo/v1/tags?" + params.Encode(), nil
 }
 
+func counterEndpoint(pin common.Pin, counterName string) (string, error) {
+        params := url.Values{}
+        params.Add("package_name", pin.PackageName)
+        params.Add("instance_id", pin.InstanceID)
+        params.Add("counter_name", counterName)
+        return "repo/v1/counter?" + params.Encode(), nil
+}
+
 // 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 %q in the server response", ts)
         }
         return time.Unix(0, i*1000), nil
 }