Interface update, per-method Contexts.

filter/dscache/globalconfig.go

 // Copyright 2015 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 dscache
 
 import (
         "sync"
         "time"
 
-        "github.com/luci/gae/service/datastore"
+        ds "github.com/luci/gae/service/datastore"
         "github.com/luci/gae/service/info"
-        "github.com/luci/gae/service/memcache"
+        mc "github.com/luci/gae/service/memcache"
+
         "github.com/luci/luci-go/common/clock"
+
         "golang.org/x/net/context"
 )
 
 // GlobalConfig is the entity definition for dscache's global configuration.
 //
 // It's Enable field can be set to false to cause all dscache operations
 // (read and write) to cease in a given application.
 //
 // This should be manipulated in the GLOBAL (e.g. empty) namespace only. When
 // written there, it affects activity in all namespaces.
@@ skipping 42 matching lines @@
         }
 
         globalEnabledLock.Lock()
         defer globalEnabledLock.Unlock()
         // just in case we raced
         if now.Before(globalEnabledNextCheck) {
                 return globalEnabled
         }
 
         // always go to the default namespace
-        c, err := info.Get(c).Namespace("")
+        c, err := info.Namespace(c, "")
         if err != nil {
                 return true
         }
         cfg := &GlobalConfig{Enable: true}
-        if err := datastore.Get(c).Get(cfg); err != nil && err != datastore.ErrNoSuchEntity {
+        if err := ds.Get(c, cfg); err != nil && err != ds.ErrNoSuchEntity {
                 return true
         }
         globalEnabled = cfg.Enable
         globalEnabledNextCheck = now.Add(GlobalEnabledCheckInterval)
         return globalEnabled
 }
 
 // SetGlobalEnable is a convenience function for manipulating the GlobalConfig.
 //
 // It's meant to be called from admin handlers on your app to turn dscache
 // functionality on or off in emergencies.
 func SetGlobalEnable(c context.Context, memcacheEnabled bool) error {
         // always go to the default namespace
-        c, err := info.Get(c).Namespace("")
+        c, err := info.Namespace(c, "")
         if err != nil {
                 return err
         }
-        return datastore.Get(c).RunInTransaction(func(c context.Context) error {
-                ds := datastore.Get(c)
+        return ds.RunInTransaction(c, func(c context.Context) error {
                 cfg := &GlobalConfig{Enable: true}
-                if err := ds.Get(cfg); err != nil && err != datastore.ErrNoSuchEntity {
+                if err := ds.Get(c, cfg); err != nil && err != ds.ErrNoSuchEntity {
                         return err
                 }
                 if cfg.Enable == memcacheEnabled {
                         return nil
                 }
                 cfg.Enable = memcacheEnabled
                 if memcacheEnabled {
                         // when going false -> true, wipe memcache.
-                        if err := memcache.Get(c).Flush(); err != nil {
+                        if err := mc.Flush(c); err != nil {
                                 return err
                         }
                 }
-                return ds.Put(cfg)
+                return ds.Put(c, cfg)
         }, nil)
 }