func newMetaBridgeClient(
cluster string, config common.Config) (c *metadataClient, err error) {
b := &metadataClient{
cluster: cluster,
finch: make(chan bool),
adminports: make(map[string]common.IndexerId),
loads: make(map[common.IndexDefnId]*loadHeuristics),
}
b.topology = make(map[common.IndexerId]map[common.IndexDefnId]*mclient.IndexMetadata)
b.servicesNotifierRetryTm = config["servicesNotifierRetryTm"].Int()
// initialize meta-data-provide.
uuid, err := common.NewUUID()
if err != nil {
logging.Errorf("Could not generate UUID in common.NewUUID\n")
return nil, err
}
b.mdClient, err = mclient.NewMetadataProvider(uuid.Str())
if err != nil {
return nil, err
}
if err := b.updateIndexerList(false); err != nil {
logging.Errorf("updateIndexerList(): %v\n", err)
b.mdClient.Close()
return nil, err
}
b.Refresh()
go b.watchClusterChanges() // will also update the indexer list
return b, nil
}
func (c *MetadataRepo) GetNextIndexInstId() (common.IndexInstId, error) {
id, err := common.NewUUID()
if err != nil {
return common.IndexInstId(0), err
}
return common.IndexInstId(id.Uint64()), nil
}
func (c *MetadataRepo) GetNextPartitionId() (common.PartitionId, error) {
id, err := common.NewUUID()
if err != nil {
return common.PartitionId(0), err
}
return common.PartitionId(id.Uint64()), nil
}
func setupInitialData(mgr *manager.IndexManager, t *testing.T) {
uuid, err := common.NewUUID()
if err != nil {
t.Fatal(err)
}
mgr.SetLocalValue("IndexerId", uuid.Str())
// Add a new index definition : 100
idxDefn := &common.IndexDefn{
DefnId: common.IndexDefnId(100),
Name: "metadata_provider_test_100",
Using: common.ForestDB,
Bucket: "Default",
IsPrimary: false,
SecExprs: []string{"Testing"},
ExprType: common.N1QL,
PartitionScheme: common.HASH,
PartitionKey: "Testing"}
if err := mgr.HandleCreateIndexDDL(idxDefn); err != nil {
t.Fatal(err)
}
// Add a new index definition : 101
idxDefn = &common.IndexDefn{
DefnId: common.IndexDefnId(101),
Name: "metadata_provider_test_101",
Using: common.ForestDB,
Bucket: "Default",
IsPrimary: false,
SecExprs: []string{"Testing"},
ExprType: common.N1QL,
PartitionScheme: common.HASH,
PartitionKey: "Testing"}
if err := mgr.HandleCreateIndexDDL(idxDefn); err != nil {
t.Fatal(err)
}
}
func newRemoteRepoRef(requestAddr string,
leaderAddr string,
config string,
mgr *IndexManager) (*RemoteRepoRef, error) {
// Initialize local repository
repository, err := repo.OpenRepository()
if err != nil {
return nil, err
}
// This is a blocking call unit the watcher is ready. This means
// the watcher has succesfully synchronized with the remote metadata
// repository.
var watcherId string
env, err := newEnv(config)
if err == nil {
watcherId = env.getHostElectionPort()
} else {
uuid, err := common.NewUUID()
if err != nil {
return nil, err
}
watcherId = strconv.FormatUint(uuid.Uint64(), 10)
}
watcher, err := startWatcher(mgr, repository, leaderAddr, watcherId)
if err != nil {
return nil, err
}
repoRef := &RemoteRepoRef{remoteReqAddr: requestAddr,
repository: repository,
watcher: watcher}
return repoRef, nil
}
func (w *watcher) makeRequest(opCode common.OpCode, key string, content []byte) ([]byte, error) {
uuid, err := c.NewUUID()
if err != nil {
return nil, err
}
id := uuid.Uint64()
request := w.factory.CreateRequest(id, uint32(opCode), key, content)
handle := &protocol.RequestHandle{Request: request, Err: nil, StartTime: 0, Content: nil}
handle.StartTime = time.Now().UnixNano()
handle.CondVar = sync.NewCond(&handle.Mutex)
handle.CondVar.L.Lock()
defer handle.CondVar.L.Unlock()
if w.queueRequest(handle) {
handle.CondVar.Wait()
}
return handle.Content, handle.Err
}
//
// Handle a new request. This function will block until the request is being processed
// (by returning true) or until the request is being interrupted (by returning false).
// If request is interrupted, then the request may still be processed by some other
// nodes. So the outcome of the request is unknown when this function returns false.
//
func (s *Coordinator) NewRequest(opCode uint32, key string, content []byte) bool {
uuid, err := co.NewUUID()
if err != nil {
return false
}
id := uuid.Uint64()
s.waitForReady()
req := s.factory.CreateRequest(id, opCode, key, content)
handle := &protocol.RequestHandle{Request: req, Err: nil}
handle.CondVar = sync.NewCond(&handle.Mutex)
handle.CondVar.L.Lock()
defer handle.CondVar.L.Unlock()
s.state.incomings <- handle
handle.CondVar.Wait()
return handle.Err == nil
}
func makeKey(prodfile string, idx, i int) string {
fname := filepath.Base(prodfile)
uuid, _ := c.NewUUID()
return fmt.Sprintf("%s-%s-%v-%v", fname, uuid.Str(), idx, i+1)
}