A transparent cache for datastore, backed by memcache.

impl/memory/raw_datastore_data.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 (
         "bytes"
         "fmt"
         "sync"
@@ skipping 45 matching lines @@
         return keyBytes(ds.WithoutContext,
                 ds.NewKey("", "", "__entity_group_ids__", "", 1, ds.KeyRoot(key)))
 }
 
 func rootIDsKey(kind string) []byte {
         return keyBytes(ds.WithoutContext,
                 ds.NewKey("", "", "__entity_root_ids__", kind, 0, nil))
 }
 
 func curVersion(ents *memCollection, key []byte) int64 {
-        if v := ents.Get(key); v != nil {
-                pm, err := rpm(v)
-                if err != nil {
-                        panic(err) // memory corruption
+        if ents != nil {
+                if v := ents.Get(key); v != nil {
+                        pm, err := rpm(v)
+                        if err != nil {
+                                panic(err) // memory corruption
+                        }
+                        pl, ok := pm["__version__"]
+                        if ok && len(pl) > 0 && pl[0].Type() == ds.PTInt {
+                                return pl[0].Value().(int64)
+                        }
+                        panic(fmt.Errorf("__version__ property missing or wrong: %v", pm))
                 }
-                pl, ok := pm["__version__"]
-                if ok && len(pl) > 0 && pl[0].Type() == ds.PTInt {
-                        return pl[0].Value().(int64)
-                }
-                panic(fmt.Errorf("__version__ property missing or wrong: %v", pm))
         }
         return 0
 }
 
 func incrementLocked(ents *memCollection, key []byte) int64 {
         ret := curVersion(ents, key) + 1
         buf := &bytes.Buffer{}
         ds.PropertyMap{"__version__": {ds.MkPropertyNI(ret)}}.Write(
                 buf, ds.WithContext)
         ents.Set(key, buf.Bytes())
@@ skipping 324 matching lines @@
 
 func rpm(data []byte) (ds.PropertyMap, error) {
         ret := ds.PropertyMap{}
         err := ret.Read(bytes.NewBuffer(data), ds.WithContext, "", "")
         return ret, err
 }
 
 type keyitem interface {
         Key() ds.Key
 }