impl/memory: Replace gkvlite with "treapstore".

impl/memory/memstore_tracing_utils.go

 // Copyright 2015 The LUCI Authors. All rights reserved.
 // Use of this source code is governed under the Apache License, Version 2.0
 // that can be found in the LICENSE file.
 
 package memory
 
 import (
         "encoding/hex"
         "flag"
         "fmt"
         "io/ioutil"
         "os"
         "path/filepath"
         "runtime"
         "strings"
         "sync"
         "sync/atomic"
-
-        "github.com/luci/gkvlite"
 )
 
 var logMemCollectionFolder = flag.String(
-        "luci.gae.gkvlite_trace_folder", "",
+        "luci.gae.store_trace_folder", "",
         "Set to a folder path to enable debugging traces to be dumped there. Set to '-' to dump to stdout.")
 var logMemCollectionFolderTmp string
 var logMemCollectionOnce sync.Once
 var logMemCounter uint32
-var logMemNameKey = "holds a string indicating the GKVLiteDebuggingTraceName"
+var logMemNameKey = "holds a string indicating the StoreDebuggingTraceName"
 var stdoutLock sync.Mutex
 
 func wrapTracingMemStore(store memStore) memStore {
         var writer traceWriter
         logNum := atomic.AddUint32(&logMemCounter, 1) - 1
         collName := fmt.Sprintf("coll%d", logNum)
 
         if *logMemCollectionFolder == "-" {
                 writer = func(format string, a ...interface{}) {
                         stdoutLock.Lock()
                         defer stdoutLock.Unlock()
                         fmt.Printf(format+"\n", a...)
                 }
         } else {
                 logMemCollectionOnce.Do(func() {
                         var err error
-                        logMemCollectionFolderTmp, err = ioutil.TempDir(*logMemCollectionFolder, "luci-gae-gkvlite_trace")
+                        logMemCollectionFolderTmp, err = ioutil.TempDir(*logMemCollectionFolder, "luci-gae-store_trace")
                         if err != nil {
                                 panic(err)
                         }
                         logMemCollectionFolderTmp, err = filepath.Abs(logMemCollectionFolderTmp)
                         if err != nil {
                                 panic(err)
                         }
-                        fmt.Fprintf(os.Stderr, "Saving GKVLite trace files to %q\n", logMemCollectionFolderTmp)
+                        fmt.Fprintf(os.Stderr, "Saving store trace files to %q\n", logMemCollectionFolderTmp)
                 })
                 if logMemCollectionFolderTmp == "" {
                         panic("unable to create folder for tracefiles")
                 }
 
                 lck := sync.Mutex{}
                 fname := fmt.Sprintf(filepath.Join(logMemCollectionFolderTmp, fmt.Sprintf("%d.trace", logNum)))
                 fil, err := os.Create(fname)
                 if err != nil {
                         panic(err)
@@ skipping 47 matching lines @@
         return t.collName
 }
 
 func (t *tracingMemStoreImpl) GetCollection(name string) memCollection {
         coll := t.i.GetCollection(name)
         if coll == nil {
                 t.w("// %s.GetCollection(%q) -> nil", t.ident(), name)
                 return nil
         }
         writer := t.colWriter("GetCollection", name)
-        return &tracingMemCollectionImpl{coll, writer, 0}
+        return &tracingMemCollectionImpl{coll, writer, 0, 0}
 }
 
 func (t *tracingMemStoreImpl) GetCollectionNames() []string {
         t.w("%s.GetCollectionNames()", t.ident())
         return t.i.GetCollectionNames()
 }
 
 func (t *tracingMemStoreImpl) GetOrCreateCollection(name string) memCollection {
         writer := t.colWriter("GetOrCreateCollection", name)
-        return &tracingMemCollectionImpl{t.i.GetOrCreateCollection(name), writer, 0}
+        return &tracingMemCollectionImpl{t.i.GetOrCreateCollection(name), writer, 0, 0}
 }
 
 func (t *tracingMemStoreImpl) Snapshot() memStore {
         snap := t.i.Snapshot()
         if snap == t.i {
                 t.w("// %s.Snapshot() -> self", t.ident())
                 return t
         }
         ret := &tracingMemStoreImpl{snap, t.w, t.collName, t.snapNum, true}
         t.w("%s := %s.Snapshot()", ret.ident(), t.ident())
         t.snapNum++
         return ret
 }
 
 func (t *tracingMemStoreImpl) IsReadOnly() bool {
         return t.i.IsReadOnly()
 }
 
 type tracingMemCollectionImpl struct {
-        i           memCollection
-        w           traceWriter
-        visitNumber uint
+        i memCollection
+        w traceWriter
+
+        iterNumber    uint
+        forEachNumber uint
 }
 
 var _ memCollection = (*tracingMemCollectionImpl)(nil)
 
 func (t *tracingMemCollectionImpl) Name() string {
         return t.i.Name()
 }
 
-func (t *tracingMemCollectionImpl) Delete(k []byte) bool {
+func (t *tracingMemCollectionImpl) Delete(k []byte) {
         t.w(".Delete(%#v)", k)
-        return t.i.Delete(k)
+        t.i.Delete(k)
 }
 
 func (t *tracingMemCollectionImpl) Get(k []byte) []byte {
         t.w(".Get(%#v)", k)
         return t.i.Get(k)
 }
 
-func (t *tracingMemCollectionImpl) GetTotals() (numItems, numBytes uint64) {
-        t.w(".GetTotals()")
-        return t.i.GetTotals()
-}
-
-func (t *tracingMemCollectionImpl) MinItem(withValue bool) *gkvlite.Item {
-        t.w(".MinItem(%t)", withValue)
-        return t.i.MinItem(withValue)
+func (t *tracingMemCollectionImpl) MinItem() *storeEntry {
+        t.w(".MinItem()")
+        return t.i.MinItem()
 }
 
 func (t *tracingMemCollectionImpl) Set(k, v []byte) {
         t.w(".Set(%#v, %#v)", k, v)
         t.i.Set(k, v)
 }
 
-func (t *tracingMemCollectionImpl) VisitItemsAscend(target []byte, withValue bool, visitor gkvlite.ItemVisitor) {
-        vnum := t.visitNumber
-        t.visitNumber++
+func (t *tracingMemCollectionImpl) Iterator(pivot []byte) memIterator {
+        inum := t.iterNumber
+        t.iterNumber++
 
-        t.w(".VisitItemsAscend(%#v, %t, func(i *gkvlite.Item) bool{ return true }) // BEGIN VisitItemsAscend(%d)", target, withValue, vnum)
-        defer t.w("// END VisitItemsAscend(%d)", vnum)
-        t.i.VisitItemsAscend(target, withValue, visitor)
+        t.w(".Iterator(%#v) // Created Iterator #%d", pivot, inum)
+        return &tracingMemIteratorImpl{t.i.Iterator(pivot), t.w, inum}
+}
+
+func (t *tracingMemCollectionImpl) ForEachItem(fn memVisitor) {
+        vnum := t.forEachNumber
+        t.forEachNumber++
+
+        t.w(".ForEachItem(func(k, v []byte) bool{ return true }) // BEGIN ForEachItem(%d)", vnum)
+        defer t.w("// END ForEachItem(%d)", vnum)
+        t.i.ForEachItem(fn)
 }
 
 func (t *tracingMemCollectionImpl) IsReadOnly() bool {
         return t.i.IsReadOnly()
 }
+
+type tracingMemIteratorImpl struct {
+        i   memIterator
+        w   traceWriter
+        num uint
+}
+
+func (t *tracingMemIteratorImpl) Next() *storeEntry {
+        t.w(".Next() // Iterator #%d", t.num)
+        return t.i.Next()
+}