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 77 matching lines @@
         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
 }
 
 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) 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()
+}