A transparent cache for datastore, backed by memcache.

impl/memory/memcache.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 memory
 
 import (
         "encoding/binary"
         "sync"
         "time"
@@ skipping 32 matching lines @@
 func (m *mcItem) SetFlags(flg uint32) mc.Item {
         m.flags = flg
         return m
 }
 func (m *mcItem) SetExpiration(exp time.Duration) mc.Item {
         m.expiration = exp
         return m
 }
 
 func (m *mcItem) SetAll(other mc.Item) {
-        *m = *other.(*mcItem)
+        if other == nil {
+                *m = mcItem{key: m.key}
+        } else {
+                k := m.key
+                *m = *other.(*mcItem)
+                m.key = k
+        }
 }
 
 type mcDataItem struct {
         value      []byte
         flags      uint32
         expiration time.Time
         casID      uint64
 }
 
 func (m *mcDataItem) toUserItem(key string) *mcItem {
@@ skipping 80 matching lines @@
         data *memcacheData
         ctx  context.Context
 }
 
 var _ mc.RawInterface = (*memcacheImpl)(nil)
 
 // useMC adds a gae.Memcache implementation to context, accessible
 // by gae.GetMC(c)
 func useMC(c context.Context) context.Context {
         lck := sync.Mutex{}
+        // TODO(riannucci): just use namespace for automatic key prefixing. Flush
+        // actually wipes the ENTIRE memcache, regardless of namespace.
         mcdMap := map[string]*memcacheData{}
 
         return mc.SetRawFactory(c, func(ic context.Context) mc.RawInterface {
                 lck.Lock()
                 defer lck.Unlock()
 
                 ns := curGID(ic).namespace
                 mcd, ok := mcdMap[ns]
                 if !ok {
                         mcd = &memcacheData{items: map[string]*mcDataItem{}}
@@ skipping 29 matching lines @@
 
 func (m *memcacheImpl) AddMulti(items []mc.Item, cb mc.RawCB) error {
         now := clock.Now(m.ctx)
         doCBs(items, cb, func(itm mc.Item) error {
                 m.data.lock.Lock()
                 defer m.data.lock.Unlock()
                 if !m.data.hasItemLocked(now, itm.Key()) {
                         m.data.setItemLocked(now, itm)
                         return nil
                 } else {
-                        return (mc.ErrNotStored)
+                        return mc.ErrNotStored
                 }
         })
         return nil
 }
 
 func (m *memcacheImpl) CompareAndSwapMulti(items []mc.Item, cb mc.RawCB) error {
         now := clock.Now(m.ctx)
         doCBs(items, cb, func(itm mc.Item) error {
                 m.data.lock.Lock()
                 defer m.data.lock.Unlock()
@@ skipping 121 matching lines @@
         return cur, nil
 }
 
 func (m *memcacheImpl) Stats() (*mc.Statistics, error) {
         m.data.lock.RLock()
         defer m.data.lock.RUnlock()
 
         ret := m.data.stats
         return &ret, nil
 }