Better attempt at an appengine wrapper.

go/src/infra/gae/libs/wrapper/datastore.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 wrapper
+
+import (
+        "fmt"
+
+        "golang.org/x/net/context"
+
+        "appengine/datastore"
+
+        "github.com/mjibson/goon"
+)
+
+/// Kinds + Keys
+
+// DSKinder simply allows you to resolve the datastore 'kind' of an object.
+// See goon.Goon.Kind().
+type DSKinder interface {
+        Kind(src interface{}) string
+}
+
+// DSKindSetter allows you to manipulate the current Kind resolution function.
+// See goon.Goon.KindNameResolver.
+type DSKindSetter interface {
+        KindNameResolver() goon.KindNameResolver
+        SetKindNameResolver(goon.KindNameResolver)
+}
+
+// DSNewKeyer allows you to generate a new *datastore.Key in a couple ways.

[Vadim Sh., 2015/05/24 19:01:56]

how about aliasing datastore.Key with something to completely detach wrapper
interface from GAE datastore package? e.g.

type *datastore.Key DSKey

though you also use datastore.TransationOptions below... I haven't read the
whole CL yet, perhaps it is a stupid suggestion.

[iannucci, 2015/05/24 20:04:31]

Ah, yes. So I want to do that :) But it's still broken, because of the way that
the appengine SDK serializes *Key fields in structs (for datastore). Basically,
the field entity MUST be a *"appengine/datastore".Key. Not an interface, not an
alias. This means that the user of wrapper needs to import "appengine/datastore"
anyway so they can put *Key objects in their fields. If we change underlying
implementations, suddenly they'll get errors at runtime.

Key is recursive (parent field), so you actually have to redefine Parent() as
well.

Additionally, since *Key is all full of private fields, there's no way to
convert between *"gae/wrapper".Key and a *"appengine/datastore".Key. The only
way to mint a new key is with a Context object. In "appengine/datastore",
Context.Call is mockable so I can at least have it lie about the 2 RPC calls
that minting a key generates. In the new SDK it's completely opaque.

Basically it just sucks :(

Key should have been defined as:

type Key interface {
  ...
  Parent() Key
  ...
}

And the datastore property loader function would basically see if the field's
interface == Key, and if so, inflate it's own concrete *key type to fulfill the 
interface. Similarly, the saver would need to extract the concrete type by doing
a type assertion, and failing that, reconstructing it's own *key type by walking
the key (e.g. copying data via the Key interface).

+// See goon.Goon.Key* for the NewKeyObj* methods, as well as datastore.NewKey.
+type DSNewKeyer interface {
+        NewKey(kind, stringID string, intID int64, parent *datastore.Key) *datastore.Key
+        NewKeyObj(src interface{}) *datastore.Key
+        NewKeyObjError(src interface{}) (*datastore.Key, error)
+}
+
+/// Read + Write
+
+// DSSingleReadWriter allows you to read and write a single datastore object.
+// See goon.Goon for more detail on the same-named functions.
+type DSSingleReadWriter interface {
+        Put(src interface{}) (*datastore.Key, error)
+        Get(dst interface{}) error
+        Delete(key *datastore.Key) error
+}
+
+// DSMultiReadWriter allows you to read and write a multiple datastore objects
+// in a non-atomic batch. See goon.Goon for more detail on the same-named.
+// functions. Also implies DSSingleReadWriter.
+type DSMultiReadWriter interface {
+        DSSingleReadWriter
+        DeleteMulti(keys []*datastore.Key) error
+        GetMulti(dst interface{}) error
+        PutMulti(src interface{}) ([]*datastore.Key, error)
+}
+
+/// Queries
+
+// DSCursor wraps datastore.Cursor.

[Vadim Sh., 2015/05/24 19:01:56]

I don't see it wrapping it...

[iannucci, 2015/05/24 20:04:31]

wraps meaning that it serves the function of (and in the case of the gae
implementation it has datastore.Cursor as a concrete type). Since nothing uses
reflect to load Cursors, and Cursor isn't recursively defined, we can just use
it's interface (which is just String() string)

+type DSCursor interface {
+        fmt.Stringer
+}
+
+// DSIterator wraps datastore.Iterator.

[Vadim Sh., 2015/05/24 19:01:56]

how about moving all these interfaces to package wrapper/datastore/datastore.go
and getting rid of DS prefix? It then would be datastore.Iterator etc. Unless
you import then and real datastore both at the same time.

[iannucci, 2015/05/24 20:04:31]

Datastore, TaskQueue and Memcache are all intertwined. I agree that such a split
should probably be done, but it would significantly complicate the
implementation (I'm pretty sure). The other thing that is tricky is that if it
were split, there would be a temptation to mix and match implementations.
Because of the way that they intertangle in terms of implementation
(transactions being the really tricky one), we'd have to expose transaction
support for the TaskQueue at the interface level (e.g. have an AddAction item on
the Datastore interface which can add callbacks to be called back on successful
transaction commit), but that would only work for the in-memory testing version,
not for the real gae implementation (THOUGH MAYBE IT COULD, since taskqueue is
really just calling the AddAction RPC in the background... though it's very
specific to taskqueues, and isn't a general callback).

bleh.

+type DSIterator interface {
+        Cursor() (DSCursor, error)
+        Next(dst interface{}) (*datastore.Key, error)
+}
+
+// DSQuery wraps datastore.Query.
+type DSQuery interface {
+        Ancestor(ancestor *datastore.Key) DSQuery
+        Distinct() DSQuery
+        End(c DSCursor) DSQuery
+        EventualConsistency() DSQuery
+        Filter(filterStr string, value interface{}) DSQuery
+        KeysOnly() DSQuery
+        Limit(limit int) DSQuery
+        Offset(offset int) DSQuery
+        Order(fieldName string) DSQuery
+        Project(fieldNames ...string) DSQuery
+        Start(c DSCursor) DSQuery
+}
+
+// DSQueryer implements all query-related functionality of goon.Goon/datastore.
+type DSQueryer interface {
+        NewQuery(kind string) DSQuery
+        Run(q DSQuery) DSIterator
+        GetAll(q DSQuery, dst interface{}) ([]*datastore.Key, error)
+        Count(q DSQuery) (int, error)
+}
+
+/// Transactions
+
+// DSTransactioner implements the function for entering a transaction with
+// datastore. The function recieves a context without the ability to enter a
+// transaction again (since recursive transactions are not implemented in
+// datastore).
+type DSTransactioner interface {
+        RunInTransaction(f func(c context.Context) error, opts *datastore.TransactionOptions) error
+}
+
+// Datastore implements the full datastore functionality.
+type Datastore interface {
+        DSKinder
+        DSNewKeyer
+        DSMultiReadWriter
+        DSQueryer
+        DSKindSetter
+        DSTransactioner
+}
+
+// DSFactory is the function signature for factory methods compatible with
+// SetDSFactory.
+type DSFactory func(context.Context) Datastore
+
+// GetDS gets the Datastore implementation from context.
+func GetDS(c context.Context) Datastore {
+        obj := c.Value(datastoreKey)
+        if obj == nil || obj.(DSFactory) == nil {
+                return nil
+        }
+        return obj.(DSFactory)(c)
+}
+
+// SetDSFactory sets the function to produce Datastore instances, as returned by
+// the GetDS method.
+func SetDSFactory(c context.Context, dsf DSFactory) context.Context {
+        return context.WithValue(c, datastoreKey, dsf)
+}
+
+// SetDS sets the current Datastore object in the context. Useful for testing
+// with a quick mock. This is just a shorthand SetDSFactory invocation to set
+// a factory which always returns the same object.
+func SetDS(c context.Context, ds Datastore) context.Context {
+        return SetDSFactory(c, func(context.Context) Datastore { return ds })
+}