impl/cloud: Add support for "memcached" memcache.

impl/cloud/context.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 cloud
 
 import (
+        "github.com/luci/gae/impl/dummy"
+        ds "github.com/luci/gae/service/datastore"
+        "github.com/luci/gae/service/mail"
+        mc "github.com/luci/gae/service/memcache"
+        "github.com/luci/gae/service/module"
+        "github.com/luci/gae/service/taskqueue"
+        "github.com/luci/gae/service/user"
+
         "cloud.google.com/go/datastore"
+        "github.com/bradfitz/gomemcache/memcache"
 
         "golang.org/x/net/context"
 )
 
-// Use installs the cloud services implementation into the supplied Context.
+// Config is a full-stack cloud service configuration. A user can selectively
+// populate its fields, and services for the populated fields will be installed
+// in the Context and available.
 //
-// This includes:
-//      - github.com/luci/gae/service/info
-//      - github.com/luci/gae/service/datastore
-//
-// This is built around the ability to use cloud datastore.
-func Use(c context.Context, client *datastore.Client) context.Context {
-        return UseDS(useInfo(c), client)
+// Because the "impl/cloud" service collection is a composite set of cloud
+// services, the user can choose services based on their configuration.
+type Config struct {

[iannucci, 2016/11/20 19:35:16]

This feels kinda wrong; there probably should be a 'setup' package which
contains all the various configurations, and then the impl/* should have
individual methods to get the various implementations or something. Then the
setup package could contain all the standard configurations (e.g. running in GAE
classic/Cloud/Memory, etc.) and any configurable hybrids that make sense.

Don't need to fix in this CL, but something to think about. Basically the
'service' packages already allow you to set the implementations independently.
Up till now there hasn't been any need for configuring mix and match
implementations, but now that there is I don't think it makes sense for that
configuration library code to live inside of one (or many) impl packages, if
that makes sense.

[dnj, 2016/11/20 22:28:47]

Yeah the mix-and-match world is definitely weird. I think for now having a
homogenous "cloud services" vision is fine. Splitting it up into pick-and-choose
can get more creative, but I think will still be containable.

+        // DS is the cloud datastore client. If populated, the datastore service will
+        // be installed.
+        DS *datastore.Client
+
+        // MC is the memcache service client. If populated, the memcache service will
+        // be installed.
+        MC *memcache.Client
 }
 
-// UseDS installs the cloud datastore implementation into the supplied Context.
-func UseDS(c context.Context, client *datastore.Client) context.Context {
-        cds := cloudDatastore{
-                client: client,
+// Use installs the Config into the supplied Context. Services will be installed
+// based on the fields that are populated in Config.
+//
+// Any services that are missing will have "impl/dummy" stubs installed. These
+// stubs will panic if called.
+func (cfg Config) Use(c context.Context) context.Context {
+        // Dummy services that we don't support.
+        c = mail.Set(c, dummy.Mail())
+        c = module.Set(c, dummy.Module())
+        c = taskqueue.SetRaw(c, dummy.TaskQueue())
+        c = user.Set(c, dummy.User())
+
+        c = useInfo(c)
+
+        // datastore service
+        if cfg.DS != nil {
+                cds := cloudDatastore{
+                        client: cfg.DS,
+                }
+                c = cds.use(c)
+        } else {
+                c = ds.SetRaw(c, dummy.Datastore())
         }
-        return cds.use(c)
+
+        // memcache service
+        if cfg.MC != nil {
+                mc := memcacheClient{
+                        client: cfg.MC,
+                }
+                c = mc.use(c)
+        } else {
+                c = mc.SetRaw(c, dummy.Memcache())
+        }
+
+        return c
 }