Add 'user friendly' datastore API.

impl/prod/raw_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 prod
 
 import (
         ds "github.com/luci/gae/service/datastore"
+        "github.com/luci/gae/service/info"
         "golang.org/x/net/context"
         "google.golang.org/appengine"
         "google.golang.org/appengine/datastore"
 )
 
 // useRDS adds a gae.RawDatastore implementation to context, accessible
 // by gae.GetDS(c)
 func useRDS(c context.Context) context.Context {
-        return ds.SetFactory(c, func(ci context.Context) ds.Interface {
-                // TODO(riannucci): Track namespace in a better way
-                k := datastore.NewKey(ci, "kind", "", 1, nil) // get current namespace.
-                return rdsImpl{ci, k.Namespace()}
+        return ds.SetRawFactory(c, func(ci context.Context) ds.RawInterface {
+                return rdsImpl{ci, info.Get(ci).GetNamespace()}
         })
 }
 
 ////////// Query
 
 type queryImpl struct{ *datastore.Query }
 
 func (q queryImpl) Distinct() ds.Query {
         return queryImpl{q.Query.Distinct()}
 }
@@ skipping 74 matching lines @@
         vals := make([]datastore.PropertyLoadSaver, len(keys))
         for i := range keys {
                 vals[i] = &typeFilter{ds.PropertyMap{}}
         }
         err := datastore.GetMulti(d, rkeys, vals)
         return idxCallbacker(err, len(keys), func(idx int, err error) {
                 cb(vals[idx].(*typeFilter).pm, err)
         })
 }
 
-func (d rdsImpl) PutMulti(keys []ds.Key, vals []ds.PropertyLoadSaver, cb ds.PutMultiCB) error {
+func (d rdsImpl) PutMulti(keys []ds.Key, vals []ds.PropertyMap, cb ds.PutMultiCB) error {
         rkeys := dsMF2R(keys)
         rvals := make([]datastore.PropertyLoadSaver, len(vals))
         for i, val := range vals {
-                rvals[i] = &typeFilter{val.(ds.PropertyMap)}
+                rvals[i] = &typeFilter{val}
         }
         rkeys, err := datastore.PutMulti(d, rkeys, vals)
         return idxCallbacker(err, len(keys), func(idx int, err error) {
                 k := ds.Key(nil)
                 if err == nil {
                         k = dsR2F(rkeys[idx])
                 }
                 cb(k, err)
         })
 }
 
 func (d rdsImpl) NewQuery(kind string) ds.Query {
         return queryImpl{datastore.NewQuery(kind)}
 }
 
-func (d rdsImpl) Run(q ds.Query, cb ds.RunCB) error {
+func (d rdsImpl) Run(q ds.Query, cb ds.RawRunCB) error {
         tf := typeFilter{}
         t := q.(queryImpl).Query.Run(d)
         cfunc := func() (ds.Cursor, error) {
                 return t.Cursor()
         }
         for {
                 k, err := t.Next(&tf)
                 if err == datastore.Done {
                         return nil
                 }
                 if err != nil {
                         return err
                 }
                 if !cb(dsR2F(k), tf.pm, cfunc) {
                         return nil
                 }
         }
 }
 
 func (d rdsImpl) RunInTransaction(f func(c context.Context) error, opts *ds.TransactionOptions) error {
         ropts := (*datastore.TransactionOptions)(opts)
         return datastore.RunInTransaction(d, f, ropts)
 }