func (ss *storageServer) RegisterServer(args *storagerpc.RegisterArgs, reply *storagerpc.RegisterReply) error {
//will fix registering and race conditions after checkpoint
node := args.ServerInfo
nodeID := int(node.NodeID)
_, in := ss.registerMap[nodeID]
if !in {
ss.ring = append(ss.ring, node)
ss.registerMapLock.Lock()
ss.registerMap[nodeID] = &node
ss.registerMapLock.Unlock()
}
if len(ss.registerMap)+1 != ss.numNodes {
reply.Status = storagerpc.NotReady
reply.Servers = nil
} else {
reply.Status = storagerpc.OK
reply.Servers = ss.ring
_, in := ss.okdMap[nodeID]
if !in {
ss.okdMap[nodeID] = 0
}
}
if len(ss.okdMap)+1 == ss.numNodes {
ss.nodeCount = ss.numNodes
ss.allConnected <- 1
}
return nil
}
func (ss *storageServer) RegisterServer(args *storagerpc.RegisterArgs, reply *storagerpc.RegisterReply) error {
serverID := args.ServerInfo.NodeID
seen := false
for i := 0; i < ss.count; i++ {
if ss.servers[i].NodeID == serverID {
seen = true
}
}
// Add this server to the list
if seen == false {
ss.countLock.Lock()
ss.servers[ss.count] = args.ServerInfo
ss.count++
ss.countLock.Unlock()
}
// If all servers have connected, send the OK and reply with server list
if ss.count == len(ss.servers) {
reply.Status = storagerpc.OK
reply.Servers = ss.servers
} else {
reply.Status = storagerpc.NotReady
reply.Servers = nil
}
return nil
}
func (ss *storageServer) RegisterServer(args *storagerpc.RegisterArgs, reply *storagerpc.RegisterReply) error {
if !ss.isMaster {
return errors.New("I am not a master!")
}
ss.registerLocker.Lock()
defer ss.registerLocker.Unlock()
/* Check if the node has already registered. */
hasRegistered := false
for _, node := range ss.nodes {
if args.ServerInfo.NodeID == node.NodeID {
hasRegistered = true
}
}
/* Register new node */
if !hasRegistered {
fmt.Printf("Register node %d, NodeID is %d\n", ss.registerCnt, args.ServerInfo.NodeID)
ss.nodes[ss.registerCnt] = args.ServerInfo
ss.registerCnt += 1
}
/* If all nodes has registered, return OK */
if ss.registerCnt == ss.numNodes {
sort.Sort(SortNodeByNodeID(ss.nodes))
reply.Status = storagerpc.OK
reply.Servers = ss.nodes
} else {
reply.Status = storagerpc.NotReady
}
return nil
}
// RegisterServer adds a storage server to the ring. It replies with
// status NotReady if not all nodes in the ring have joined. Once
// all nodes have joined, it should reply with status OK and a list
// of all connected nodes in the ring.
func (ss *storageServer) RegisterServer(args *storagerpc.RegisterArgs, reply *storagerpc.RegisterReply) error {
ss.rMutex.Lock()
defer ss.rMutex.Unlock()
// check if this server has already joined
_, ok := ss.ringSet[args.ServerInfo]
if !ok {
fmt.Println("MasterSide: Register a new Slave Storage Server.", args.ServerInfo)
ss.ring = append(ss.ring, args.ServerInfo)
ss.ringSet[args.ServerInfo] = 1
} else {
// fmt.Println("MasterSide: Ignore one slave storage server.", args.ServerInfo);
}
if len(ss.ring) == ss.totalNode {
// if the connection is finished
reply.Servers = ss.ring
reply.Status = storagerpc.OK
//ss.iCond.Signal()
if !ok {
ss.masterReady <- 1
}
fmt.Println("****Register Function: all node registered.")
} else {
reply.Status = storagerpc.NotReady
// fmt.Println("Registration not ready:", len(ss.ring), ss.totalNode)
}
return nil
}
func (ss *storageServer) RegisterServer(args *storagerpc.RegisterArgs, reply *storagerpc.RegisterReply) error {
ss.serverMutex.Lock()
defer ss.serverMutex.Unlock()
if ss.isMaster == true {
serverInfo := args.ServerInfo
exist := ss.serverExist(serverInfo)
if exist == false {
ss.serverList.PushBack(serverInfo)
}
if ss.serverList.Len() < ss.numNodes {
reply.Status = storagerpc.NotReady
reply.Servers = nil
} else if ss.serverList.Len() == ss.numNodes {
reply.Status = storagerpc.OK
reply.Servers = list2SliceNode(ss.serverList)
sort.Sort(serverList(reply.Servers))
ss.serverList.Init()
// ss.serverList = *list.New()
for i := 0; i < len(reply.Servers); i++ {
ss.serverList.PushBack(reply.Servers[i])
}
reply.Servers = list2SliceNode(ss.serverList)
if exist == false {
ss.isReady = true
ss.storageServerReady <- 1
}
} else {
return errors.New("Error registered server number overflow")
}
} else {
fmt.Println("Fatal Error")
return errors.New("Error register with slave server")
}
return nil
}
func (ss *storageServer) RegisterServer(args *storagerpc.RegisterArgs, reply *storagerpc.RegisterReply) error {
if !ss.isMaster {
return errors.New("server is not a master")
}
ss.infoRWL.Lock()
defer ss.infoRWL.Unlock()
if ss.isReady {
reply.Status = storagerpc.OK
} else {
reply.Status = storagerpc.NotReady
// add to cluster
if _, exisit := ss.servers[args.ServerInfo.NodeID]; !exisit {
ss.servers[args.ServerInfo.NodeID] = &args.ServerInfo
}
if len(ss.servers) == ss.numNodes {
ss.isReady = true
reply.Status = storagerpc.OK
close(ss.readyChan)
}
}
for k := range ss.servers {
reply.Servers = append(reply.Servers, *ss.servers[k])
}
return nil
}
func (ss *storageServer) RegisterServer(args *storagerpc.RegisterArgs, reply *storagerpc.RegisterReply) error {
ss.dataLock.Lock()
defer ss.dataLock.Unlock()
node := args.ServerInfo
_, ok := ss.seenNodes[node.NodeID]
if !ok {
ss.seenNodes[node.NodeID] = true
ss.servers[ss.nextNode] = node
ss.nextNode++
}
if ss.nextNode == ss.numNodes {
reply.Status = storagerpc.OK
reply.Servers = ss.servers
if !ss.allServersReadyBool {
ss.allServersReady <- 1
}
} else {
reply.Status = storagerpc.NotReady
reply.Servers = nil
}
return nil
}
func (ss *storageServer) RegisterServer(args *storagerpc.RegisterArgs, reply *storagerpc.RegisterReply) error {
serverInfo := args.ServerInfo
_, ok := ss.nodeIdMap[serverInfo.NodeID]
if !ok {
ss.nodeIdMap[serverInfo.NodeID] = args.ServerInfo
ss.nodesList = append(ss.nodesList, args.ServerInfo)
}
if len(ss.nodeIdMap) < ss.nodeSize {
reply.Status = storagerpc.NotReady
} else {
reply.Status = storagerpc.OK
reply.Servers = ss.nodesList
ss.cMutex.Lock()
ss.informedCount += 1
ss.cMutex.Unlock()
if ss.informedCount == ss.nodeSize-1 {
ss.serverFull <- 1
}
}
return nil
}
func (ss *storageServer) RegisterServer(args *storagerpc.RegisterArgs, reply *storagerpc.RegisterReply) error {
//Add to node map if it's a new slave
_, exist := ss.nodeMap[args.ServerInfo.NodeID]
if !exist {
ss.nodeMap[args.ServerInfo.NodeID] = args.ServerInfo
}
//RPC reply
if len(ss.nodeMap) < ss.numNodes {
reply.Status = storagerpc.NotReady
} else {
i := 0
for _, node := range ss.nodeMap {
ss.nodeList[i] = node
i = i + 1
}
reply.Status = storagerpc.OK
reply.Servers = ss.nodeList
}
return nil
}
