Use time.Time for internal memcache memory implementation

impl/memory/memcache.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 (
         "encoding/binary"
         "sync"
         "time"
@@ skipping 32 matching lines @@
 func (m *mcItem) SetFlags(flg uint32) mc.Item {
         m.flags = flg
         return m
 }
 func (m *mcItem) SetExpiration(exp time.Duration) mc.Item {
         m.expiration = exp
         return m
 }
 
 func (m *mcItem) SetAll(other mc.Item) {
-        *m = *other.(*mcItem).duplicate(false)
+        *m = *other.(*mcItem)
 }
 
-func (m *mcItem) duplicate(deep bool) *mcItem {
-        ret := mcItem{}
-        ret = *m
-        if deep {
-                ret.value = make([]byte, len(m.value))
-                copy(ret.value, m.value)
-        }
-        return &ret
+type mcDataItem struct {
+        value      []byte
+        flags      uint32
+        expiration time.Time
+        casID      uint64
+}
+
+func (m *mcDataItem) toUserItem(key string) *mcItem {
+        value := make([]byte, len(m.value))
+        copy(value, m.value)
+        return &mcItem{key, value, m.flags, 0, m.casID}

[dnj, 2015/08/04 17:55:42]

Shouldn't you use "m.expiration.UTC().UnixNano() / <whatever>" here instead of
"0"?

[iannucci, 2015/08/04 18:13:54]

Nah, the memcache api defines Expiration has having 0 when getting items back
from the server. added comment.

 }
 
 type memcacheData struct {
         lock  sync.RWMutex
-        items map[string]*mcItem
+        items map[string]*mcDataItem
         casID uint64
 
         stats mc.Statistics
 }
 
-func (m *memcacheData) mkItemLocked(now time.Time, i mc.Item) (ret *mcItem) {
+func (m *memcacheData) mkDataItemLocked(now time.Time, i mc.Item) (ret *mcDataItem) {
         m.casID++
 
-        var exp time.Duration
+        var exp time.Time

[dnj, 2015/08/04 17:55:43]

maruel@ prefers: exp := time.Time{}

This seems to be the notation we've been using.

[iannucci, 2015/08/04 18:13:54]

Weird. I usually do that too.

         if i.Expiration() != 0 {
-                exp = time.Duration(now.Add(i.Expiration()).UnixNano())
+                exp = now.Add(i.Expiration()).Truncate(time.Second)
         }
         value := make([]byte, len(i.Value()))
         copy(value, i.Value())
-        return &mcItem{
-                key:        i.Key(),
+        return &mcDataItem{
                 flags:      i.Flags(),
                 expiration: exp,
                 value:      value,
-                CasID:      m.casID,
+                casID:      m.casID,
         }
 }
 
 func (m *memcacheData) setItemLocked(now time.Time, i mc.Item) {
         if cur, ok := m.items[i.Key()]; ok {
                 m.stats.Items--
                 m.stats.Bytes -= uint64(len(cur.value))
         }
         m.stats.Items++
         m.stats.Bytes += uint64(len(i.Value()))
-        m.items[i.Key()] = m.mkItemLocked(now, i)
+        m.items[i.Key()] = m.mkDataItemLocked(now, i)
 }
 
 func (m *memcacheData) delItemLocked(k string) {
         if itm, ok := m.items[k]; ok {
                 m.stats.Items--
                 m.stats.Bytes -= uint64(len(itm.value))
                 delete(m.items, k)
         }
 }
 
 func (m *memcacheData) reset() {
         m.stats = mc.Statistics{}
-        m.items = map[string]*mcItem{}
+        m.items = map[string]*mcDataItem{}
 }
 
 func (m *memcacheData) hasItemLocked(now time.Time, key string) bool {
         ret, ok := m.items[key]
-        if ok && ret.Expiration() != 0 && ret.Expiration() < time.Duration(now.UnixNano()) {
+        if ok && !ret.expiration.IsZero() && ret.expiration.Before(now) {
                 m.delItemLocked(key)
                 return false
         }
         return ok
 }
 
-func (m *memcacheData) retrieveLocked(now time.Time, key string) (*mcItem, error) {
+func (m *memcacheData) retrieveLocked(now time.Time, key string) (*mcDataItem, error) {
         if !m.hasItemLocked(now, key) {
                 m.stats.Misses++
                 return nil, mc.ErrCacheMiss
         }
 
         ret := m.items[key]
         m.stats.Hits++
         m.stats.ByteHits += uint64(len(ret.value))
         return ret, nil
 }
@@ skipping 13 matching lines @@
         lck := sync.Mutex{}
         mcdMap := map[string]*memcacheData{}
 
         return mc.SetRawFactory(c, func(ic context.Context) mc.RawInterface {
                 lck.Lock()
                 defer lck.Unlock()
 
                 ns := curGID(ic).namespace
                 mcd, ok := mcdMap[ns]
                 if !ok {
-                        mcd = &memcacheData{items: map[string]*mcItem{}}
+                        mcd = &memcacheData{items: map[string]*mcDataItem{}}
                         mcdMap[ns] = mcd
                 }
 
                 return &memcacheImpl{
                         mcd,
                         ic,
                 }
         })
 }
 
@@ skipping 37 matching lines @@
         doCBs(items, cb, func(itm mc.Item) error {
                 m.data.lock.Lock()
                 defer m.data.lock.Unlock()
 
                 if cur, err := m.data.retrieveLocked(now, itm.Key()); err == nil {
                         casid := uint64(0)
                         if mi, ok := itm.(*mcItem); ok && mi != nil {
                                 casid = mi.CasID
                         }
 
-                        if cur.CasID == casid {
+                        if cur.casID == casid {
                                 m.data.setItemLocked(now, itm)
                         } else {
                                 return mc.ErrCASConflict
                         }
                         return nil
                 }
                 return mc.ErrNotStored
         })
         return nil
 }
@@ skipping 16 matching lines @@
         errs := make([]error, len(keys))
 
         for i, k := range keys {
                 itms[i], errs[i] = func() (mc.Item, error) {
                         m.data.lock.RLock()
                         defer m.data.lock.RUnlock()
                         val, err := m.data.retrieveLocked(now, k)
                         if err != nil {
                                 return nil, err
                         }
-                        return val.duplicate(true).SetExpiration(0), nil
+                        return val.toUserItem(k), nil
                 }()
         }
 
         for i, itm := range itms {
                 cb(itm, errs[i])
         }
 
         return nil
 }
 
@@ skipping 66 matching lines @@
         return cur, nil
 }
 
 func (m *memcacheImpl) Stats() (*mc.Statistics, error) {
         m.data.lock.RLock()
         defer m.data.lock.RUnlock()
 
         ret := m.data.stats
         return &ret, nil
 }