Implement a server-side config service interface.

server/config/service.go

+// Copyright 2016 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 config
+
+import (
+        "net/http"
+        "net/url"
+        "sync"
+
+        "github.com/luci/luci-go/common/config"
+        "github.com/luci/luci-go/common/config/impl/remote"
+        "github.com/luci/luci-go/common/errors"
+        "github.com/luci/luci-go/server/auth"
+
+        "golang.org/x/net/context"
+)
+
+// ClientProvider returns a config.Interface for the supplied parameters.
+type ClientProvider interface {
+        GetConfigClient(context.Context, Authority) config.Interface
+}
+
+// ClientBackend returns a Backend implementation that falls through to the
+// supplied client config.Interface supplied by the Provider.
+//
+// url is the base URL to the configuration service, e.g.,
+// https://example.appspot.com.
+type ClientBackend struct {
+        Provider ClientProvider
+}
+
+var _ Backend = (*ClientBackend)(nil)
+
+// ServiceURL implements Backend.
+func (cb *ClientBackend) ServiceURL(c context.Context) url.URL {
+        return cb.getIface(c, AsAnonymous).ServiceURL(c)
+}
+
+// ConfigSetURL implements Backend.
+func (cb *ClientBackend) ConfigSetURL(c context.Context, a Authority, configSet string) (url.URL, error) {
+        u, err := cb.getIface(c, a).GetConfigSetLocation(c, configSet)
+        if err != nil || u == nil {
+                return url.URL{}, err
+        }
+        return *u, nil
+}
+
+// Get implements Backend.
+func (cb *ClientBackend) Get(c context.Context, configSet, path string, p Params) (*Item, error) {
+        svc := cb.getIface(c, p.Authority)
+
+        cfg, err := svc.GetConfig(c, configSet, path, !p.Content)
+        if err != nil {
+                return nil, translateConfigErr(err)
+        }
+
+        return makeItem(cfg), nil
+}
+
+// GetAll implements Backend.
+func (cb *ClientBackend) GetAll(c context.Context, t GetAllType, path string, p Params) ([]*Item, error) {
+        svc := cb.getIface(c, p.Authority)
+
+        var fn func(context.Context, string, bool) ([]config.Config, error)
+        switch t {
+        case Project:
+                fn = svc.GetProjectConfigs
+        case Ref:
+                fn = svc.GetRefConfigs
+        default:
+                return nil, errors.Reason("unknown GetAllType: %(type)q").D("type", t).Err()
+        }
+
+        cfgs, err := fn(c, path, !p.Content)
+        if err != nil || len(cfgs) == 0 {
+                return nil, translateConfigErr(err)
+        }
+
+        items := make([]*Item, len(cfgs))
+        for i := range cfgs {
+                items[i] = makeItem(&cfgs[i])
+        }
+        return items, nil
+}
+
+func (cb *ClientBackend) getIface(c context.Context, a Authority) config.Interface {
+        return cb.Provider.GetConfigClient(c, a)
+}
+
+// RemoteClientProvider is a ClientProvider implementation that binds to
+// a remote configuration service.
+type RemoteClientProvider struct {
+        // BaseURL is the base URL to the configuration service, e.g.,
+        // https://example.appspot.com.
+        BaseURL string
+
+        cacheLock sync.RWMutex
+        cache     map[Authority]config.Interface
+
+        // testUserDelegationToken, if not nil, is the delegation token to use for
+        // AsUser calls. This is done to mock delegation token generation.
+        testUserDelegationToken string
+}
+
+var _ ClientProvider = (*RemoteClientProvider)(nil)
+
+// GetConfigClient implements ClientProvider.
+func (p *RemoteClientProvider) GetConfigClient(c context.Context, a Authority) config.Interface {
+        p.cacheLock.RLock()
+        impl, ok := p.cache[a]
+        p.cacheLock.RUnlock()
+        if ok {
+                return impl
+        }
+
+        p.cacheLock.Lock()
+        defer p.cacheLock.Unlock()
+
+        if impl, ok := p.cache[a]; ok {
+                return impl
+        }
+
+        // Create our remote implementation.
+        impl = remote.New(p.BaseURL+"/_ah/api/config/v1/", func(c context.Context) (*http.Client, error) {
+                var opts []auth.RPCOption
+                if a == AsUser && p.testUserDelegationToken != "" {
+                        opts = append(opts, auth.WithDelegationToken(p.testUserDelegationToken))
+                }
+                t, err := auth.GetRPCTransport(c, a.rpcAuthorityKind(), opts...)
+                if err != nil {
+                        return nil, err
+                }
+                return &http.Client{Transport: t}, nil
+        })
+        if p.cache == nil {
+                p.cache = make(map[Authority]config.Interface, 3)
+        }
+        p.cache[a] = impl
+
+        return impl
+}
+
+func translateConfigErr(err error) error {
+        switch err {
+        case config.ErrNoConfig:
+                return ErrNoConfig
+        default:
+                return err
+        }
+}
+
+func makeItem(cfg *config.Config) *Item {
+        return &Item{
+                Meta: Meta{
+                        ConfigSet:   cfg.ConfigSet,
+                        Path:        cfg.Path,
+                        ContentHash: cfg.ContentHash,
+                        Revision:    cfg.Revision,
+                },
+                Content: cfg.Content,
+        }
+}