datastore: Fix AddIndexes with existing namespaces

impl/memory/datastore_data.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 (
         "bytes"
         "fmt"
+        "strings"
         "sync"
         "sync/atomic"
 
         ds "github.com/luci/gae/service/datastore"
         "github.com/luci/gae/service/datastore/serialize"
         "github.com/luci/luci-go/common/errors"
         "golang.org/x/net/context"
 )
 
 //////////////////////////////// dataStoreData /////////////////////////////////
@@ skipping 52 matching lines @@
         d.Lock()
         defer d.Unlock()
 
         if always {
                 d.snap = nil
         } else {
                 d.snap = d.head.Snapshot()
         }
 }
 
-func (d *dataStoreData) addIndexes(ns string, idxs []*ds.IndexDefinition) {
+func (d *dataStoreData) addIndexes(idxs []*ds.IndexDefinition) {
         d.Lock()
         defer d.Unlock()
-        addIndexes(d.head, d.aid, ns, idxs)
+        addIndexes(d.head, d.aid, idxs)
 }
 
 func (d *dataStoreData) setAutoIndex(enable bool) {
         d.Lock()
         defer d.Unlock()
         d.autoIndex = enable
 }
 
 func (d *dataStoreData) maybeAutoIndex(err error) bool {
         mi, ok := err.(*ErrMissingIndex)
         if !ok {
                 return false
         }
 
         d.rwlock.RLock()
         ai := d.autoIndex
         d.rwlock.RUnlock()
 
         if !ai {
                 return false
         }
 
-        d.addIndexes(mi.ns, []*ds.IndexDefinition{mi.Missing})
+        d.addIndexes([]*ds.IndexDefinition{mi.Missing})
         return true
 }
 
 func (d *dataStoreData) setDisableSpecialEntities(enabled bool) {
         d.Lock()
         defer d.Unlock()
         d.disableSpecialEntities = true
 }
 
 func (d *dataStoreData) getDisableSpecialEntities() bool {
@@ skipping 39 matching lines @@
 func (d *dataStoreData) catchupIndexes() {
         d.rwlock.Lock()
         defer d.rwlock.Unlock()
         if d.snap == nil {
                 // we're 'always consistent'
                 return
         }
         d.snap = d.head.Snapshot()
 }
 
+func (d *dataStoreData) namespaces() []string {
+        d.rwlock.Lock()
+        defer d.rwlock.Unlock()
+
+        return namespaces(d.head)
+}
+
 /////////////////////////// indexes(dataStoreData) ////////////////////////////
 
 func groupMetaKey(key *ds.Key) []byte {
         return keyBytes(ds.NewKey("", "", "__entity_group__", "", 1, key.Root()))
 }
 
 func groupIDsKey(key *ds.Key) []byte {
         return keyBytes(ds.NewKey("", "", "__entity_group_ids__", "", 1, key.Root()))
 }
 
@@ skipping 385 matching lines @@
 }
 
 func keyBytes(key *ds.Key) []byte {
         return serialize.ToBytes(ds.MkProperty(key))
 }
 
 func rpm(data []byte) (ds.PropertyMap, error) {
         return serialize.ReadPropertyMap(bytes.NewBuffer(data),
                 serialize.WithContext, "", "")
 }
+
+func namespaces(store *memStore) []string {
+        var namespaces []string
+        for _, c := range store.GetCollectionNames() {
+                ns, has := trimPrefix(c, "ents:")
+                if !has {
+                        if len(namespaces) > 0 {
+                                break
+                        }
+                        continue
+                }
+                namespaces = append(namespaces, ns)
+        }
+        return namespaces
+}
+
+func trimPrefix(v, p string) (string, bool) {
+        if strings.HasPrefix(v, p) {
+                return v[len(p):], true
+        }
+        return v, false
+}