// return adminports for all known indexers.
func getIndexerAdminports(cinfo *common.ClusterInfoCache) ([]string, error) {
iAdminports := make([]string, 0)
for _, node := range cinfo.GetNodesByServiceType("indexAdmin") {
status, err := cinfo.GetNodeStatus(node)
if err != nil {
return nil, err
}
logging.Verbosef("node %v status: %q", node, status)
if status == "healthy" || status == "active" || status == "warmup" {
adminport, err := cinfo.GetServiceAddress(node, "indexAdmin")
if err != nil {
return nil, err
}
iAdminports = append(iAdminports, adminport)
} else {
logging.Warnf("node %v status: %q", node, status)
}
}
return iAdminports, nil
}
func (m *requestHandlerContext) getIndexMetadata(cinfo *common.ClusterInfoCache,
indexerHostMap map[common.IndexerId]string) (*ClusterIndexMetadata, error) {
if err := cinfo.Fetch(); err != nil {
return nil, err
}
// find all nodes that has a index http service
nids := cinfo.GetNodesByServiceType(common.INDEX_HTTP_SERVICE)
clusterMeta := &ClusterIndexMetadata{Metadata: make([]LocalIndexMetadata, len(nids))}
for i, nid := range nids {
addr, err := cinfo.GetServiceAddress(nid, common.INDEX_HTTP_SERVICE)
if err == nil {
resp, err := getWithAuth(addr + "/getLocalIndexMetadata")
if err != nil {
return nil, errors.New(fmt.Sprintf("Fail to retrieve index definition from url %s", addr))
}
localMeta := new(LocalIndexMetadata)
status := convertResponse(resp, localMeta)
if status == RESP_ERROR {
return nil, errors.New(fmt.Sprintf("Fail to retrieve local metadata from url %s.", addr))
}
indexerHostMap[common.IndexerId(localMeta.IndexerId)] = addr
clusterMeta.Metadata[i] = *localMeta
} else {
return nil, errors.New(fmt.Sprintf("Fail to retrieve http endpoint for index node"))
}
}
return clusterMeta, nil
}
func addPartnInfoToProtoInst(cfg c.Config, cinfo *c.ClusterInfoCache,
indexInst c.IndexInst, streamId c.StreamId, protoInst *protobuf.IndexInst) {
switch partn := indexInst.Pc.(type) {
case *c.KeyPartitionContainer:
//Right now the fill the SinglePartition as that is the only
//partition structure supported
partnDefn := partn.GetAllPartitions()
//TODO move this to indexer init. These addresses cannot change.
//Better to get these once and store.
cinfo.Lock()
defer cinfo.Unlock()
err := cinfo.Fetch()
c.CrashOnError(err)
nid := cinfo.GetCurrentNode()
streamMaintAddr, err := cinfo.GetServiceAddress(nid, "indexStreamMaint")
c.CrashOnError(err)
streamInitAddr, err := cinfo.GetServiceAddress(nid, "indexStreamInit")
c.CrashOnError(err)
streamCatchupAddr, err := cinfo.GetServiceAddress(nid, "indexStreamCatchup")
c.CrashOnError(err)
var endpoints []string
for _, p := range partnDefn {
for _, e := range p.Endpoints() {
//Set the right endpoint based on streamId
switch streamId {
case c.MAINT_STREAM:
e = c.Endpoint(streamMaintAddr)
case c.CATCHUP_STREAM:
e = c.Endpoint(streamCatchupAddr)
case c.INIT_STREAM:
e = c.Endpoint(streamInitAddr)
}
endpoints = append(endpoints, string(e))
}
}
protoInst.SinglePartn = &protobuf.SinglePartition{
Endpoints: endpoints,
}
}
}
func (m *requestHandlerContext) getIndexStatus(cinfo *common.ClusterInfoCache, bucket string) ([]IndexStatus, []string, error) {
if err := cinfo.Fetch(); err != nil {
return nil, nil, err
}
// find all nodes that has a index http service
nids := cinfo.GetNodesByServiceType(common.INDEX_HTTP_SERVICE)
list := make([]IndexStatus, 0)
failedNodes := make([]string, 0)
for _, nid := range nids {
addr, err := cinfo.GetServiceAddress(nid, common.INDEX_HTTP_SERVICE)
if err == nil {
resp, err := getWithAuth(addr + "/getLocalIndexMetadata")
if err != nil {
failedNodes = append(failedNodes, addr)
continue
}
localMeta := new(LocalIndexMetadata)
status := convertResponse(resp, localMeta)
if status == RESP_ERROR {
failedNodes = append(failedNodes, addr)
continue
}
curl, err := cinfo.GetServiceAddress(nid, "mgmt")
if err != nil {
failedNodes = append(failedNodes, addr)
continue
}
resp, err = getWithAuth(addr + "/stats?async=true")
if err != nil {
failedNodes = append(failedNodes, addr)
continue
}
stats := new(common.Statistics)
status = convertResponse(resp, stats)
if status == RESP_ERROR {
failedNodes = append(failedNodes, addr)
continue
}
for _, defn := range localMeta.IndexDefinitions {
if len(bucket) != 0 && bucket != defn.Bucket {
continue
}
if topology := m.findTopologyByBucket(localMeta.IndexTopologies, defn.Bucket); topology != nil {
state, errStr := topology.GetStatusByDefn(defn.DefnId)
if state != common.INDEX_STATE_DELETED && state != common.INDEX_STATE_NIL {
stateStr := "Not Available"
switch state {
case common.INDEX_STATE_CREATED:
stateStr = "Created"
case common.INDEX_STATE_READY:
stateStr = "Created"
case common.INDEX_STATE_INITIAL:
stateStr = "Building"
case common.INDEX_STATE_CATCHUP:
stateStr = "Building"
case common.INDEX_STATE_ACTIVE:
stateStr = "Ready"
}
if len(errStr) != 0 {
stateStr = "Error"
}
completion := int(0)
key := fmt.Sprintf("%v:%v:build_progress", defn.Bucket, defn.Name)
if progress, ok := stats.ToMap()[key]; ok {
completion = int(progress.(float64))
}
status := IndexStatus{
DefnId: defn.DefnId,
Name: defn.Name,
Bucket: defn.Bucket,
IsPrimary: defn.IsPrimary,
SecExprs: defn.SecExprs,
WhereExpr: defn.WhereExpr,
Status: stateStr,
Error: errStr,
Hosts: []string{curl},
Definition: common.IndexStatement(defn),
Completion: completion,
}
list = append(list, status)
}
}
}
} else {
failedNodes = append(failedNodes, addr)
continue
}
}
return list, failedNodes, nil
}