impl/memory: Disallow empty namespace.

filter/dscache/globalconfig.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 dscache
 
 import (
         "sync"
         "time"
 
         "github.com/luci/gae/service/datastore"
-        "github.com/luci/gae/service/info"
         "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.
 //
@@ skipping 44 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("")
-        if err != nil {
-                return true
-        }
         cfg := &GlobalConfig{Enable: true}
         if err := datastore.Get(c).Get(cfg); err != nil && err != datastore.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("")
-        if err != nil {
-                return err
-        }
         return datastore.Get(c).RunInTransaction(func(c context.Context) error {
                 ds := datastore.Get(c)
                 cfg := &GlobalConfig{Enable: true}
                 if err := ds.Get(cfg); err != nil && err != datastore.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 {
                                 return err
                         }
                 }
                 return ds.Put(cfg)
         }, nil)
 }