func (c *MetadataRepo) loadDefn() error { iter, err := c.repo.newIterator() if err != nil { return err } defer iter.Close() for { key, content, err := iter.Next() if err != nil { return nil } if isIndexDefnKey(key) { id := indexDefnIdFromKey(key) if id != "" { defn, err := common.UnmarshallIndexDefn(content) if err != nil { return err } c.defnCache[defn.DefnId] = defn } } } }
func (r *metadataRepo) unmarshallAndAddDefn(content []byte) error { defn, err := c.UnmarshallIndexDefn(content) if err != nil { return err } r.addDefn(defn) return nil }
func (m *LifecycleMgr) handleCreateIndex(key string, content []byte) error { defn, err := common.UnmarshallIndexDefn(content) if err != nil { logging.Errorf("LifecycleMgr.handleCreateIndex() : createIndex fails. Unable to unmarshall index definition. Reason = %v", err) return err } return m.CreateIndex(defn) }
// // Handle create Index request in the dictionary. If this function // returns true, it means createIndex request completes successfully. // If this function returns false, then the result is unknown. // func (c *Coordinator) createIndex(key string, content []byte) bool { defn, err := co.UnmarshallIndexDefn(content) if err != nil { return false } // For now, use the local host. This logic is not called in sherlock production code. // But still will be called in uint test. if err := c.idxMgr.getLifecycleMgr().CreateIndex(defn); err != nil { logging.Debugf("Coordinator.createIndexy() : createIndex fails. Reason = %s", err.Error()) return false } return true }
func (c *MetadataRepo) GetIndexDefnById(id common.IndexDefnId) (*common.IndexDefn, error) { c.mutex.Lock() defer c.mutex.Unlock() defn, ok := c.defnCache[id] if ok && defn != nil { return defn, nil } lookupName := indexDefnKeyById(id) data, err := c.getMeta(lookupName) if err != nil { return nil, err } defn, err = common.UnmarshallIndexDefn(data) if err != nil { return nil, err } c.defnCache[id] = defn return defn, nil }
func TestEventMgr(t *testing.T) { logging.SetLogLevel(logging.Trace) logging.Infof("Start TestEventMgr *********************************************************") cfg := common.SystemConfig.SectionConfig("indexer", true /*trim*/) cfg.Set("storage_dir", common.ConfigValue{"./data/", "metadata file path", "./"}) os.MkdirAll("./data/", os.ModePerm) /* var requestAddr = "localhost:9885" var leaderAddr = "localhost:9884" var config = "./config.json" */ logging.Infof("Start Index Manager") factory := new(util.TestDefaultClientFactory) env := new(util.TestDefaultClientEnv) admin := manager.NewProjectorAdmin(factory, env, nil) //mgr, err := manager.NewIndexManagerInternal(requestAddr, leaderAddr, config, admin) mgr, err := manager.NewIndexManagerInternal("localhost:9886", "localhost:"+manager.COORD_MAINT_STREAM_PORT, admin, cfg) if err != nil { t.Fatal(err) } defer mgr.Close() cleanupEvtMgrTest(mgr, t) time.Sleep(time.Duration(1000) * time.Millisecond) logging.Infof("Start Listening to event") notifications, err := mgr.StartListenIndexCreate("TestEventMgr") if err != nil { t.Fatal(err) } // Add a new index definition : 300 idxDefn := &common.IndexDefn{ DefnId: common.IndexDefnId(300), Name: "event_mgr_test", Using: common.ForestDB, Bucket: "Default", IsPrimary: false, SecExprs: []string{"Testing"}, ExprType: common.N1QL, PartitionScheme: common.HASH, PartitionKey: "Testing"} logging.Infof("Before DDL") err = mgr.HandleCreateIndexDDL(idxDefn) if err != nil { t.Fatal(err) } data := listen(notifications) if data == nil { t.Fatal("Does not receive notification from watcher") } idxDefn, err = common.UnmarshallIndexDefn(([]byte)(data)) if err != nil { t.Fatal(err) } if idxDefn == nil { t.Fatal("Cannot unmarshall index definition") } if idxDefn.Name != "event_mgr_test" { t.Fatal("Index Definition Name mismatch") } cleanupEvtMgrTest(mgr, t) mgr.CleanupTopology() mgr.CleanupStabilityTimestamp() time.Sleep(time.Duration(1000) * time.Millisecond) logging.Infof("Stop TestEventMgr. Tearing down *********************************************************") mgr.Close() time.Sleep(time.Duration(1000) * time.Millisecond) }