Ejemplo n.º 1
0
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
}
Ejemplo n.º 2
0
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
}
Ejemplo n.º 3
0
// 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
}
Ejemplo n.º 4
0
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
}
Ejemplo n.º 5
0
// 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
}
Ejemplo n.º 6
0
// 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
}