A transparent cache for datastore, backed by memcache.

service/memcache/memcache.go

Index: service/memcache/memcache.go
diff --git a/service/memcache/memcache.go b/service/memcache/memcache.go
index e9a1e40bd77ffc08e0440b43156c64ceb32af267..e2ba498d7d6cdb4cba339ecae697c7df42e32f28 100644
--- a/service/memcache/memcache.go
+++ b/service/memcache/memcache.go
@@ -33,12 +33,27 @@ func (m *memcacheImpl) CompareAndSwap(item Item) error {
 	return errors.SingleError(m.CompareAndSwapMulti([]Item{item}))
 }
 
-func multiCall(items []Item, inner func(items []Item, cb RawCB) error) error {
+func filterItems(lme *errors.LazyMultiError, items []Item, nilErr error) ([]Item, []int) {

[dnj, 2015/08/05 18:32:18]

We can catch duplicate "set" here, too, by working backwards and discarding
duplicate keys.

[iannucci, 2015/08/06 01:54:02]

uuuuggggggghhhhh :(

+	idxMap := make([]int, 0, len(items))
+	retItems := make([]Item, 0, len(items))
+	for i, itm := range items {
+		if itm != nil {
+			idxMap = append(idxMap, i)
+			retItems = append(retItems, itm)
+		} else {
+			lme.Assign(i, nilErr)
+		}
+	}
+	return retItems, idxMap
+}
+
+func multiCall(items []Item, nilErr error, inner func(items []Item, cb RawCB) error) error {
 	lme := errors.LazyMultiError{Size: len(items)}
-	i := 0
-	err := inner(items, func(err error) {
-		lme.Assign(i, err)
-		i++
+	realItems, idxMap := filterItems(&lme, items, nilErr)
+	j := 0

[dnj, 2015/08/05 18:32:18]

What was wrong with "i"?

[iannucci, 2015/08/06 01:54:02]

b/c I'm using i for the index into the input map and j into the idxMap... not
apparent right here, I know, but I do it elsewhere.

+	err := inner(realItems, func(err error) {
+		lme.Assign(idxMap[j], err)
+		j++
 	})
 	if err == nil {
 		err = lme.Get()
@@ -47,15 +62,15 @@ func multiCall(items []Item, inner func(items []Item, cb RawCB) error) error {
 }
 
 func (m *memcacheImpl) AddMulti(items []Item) error {
-	return multiCall(items, m.RawInterface.AddMulti)
+	return multiCall(items, ErrNotStored, m.RawInterface.AddMulti)
 }
 
 func (m *memcacheImpl) SetMulti(items []Item) error {
-	return multiCall(items, m.RawInterface.SetMulti)
+	return multiCall(items, ErrNotStored, m.RawInterface.SetMulti)
 }
 
 func (m *memcacheImpl) CompareAndSwapMulti(items []Item) error {
-	return multiCall(items, m.RawInterface.CompareAndSwapMulti)
+	return multiCall(items, ErrNotStored, m.RawInterface.CompareAndSwapMulti)
 }
 
 func (m *memcacheImpl) DeleteMulti(keys []string) error {
@@ -73,16 +88,23 @@ func (m *memcacheImpl) DeleteMulti(keys []string) error {
 
 func (m *memcacheImpl) GetMulti(items []Item) error {
 	lme := errors.LazyMultiError{Size: len(items)}
-	i := 0
-	keys := make([]string, len(items))
-	for i, itm := range items {
+	realItems, idxMap := filterItems(&lme, items, ErrCacheMiss)
+	if len(realItems) == 0 {
+		return lme.Get()
+	}
+
+	keys := make([]string, len(realItems))
+	for i, itm := range realItems {
 		keys[i] = itm.Key()
 	}
+
+	j := 0
 	err := m.RawInterface.GetMulti(keys, func(item Item, err error) {
+		i := idxMap[j]

[iannucci, 2015/08/06 01:54:02]

like right here!

 		if !lme.Assign(i, err) {
 			items[i].SetAll(item)
 		}
-		i++
+		j++
 	})
 	if err == nil {
 		err = lme.Get()