A transparent cache for datastore, backed by memcache.

filter/dscache/plan.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 dscache
+
+import (
+        "bytes"
+
+        ds "github.com/luci/gae/service/datastore"
+        mc "github.com/luci/gae/service/memcache"
+        "github.com/luci/luci-go/common/errors"
+        "github.com/luci/luci-go/common/logging"
+)
+
+type facts struct {
+        getKeys   []ds.Key
+        getMeta   ds.MultiMetaGetter
+        lockItems []mc.Item
+        nonce     []byte
+}
+
+type plan struct {
+        keepMeta bool
+
+        idxMap    []int
+        toGet     []ds.Key
+        toGetMeta ds.MultiMetaGetter
+        toSave    []mc.Item
+
+        decoded []ds.PropertyMap
+        lme     errors.LazyMultiError
+}
+
+func (p *plan) add(idx int, get ds.Key, m ds.MetaGetter, save mc.Item) {
+        p.idxMap = append(p.idxMap, idx)
+        p.toGet = append(p.toGet, get)
+
+        p.toSave = append(p.toSave, save)

[Vadim Sh., 2015/08/06 01:23:34]

is it ok that you append 'nil's here?

[iannucci, 2015/08/06 02:37:33]

yeah. nil means "don't save it" I added a bunch of docs here to hopefully clear
things up.

+
+        if p.keepMeta {
+                p.toGetMeta = append(p.toGetMeta, m)
+        }
+}
+
+func (p *plan) empty() bool {
+        return len(p.idxMap) == 0
+}
+
+func makePlan(aid, ns string, log logging.Logger, f *facts) *plan {

[Vadim Sh., 2015/08/06 01:23:34]

nit: makeFetchPlan or something

[iannucci, 2015/08/06 02:37:33]

Done.

+        p := plan{
+                keepMeta: f.getMeta != nil,
+                decoded:  make([]ds.PropertyMap, len(f.lockItems)),
+                lme:      errors.LazyMultiError{Size: len(f.lockItems)},
+        }
+        for i, lockItm := range f.lockItems {
+                m := f.getMeta.GetSingle(i)
+                getKey := f.getKeys[i]
+
+                if lockItm == nil { // this item wasn't cacheable

[Vadim Sh., 2015/08/06 01:23:34]

typo: "wasn't cached" (unless I misunderstand something)

[iannucci, 2015/08/06 02:37:33]

fixed comment, it meant something different.

+                        p.add(i, getKey, m, nil)
+                        continue
+                }
+
+                flg := FlagValue(lockItm.Flags())
+                if flg == ItemHasLock {

[dnj, 2015/08/05 18:32:18]

Consider "switch" on "flag", clearer what values/actions you expect.

[iannucci, 2015/08/06 01:54:01]

Done.

+                        if !bytes.Equal(f.nonce, lockItm.Value()) {

[dnj, 2015/08/05 18:32:18]

Invert this to make it more readable: if bytes.Equal(...) { p.add(...) }

[iannucci, 2015/08/06 01:54:01]

Done.

+                                lockItm = nil // someone else has the lock, don't save
+                        }
+                        p.add(i, getKey, m, lockItm)
+                        continue
+                }
+
+                // have some other sort of object, or our AddMulti failed to add this item.
+                if flg != ItemHasData {
+                        p.add(i, getKey, m, nil)
+                        continue
+                }
+
+                pmap, err := decodeItemValue(lockItm.Value(), aid, ns)
+                switch err {
+                case nil:
+                        p.decoded[i] = pmap
+                case ds.ErrNoSuchEntity:
+                        p.lme.Assign(i, ds.ErrNoSuchEntity)
+                default:
+                        log.Errorf("dscache: error decoding %s, %s: %s", lockItm.Key(), getKey, err)
+                        p.add(i, getKey, m, nil)
+                }
+        }
+        return &p
+}