Add a package listing API to cipd.

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 23 matching lines @@
 */
 package cipd
 
 import (
         "bufio"
         "errors"
         "fmt"
         "io"
         "net/http"
         "os"
+        "sort"
         "strings"
         "time"
 
         "github.com/luci/luci-go/common/logging"
 
         "infra/tools/cipd/common"
         "infra/tools/cipd/local"
 )
 
 // PackageACLChangeAction defines a flavor of PackageACLChange.
@@ skipping 106 matching lines @@
         // processed" responses.
         AttachTagsWhenReady(pin common.Pin, tags []string) error
 
         // FetchInstance downloads package instance file from the repository.
         FetchInstance(pin common.Pin, output io.WriteSeeker) error
 
         // FetchAndDeployInstance fetches the package instance and deploys it into
         // the site root. It doesn't check whether the instance is already deployed.
         FetchAndDeployInstance(pin common.Pin) error
 
+        // ListPackages returns a list of strings of package names.
+        ListPackages(path string, recursive bool) ([]string, error)
+
         // 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 by calling the backend.
         ProcessEnsureFile(r io.Reader) ([]common.Pin, error)
 
         // EnsurePackages is high-level interface for installation, removal and update
         // of packages inside the installation site root. Given a description of
         // what packages (and versions) should be installed it will do all necessary
@@ skipping 91 matching lines @@
 }
 
 func (client *clientImpl) FetchACL(packagePath string) ([]PackageACL, error) {
         return client.remote.fetchACL(packagePath)
 }
 
 func (client *clientImpl) ModifyACL(packagePath string, changes []PackageACLChange) error {
         return client.remote.modifyACL(packagePath, changes)
 }
 
+func (client *clientImpl) ListPackages(path string, recursive bool) ([]string, error) {
+        pkgs, dirs, err := client.remote.listPackages(path, recursive)
+        if err != nil {
+                return nil, err
+        }
+
+        // Add trailing slash to directories.
+        for k, d := range dirs {

[Vadim Sh., 2015/06/23 00:08:35]

IIUC, that's the only place where dir vs pkg matter now?

How about embracing "dir can be a package" situation and just display it in UI
somehow. Show both dir (with "/") and package without ("/"). (I think it happens
now).

I know at least one example of filesystem-like datamodel where directories are
no special from leaf nodes: zookeeper. So it's not unheard of. 

My concern is that trying to keep directories as a special kind of entities can
lead to more complications than gains.

[estaab, 2015/06/23 02:26:13]

Sounds fine, we show both now.

+                dirs[k] = d + "/"
+        }
+        // Merge and sort packages and directories.
+        allPkgs := append(pkgs, dirs...)
+        sort.Sort(sort.StringSlice(allPkgs))

[Vadim Sh., 2015/06/23 00:08:35]

sort.Strings(allPkgs)

[estaab, 2015/06/23 02:26:14]

Done.

+        return allPkgs, nil
+}
+
 func (client *clientImpl) UploadToCAS(sha1 string, data io.ReadSeeker, session *UploadSession) error {
         // Open new upload session if an existing is not provided.
         var err error
         if session == nil {
                 client.Logger.Infof("cipd: uploading %s: initiating", sha1)
                 session, err = client.remote.initiateUpload(sha1)
                 if err != nil {
                         client.Logger.Warningf("cipd: can't upload %s - %s", sha1, err)
                         return err
                 }
@@ skipping 298 matching lines @@
         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)
+
+        listPackages(path string, recursive bool) ([]string, []string, error)
 }
 
 type storage interface {
         upload(url string, data io.ReadSeeker) error
         download(url string, output io.WriteSeeker) error
 }
 
 type registerInstanceResponse struct {
         uploadSession     *UploadSession
         alreadyRegistered bool
@@ skipping 36 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
 }