Refactor current GAE abstraction library to be free of the SDK*

go/src/infra/gae/libs/memlock/memlock.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 memlock allows multiple appengine handlers to coordinate best-effort
 // mutual execution via memcache. "best-effort" here means "best-effort"...
 // memcache is not reliable. However, colliding on memcache is a lot cheaper
 // than, for example, colliding with datastore transactions.
 package memlock
 
 import (
         "bytes"
         "errors"
-        "infra/gae/libs/wrapper"
-        "infra/libs/clock"
+        "golang.org/x/net/context"
         "sync/atomic"
         "time"
 
+        "infra/gae/libs/gae"
+
+        "github.com/luci/luci-go/common/clock"
         "github.com/luci/luci-go/common/logging"
-        "golang.org/x/net/context"
-
-        "appengine/memcache"
 )
 
 // ErrFailedToLock is returned from TryWithLock when it fails to obtain a lock
 // prior to invoking the user-supplied function.
 var ErrFailedToLock = errors.New("memlock: failed to obtain lock")
 
 // ErrEmptyClientID is returned from TryWithLock when you specify an empty
 // clientID.
 var ErrEmptyClientID = errors.New("memlock: empty clientID")
 
@@ skipping 27 matching lines @@
 // this client (lock-holder). If it's empty then TryWithLock() will return
 // ErrEmptyClientID.
 func TryWithLock(ctx context.Context, key, clientID string, f func(check func() bool) error) error {
         if len(clientID) == 0 {
                 return ErrEmptyClientID
         }
 
         ctx = logging.SetField(ctx, "key", key)
         ctx = logging.SetField(ctx, "clientID", clientID)
         log := logging.Get(ctx)
-        mc := wrapper.GetMC(ctx)
+        mc := gae.GetMC(ctx)
 
         key = memlockKeyPrefix + key
         cid := []byte(clientID)
 
         // checkAnd gets the current value from memcache, and then attempts to do the
         // checkOp (which can either be `refresh` or `release`). These pieces of
         // functionality are necessarially intertwined, because CAS only works with
         // the exact-same *Item which was returned from a Get.
         //
         // refresh will attempt to CAS the item with the same content to reset it's
         // timeout.
         //
         // release will attempt to CAS the item to remove it's contents (clientID).
         // another lock observing an empty clientID will know that the lock is
         // obtainable.
         checkAnd := func(op checkOp) bool {
                 itm, err := mc.Get(key)
                 if err != nil {
                         log.Warningf("error getting: %s", err)
                         return false
                 }
 
-                if len(itm.Value) > 0 && !bytes.Equal(itm.Value, cid) {
-                        log.Infof("lock owned by %q", string(itm.Value))
+                if len(itm.Value()) > 0 && !bytes.Equal(itm.Value(), cid) {
+                        log.Infof("lock owned by %q", string(itm.Value()))
                         return false
                 }
 
                 if op == refresh {
-                        itm.Value = cid
-                        itm.Expiration = memcacheLockTime
+                        itm.SetValue(cid).SetExpiration(memcacheLockTime)
                 } else {
-                        if len(itm.Value) == 0 {
+                        if len(itm.Value()) == 0 {
                                 // it's already unlocked, no need to CAS
                                 log.Infof("lock already released")
                                 return true
                         }
-                        itm.Value = []byte{}
-                        itm.Expiration = delay
+                        itm.SetValue([]byte{}).SetExpiration(delay)
                 }
 
                 err = mc.CompareAndSwap(itm)
                 if err != nil {
                         log.Warningf("failed to %s lock: %q", op, err)
                         return false
                 }
 
                 return true
         }
 
         // Now the actual logic begins. First we 'Add' the item, which will set it if
         // it's not present in the memcache, otherwise leaves it alone.
-        err := mc.Add(&memcache.Item{
-                Key: key, Value: cid, Expiration: memcacheLockTime})
+
+        err := mc.Add(mc.NewItem(key).SetValue(cid).SetExpiration(memcacheLockTime))
         if err != nil {
-                if err != memcache.ErrNotStored {
+                if err != gae.ErrMCNotStored {
                         log.Warningf("error adding: %s", err)
                 }
                 if !checkAnd(refresh) {
                         return ErrFailedToLock
                 }
         }
 
         // At this point we nominally have the lock (at least for memcacheLockTime).
 
         stopChan := make(chan struct{})
@@ skipping 24 matching lines @@
                                 return
                         }
                 }
 
                 checkAnd(release)
                 atomic.StoreUint32(&held, 0)
         }()
 
         return f(func() bool { return atomic.LoadUint32(&held) == 1 })
 }