Add emulation of transaction retries to memory impl of RunInTransaction.

impl/memory/datastore.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 (
         "errors"
         "fmt"
 
         "golang.org/x/net/context"
 
         ds "github.com/luci/gae/service/datastore"
         "github.com/luci/gae/service/datastore/dskey"
 )
 
 //////////////////////////////////// public ////////////////////////////////////
 
 // useRDS adds a gae.Datastore implementation to context, accessible
 // by gae.GetDS(c)
 func useRDS(c context.Context) context.Context {
         return ds.SetRawFactory(c, func(ic context.Context) ds.RawInterface {
                 dsd := cur(ic).Get(memContextDSIdx)
 
                 ns := curGID(ic).namespace
                 if x, ok := dsd.(*dataStoreData); ok {
-                        return &dsImpl{x, ns, ic}
+                        return &dsImpl{x, ns, 0, ic}
                 }
                 return &txnDsImpl{dsd.(*txnDataStoreData), ns}
         })
 }
 
 //////////////////////////////////// dsImpl ////////////////////////////////////
 
 // dsImpl exists solely to bind the current c to the datastore data.
 type dsImpl struct {
-        data *dataStoreData
-        ns   string
-        c    context.Context
+        data         *dataStoreData
+        ns           string
+        txnFakeRetry int
+        c            context.Context
 }
 
 var _ ds.RawInterface = (*dsImpl)(nil)
 
 func (d *dsImpl) DecodeKey(encoded string) (ds.Key, error) {
         return dskey.NewFromEncoded(encoded)
 }
 
 func (d *dsImpl) NewKey(kind, stringID string, intID int64, parent ds.Key) ds.Key {
         return dskey.New(globalAppID, d.ns, kind, stringID, intID, parent)
@@ skipping 50 matching lines @@
 }
 
 func (d *dsImpl) SetIndexSnapshot(snap ds.TestingSnapshot) {
         d.data.setSnapshot(snap.(*memStore))
 }
 
 func (d *dsImpl) CatchupIndexes() {
         d.data.catchupIndexes()
 }
 
+func (d *dsImpl) SetTransactionRetryCount(count int) {
+        d.txnFakeRetry = count
+}
+
 func (d *dsImpl) Testable() ds.Testable {
         return d
 }
 
 ////////////////////////////////// txnDsImpl ///////////////////////////////////
 
 type txnDsImpl struct {
         data *txnDataStoreData
         ns   string
 }
@@ skipping 39 matching lines @@
         return errors.New("datastore: nested transactions are not supported")
 }
 
 func (d *txnDsImpl) NewQuery(kind string) ds.Query {
         return &queryImpl{ns: d.ns, kind: kind}
 }
 
 func (*txnDsImpl) Testable() ds.Testable {
         return nil
 }