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)
}