Add a package listing API to cipd.

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 108 matching lines @@
 
                 // Success?
                 if resp.StatusCode < 300 {
                         return json.Unmarshal(responseBody, response)
                 }
 
                 // Fatal error?
                 if resp.StatusCode == 403 || resp.StatusCode == 401 {
                         return ErrAccessDenined
                 }
-                return fmt.Errorf("Unexpected reply (HTTP %d):\n%s", resp.StatusCode, string(body))
+                return fmt.Errorf("Unexpected reply (HTTP %d):\n%s", resp.StatusCode, string(responseBody))
         }
 
         return ErrBackendInaccessible
 }
 
 func (r *remoteImpl) initiateUpload(sha1 string) (s *UploadSession, err error) {
         var reply struct {
                 Status          string `json:"status"`
                 UploadSessionID string `json:"upload_session_id"`
                 UploadURL       string `json:"upload_url"`
@@ skipping 303 matching lines @@
         case "SUCCESS":
                 return nil
         case "PROCESSING_NOT_FINISHED_YET":
                 return &pendingProcessingError{reply.ErrorMessage}
         case "ERROR", "PROCESSING_FAILED":
                 return errors.New(reply.ErrorMessage)
         }
         return fmt.Errorf("Unexpected status when attaching tags: %s", reply.Status)
 }
 
+func (r *remoteImpl) listPackages(path string, recursive bool) ([]string, []string, error) {
+        endpoint, err := packageSearchEndpoint(path, recursive)
+        if err != nil {
+                return nil, nil, err
+        }
+        var reply struct {
+                Status       string   `json:"status"`
+                ErrorMessage string   `json:"error_message"`
+                Packages     []string `json:"packages"`
+                Directories  []string `json:"directories"`
+        }
+        err = r.makeRequest(endpoint, "GET", nil, &reply)
+        if err != nil {
+                return nil, nil, err
+        }
+        switch reply.Status {
+        case "SUCCESS":
+                packages := reply.Packages
+                directories := reply.Directories
+                return packages, directories, nil
+        case "ERROR":
+                return nil, nil, errors.New(reply.ErrorMessage)
+        }
+        return nil, nil, fmt.Errorf("Unexpected list packages status: %s", reply.Status)
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 
 func instanceEndpoint(pin common.Pin) (string, error) {
         if err := common.ValidatePin(pin); err != nil {
                 return "", err
         }
         params := url.Values{}
         params.Add("package_name", pin.PackageName)
         params.Add("instance_id", pin.InstanceID)
         return "repo/v1/instance?" + params.Encode(), nil
@@ skipping 14 matching lines @@
         }
         if err := common.ValidatePackageRef(ref); err != nil {
                 return "", err
         }
         params := url.Values{}
         params.Add("package_name", packageName)
         params.Add("ref", ref)
         return "repo/v1/ref?" + params.Encode(), nil
 }
 
+func packageSearchEndpoint(path string, recursive bool) (string, error) {
+        params := url.Values{}
+        params.Add("path", path)
+        recursiveString := "false"
+        if recursive {
+                recursiveString = "true"
+        }
+        params.Add("recursive", recursiveString)
+        return "repo/v1/package/search?" + params.Encode(), nil
+}
+
 func tagsEndpoint(pin common.Pin, tags []string) (string, error) {
         if err := common.ValidatePin(pin); err != nil {
                 return "", err
         }
         for _, tag := range tags {
                 if err := common.ValidateInstanceTag(tag); err != nil {
                         return "", err
                 }
         }
         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
 }
 
 // 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
 }