func (ss *Storageserver) GetServers(args *storageproto.GetServersArgs, reply *storageproto.RegisterReply) error { //this is what libstore calls on the master to get a list of all the servers //if the lenght of the nodeList is the number of nodes then we return ready and the list of nodes //otherwise we return false for ready and the list of nodes we have so far //fmt.Println("called get servers") <-ss.nodeListM //fmt.Println("aquried nodelist lock GetServers") //check to see if all nodes have registered if len(ss.nodeList) == ss.numNodes { //if so we are ready //fmt.Println("we are ready") reply.Ready = true } else { //if not we aren't ready //fmt.Println("we aren't ready") reply.Ready = false } //send back the list of servers anyway reply.Servers = ss.nodeList ss.nodeListM <- 1 //fmt.Println("released nodelist lock GetServers") //fmt.Println(reply.Servers) //fmt.Printf("ready? %v\n", reply.Ready) return nil }
func (ss *Storageserver) GetServers(args *storageproto.GetServersArgs, reply *storageproto.RegisterReply) error { fmt.Println("Storage GetServers invoked") if !ss.isMaster { fmt.Println("WARNING:Calling a non-master node for GetServers") return lsplog.MakeErr("Calling a non-master node to GetServers") } if len(ss.nodes) != ss.numnodes { fmt.Println("GetServer not ready") //what a hack here, need change if time possible time.Sleep(time.Duration(2*1000) * time.Millisecond) reply.Ready = false return nil } servers := make([]storageproto.Node, ss.numnodes) i := 0 for node, _ := range ss.nodes { //fmt.Printf("i: %d, info: %v\n", i, node) servers[i] = node i++ } reply.Servers = servers reply.Ready = true return nil }
// Non-master servers to the master func (ss *Storageserver) RegisterServer(args *storageproto.RegisterArgs, reply *storageproto.RegisterReply) error { //called on master by other servers //first check if that server is alreayd in our map //fmt.Println("called register server") <-ss.nodeMapM //fmt.Println("aquired nodeMap lock RegisterServer") _, ok := ss.nodeMap[args.ServerInfo] //if not we have to add it to the map and to the list if ok != true { //put it in the list <-ss.nodeListM //fmt.Println("aquired nodeList lock RegisterServer") ss.nodeList = append(ss.nodeList, args.ServerInfo) ss.nodeListM <- 1 //fmt.Println("release nodeList lock RegisterServer") //put it in the map w/ it's index in the list just cause whatever bro //map is just easy way to check for duplicates anyway ss.nodeMap[args.ServerInfo] = len(ss.nodeList) } //check to see if all nodes have registered <-ss.nodeListM //fmt.Println("aquired nodeList lock RegisterServer") if len(ss.nodeList) == ss.numNodes { //if so we are ready reply.Ready = true log.Println("Successfully joined storage node cluster.") slist := "" for i := 0; i < len(ss.nodeList); i++ { res := fmt.Sprintf("{localhost:%v %v}", ss.portnum, ss.nodeid) slist += res if i < len(ss.nodeList)-1 { slist += " " } } log.Printf("Server List: [%s]", slist) } else { //if not we aren't ready reply.Ready = false } //send back the list of servers anyway reply.Servers = ss.nodeList //unlock everything ss.nodeListM <- 1 //fmt.Println("released nodeList lock RegisterServer") ss.nodeMapM <- 1 //fmt.Println("released nodeMap lock RegisterServer") //NOTE: having these two mutexes may cause weird problems, might want to look into just having one mutex that is used for both the //node list and the node map since they are baiscally the same thing anyway. //fmt.Println(reply.Servers) //fmt.Printf("ready? %v\n", reply.Ready) return nil }
func (ss *Storageserver) GetServers(args *storageproto.GetServersArgs, reply *storageproto.RegisterReply) error { ss.registeredLocker.Lock() defer ss.registeredLocker.Unlock() reply.Servers = make([]storageproto.Node, len(ss.nodes)) if ss.registered == len(ss.nodes) { reply.Ready = true for i := range ss.nodes { reply.Servers[i] = *ss.nodes[i] } } else { reply.Ready = false } return nil }
// Non-master servers to the master func (ss *Storageserver) RegisterServer(args *storageproto.RegisterArgs, reply *storageproto.RegisterReply) error { fmt.Printf("st registerServer invoked\n") if !ss.isMaster { lsplog.Vlogf(0, "WARNING:Calling a non-master node to register") return lsplog.MakeErr("Calling a non-master node to register") } _, present := ss.nodes[args.ServerInfo] if !present { //add to nodes ss.nodes[args.ServerInfo] = true fmt.Println("add nodes %v", args.ServerInfo) } fmt.Printf("master collect slave info %d/%d\n", len(ss.nodes), ss.numnodes) reply.Servers = nil if len(ss.nodes) == ss.numnodes { reply.Ready = true //ss.GetServers(nil, reply) servers := make([]storageproto.Node, ss.numnodes) i := 0 for node, _ := range ss.nodes { //fmt.Printf("i: %d, info: %v\n", i, node) servers[i] = node i++ } reply.Servers = servers } else { reply.Ready = false } return nil }
// Non-master servers to the master func (ss *Storageserver) RegisterServer(args *storageproto.RegisterArgs, reply *storageproto.RegisterReply) error { lsplog.Vlogf(1, "[storageimpl] Got a registration call from [%+v]", args.ServerInfo) ss.registeredLocker.Lock() defer ss.registeredLocker.Unlock() reply.Servers = make([]storageproto.Node, ss.numnodes) if ss.registered == len(ss.nodes) { lsplog.Vlogf(1, "[RegisterServer] Request is for getting ready") reply.Ready = true for i := range ss.nodes { reply.Servers[i] = *ss.nodes[i] } return nil } lsplog.Vlogf(1, "[RegisterServer] Request is for registration") for i := range ss.nodes { if ss.nodes[i] != nil && ss.nodes[i].NodeID == args.ServerInfo.NodeID { lsplog.Vlogf(1, "[RegisterServer] Already registered and not ready") reply.Ready = false return nil } } lsplog.Vlogf(1, "[RegisterServer] Registering") ss.nodes[ss.registered] = &args.ServerInfo ss.registered++ if ss.registered == len(ss.nodes) { lsplog.Vlogf(1, "[RegisterServer] Registered and it was the last node") reply.Ready = true for i := range ss.nodes { reply.Servers[i] = *ss.nodes[i] } } else { lsplog.Vlogf(1, "[RegisterServer] Registered and there are more nodes ") reply.Ready = false } return nil }