Golang 621_proj-rpcclient.ServerInfo类(方法)实例源码

func (chordNode *ChordNode) checkPredecessor() {

	chordNode.Logger.Println("Chord : In checkPredecessor")

	//RPC call to check predecessor
	jsonMessage := "{\"method\":\"CheckPredecessor\",\"params\":[]}"

	chordNode.Logger.Println("Predecessor:", chordNode.Predecessor)
	chordNode.Logger.Println("Predecessor serverInfo:", chordNode.FtServerMapping[chordNode.Predecessor])
	clientServerInfo := rpcclient.ServerInfo{}
	clientServerInfo.ServerID = chordNode.FtServerMapping[chordNode.Predecessor].ServerID
	clientServerInfo.Protocol = chordNode.FtServerMapping[chordNode.Predecessor].Protocol
	clientServerInfo.IpAddress = chordNode.FtServerMapping[chordNode.Predecessor].IpAddress
	clientServerInfo.Port = chordNode.FtServerMapping[chordNode.Predecessor].Port

	chordNode.Logger.Println("RPC call to:", clientServerInfo)

	client := &rpcclient.RPCClient{}
	err, response := client.RpcCall(clientServerInfo, jsonMessage)

	chordNode.Logger.Println("Response:", response)

	if err != nil {
		chordNode.Logger.Println(err)
		return
	}

	chordNode.Logger.Println("response.Result=", response.(*(rpcclient.ResponseParameters)).Result)
	// Set the predecessor to nil if empty response
	if response.(*(rpcclient.ResponseParameters)).Result == nil {
		chordNode.Logger.Println("SETTING PREDECESSOR TO NIL")
		chordNode.SetPredecessor(true, 0)
	}
}

func getDefaultServerInfo() rpcclient.ServerInfo {
	serverInfo := rpcclient.ServerInfo{}
	serverInfo.ServerID = "mainserver"
	serverInfo.Protocol = "tcp"
	serverInfo.IpAddress = "127.0.0.1"
	serverInfo.Port = 1234

	return serverInfo
}

func (chordNode *ChordNode) updateFtServerMapping(id uint32, serverInfo rpcclient.ServerInfo) {

	if _, ok := chordNode.FtServerMapping[id]; !ok {

		clientServerInfo := rpcclient.ServerInfo{}
		clientServerInfo.ServerID = serverInfo.ServerID
		clientServerInfo.Protocol = serverInfo.Protocol
		clientServerInfo.IpAddress = serverInfo.IpAddress
		clientServerInfo.Port = serverInfo.Port

		chordNode.FtServerMapping[id] = clientServerInfo
	}
}

/*
Use this function to create server info to whom RPCcall is going to be made
Input: Chord Id of the server
*/
func (chordNode *ChordNode) PrepareClientServerInfo(chordID uint32) (rpcclient.ServerInfo, error) {
	clientServerInfo := rpcclient.ServerInfo{}
	if _, ok := chordNode.FtServerMapping[chordID]; ok {
		clientServerInfo.ServerID = chordNode.FtServerMapping[chordID].ServerID
		clientServerInfo.Protocol = chordNode.FtServerMapping[chordID].Protocol
		clientServerInfo.IpAddress = chordNode.FtServerMapping[chordID].IpAddress
		clientServerInfo.Port = chordNode.FtServerMapping[chordID].Port
		return clientServerInfo, nil
	} else {
		customError := errors.New("Entry not found in FTServerMapping")
		chordNode.Logger.Println(customError)
		return rpcclient.ServerInfo{}, customError
	}

}

// initially FingerTableIndex = 0
func (chordNode *ChordNode) fixFingers(FingerTableIndex int) {

	chordNode.Logger.Println("Chord : In fixFingers")

	//find the successor of (p+2^(i-1)) by initiaing the find_successor call from the current node
	nextNodeId := chordNode.Id + uint32(math.Pow(2, float64(FingerTableIndex-1)))
	jsonMessage := "{\"method\":\"findSuccessor\",\"params\":[" + fmt.Sprint(nextNodeId) + "]}"

	clientServerInfo := rpcclient.ServerInfo{}
	clientServerInfo.ServerID = chordNode.MyServerInfo.ServerID
	clientServerInfo.Protocol = chordNode.MyServerInfo.Protocol
	clientServerInfo.IpAddress = chordNode.MyServerInfo.IpAddress
	clientServerInfo.Port = chordNode.MyServerInfo.Port

	client := &rpcclient.RPCClient{}
	err, response := client.RpcCall(clientServerInfo, jsonMessage)

	if err != nil {
		chordNode.Logger.Println(err)
		return
	}

	// process only if response is present
	if response.(*(rpcclient.ResponseParameters)).Result != nil {
		chordNode.FingerTable[FingerTableIndex] = uint32((response.(*(rpcclient.ResponseParameters)).Result[0]).(float64))

		resultServerInfo := rpcclient.ServerInfo{}
		for key, value := range response.(*(rpcclient.ResponseParameters)).Result[1].(map[string]interface{}) {
			switch key {
			case "serverID":
				resultServerInfo.ServerID = value.(string)
				break
			case "protocol":
				resultServerInfo.Protocol = value.(string)
				break
			case "IpAddress":
				resultServerInfo.IpAddress = value.(string)
				break
			case "Port":
				resultServerInfo.Port = int(value.(float64))
			}
		}
		chordNode.FtServerMapping[chordNode.FingerTable[FingerTableIndex]] = resultServerInfo
		chordNode.Successor = chordNode.FingerTable[1]
	}
	chordNode.Logger.Println("FingerTable=", chordNode.FingerTable)
}

func (chordNode *ChordNode) join(serverInfo rpcclient.ServerInfo) {

	chordNode.Logger.Println("Chord : In Join")
	jsonMessage := "{\"method\":\"findSuccessor\",\"params\":[" + fmt.Sprint(chordNode.Id) + "]}"

	clientServerInfo := rpcclient.ServerInfo{}
	clientServerInfo.ServerID = serverInfo.ServerID
	clientServerInfo.Protocol = serverInfo.Protocol
	clientServerInfo.IpAddress = serverInfo.IpAddress
	clientServerInfo.Port = serverInfo.Port

	client := &rpcclient.RPCClient{}
	err, response := client.RpcCall(clientServerInfo, jsonMessage)

	if err != nil {
		chordNode.Logger.Println(err)
		return
	}

	chordNode.Predecessor = 0
	chordNode.Successor = uint32((response.(*(rpcclient.ResponseParameters)).Result[0]).(float64))

	resultServerInfo := rpcclient.ServerInfo{}
	for key, value := range response.(*(rpcclient.ResponseParameters)).Result[1].(map[string]interface{}) {
		switch key {
		case "serverID":
			resultServerInfo.ServerID = value.(string)
			break
		case "protocol":
			resultServerInfo.Protocol = value.(string)
			break
		case "IpAddress":
			resultServerInfo.IpAddress = value.(string)
			break
		case "Port":
			resultServerInfo.Port = int(value.(float64))
		}
	}
	chordNode.FtServerMapping[chordNode.Successor] = resultServerInfo
}

/*
request <-"{"method":"Notify","params":[10,{"ServerID":"9999","Protocol":"tcp","IpAddress":"127.0.0.1","Port":1235}]}"
response <- "{"result":[],"id":,"error":null }"
*/
func (rpcMethod *RPCMethod) Notify(jsonInput RequestParameters, jsonOutput *ResponseParameters) error {

	//Initialize rpcserver
	var err error
	err, rpcMethod.rpcServer = GetRPCServerInstance()
	var customError error
	if err != nil {
		customError = errors.New("Getting Server Instance error :" + err.Error())
		rpcMethod.rpcServer.logger.Println(customError)
		return customError
	}

	rpcMethod.rpcServer.logger.Println("RPCCall: In Notify")
	rpcMethod.rpcServer.logger.Println("Input=", jsonInput)

	var probablePredecessorId uint32
	probablePredecessorServerInfo := rpcclient.ServerInfo{}
	var parameters []interface{}
	parameters = jsonInput.Params

	//get inputId from the []interface
	for k, v := range parameters {
		if k == 0 {
			probablePredecessorId = uint32(v.(float64))
		} else if k == 1 {
			resultServerInfo := rpcclient.ServerInfo{}
			for key, value := range v.(map[string]interface{}) {
				switch key {
				case "serverID":
					resultServerInfo.ServerID = value.(string)
					break
				case "protocol":
					resultServerInfo.Protocol = value.(string)
					break
				case "IpAddress":
					resultServerInfo.IpAddress = value.(string)
					break
				case "Port":
					resultServerInfo.Port = int(value.(float64))
				}
			}
			probablePredecessorServerInfo = resultServerInfo
		}
	}

	//probablePredecessor ∈ (predecessor, chordNode)
	isPredecessorNil, predecessor := rpcMethod.rpcServer.chordNode.GetPredecessor()
	//predecessor == chordNode.Id refers to the case where the ActualNodesInRing = 1 i.e. predecessor is the node itself
	nodeId := rpcMethod.rpcServer.chordNode.Id
	if isPredecessorNil ||
		(probablePredecessorId > predecessor && probablePredecessorId < nodeId) ||
		predecessor == nodeId ||
		(probablePredecessorId < nodeId && predecessor > probablePredecessorId && predecessor > nodeId) ||
		(probablePredecessorId > nodeId && predecessor < probablePredecessorId && predecessor > nodeId) {

		rpcMethod.rpcServer.chordNode.SetPredecessor(false, probablePredecessorId)
		rpcMethod.rpcServer.chordNode.FtServerMapping[rpcMethod.rpcServer.chordNode.Predecessor] = probablePredecessorServerInfo

		//transfer keys to predecessor whose hash is less than predecessor chord ID
		rpcMethod.rpcServer.transferKeysToPredecessor()
	}

	return nil
}

func (rpcMethod *RPCMethod) FindSuccessor(jsonInput RequestParameters, jsonOutput *ResponseParameters) error {

	//Initialize rpcserver
	var err error
	err, rpcMethod.rpcServer = GetRPCServerInstance()
	var customError error
	if err != nil {
		customError = errors.New("Getting Server Instance error :" + err.Error())
		rpcMethod.rpcServer.logger.Println(customError)
		return customError
	}

	rpcMethod.rpcServer.logger.Println("RPCCall: In FindSuccessor ")
	rpcMethod.rpcServer.logger.Println("Input=", jsonInput)
	defer rpcMethod.rpcServer.logger.Println("Exited FindSuccssor=")

	var inputId uint32
	var succId uint32
	var interId uint32

	succServerInfo := rpcclient.ServerInfo{}

	var parameters []interface{}
	parameters = jsonInput.Params

	//get inputId from the []interface
	for k, v := range parameters {
		if k == 0 {
			inputId = uint32(v.(float64))
		}
	}

	/*
	   if (id ∈ (n, successor])
	      return successor;
	*/
	rpcMethod.rpcServer.logger.Println("Find Successor of (id)" + fmt.Sprint(inputId))
	rpcMethod.rpcServer.logger.Println("Current Node (n):" + fmt.Sprint(rpcMethod.rpcServer.chordNode.Id))
	rpcMethod.rpcServer.logger.Println("Current Node Successor (successor):" + fmt.Sprint(rpcMethod.rpcServer.chordNode.Successor))

	//case when only 1 node in chord ring - that node will be the successor
	if rpcMethod.rpcServer.chordNode.Id == rpcMethod.rpcServer.chordNode.Successor {
		succId = rpcMethod.rpcServer.chordNode.Id

		//basic condition
	} else if rpcMethod.rpcServer.chordNode.Id < inputId && inputId <= rpcMethod.rpcServer.chordNode.Successor {
		succId = rpcMethod.rpcServer.chordNode.Successor

		//successor id is less than node id - check whether inputId falls between (n,sucessor + 2^m)

	} else if rpcMethod.rpcServer.chordNode.Successor < rpcMethod.rpcServer.chordNode.Id && (inputId > rpcMethod.rpcServer.chordNode.Id || inputId < rpcMethod.rpcServer.chordNode.Successor) {
		succId = rpcMethod.rpcServer.chordNode.Successor

	} else {
		interId = rpcMethod.rpcServer.chordNode.ClosestPrecedingNode(inputId)

		// if call is being forwarded to the current node itself, that means current node itself is the successor
		if interId == rpcMethod.rpcServer.chordNode.Id {
			succId = rpcMethod.rpcServer.chordNode.Id
		} else {

			//create rpc call "{"method":"findSuccessor","params":[inputId]}"
			jsonMessage := "{\"method\":\"findSuccessor\",\"params\":[" + fmt.Sprint(inputId) + "]}"

			clientServerInfo := rpcclient.ServerInfo{}
			clientServerInfo.ServerID = rpcMethod.rpcServer.chordNode.FtServerMapping[interId].ServerID
			clientServerInfo.Protocol = rpcMethod.rpcServer.chordNode.FtServerMapping[interId].Protocol
			clientServerInfo.IpAddress = rpcMethod.rpcServer.chordNode.FtServerMapping[interId].IpAddress
			clientServerInfo.Port = rpcMethod.rpcServer.chordNode.FtServerMapping[interId].Port

			client := &rpcclient.RPCClient{}
			err, response := client.RpcCall(clientServerInfo, jsonMessage)

			if err != nil {
				fmt.Println(err)
				return nil
			}

			jsonOutput.Result = make([]interface{}, 2)
			// process only if response is present
			if response.(*(rpcclient.ResponseParameters)).Result != nil {
				succId = uint32(response.(*(rpcclient.ResponseParameters)).Result[0].(float64))

				resultServerInfo := rpcclient.ServerInfo{}
				for key, value := range response.(*(rpcclient.ResponseParameters)).Result[1].(map[string]interface{}) {
					switch key {
					case "serverID":
						resultServerInfo.ServerID = value.(string)
						break
					case "protocol":
						resultServerInfo.Protocol = value.(string)
						break
					case "IpAddress":
						resultServerInfo.IpAddress = value.(string)
						break
					case "Port":
						resultServerInfo.Port = int(value.(float64))
					}
				}
				succServerInfo = resultServerInfo
//.........这里部分代码省略.........

func (chordNode *ChordNode) stabilize() {
	chordNode.Logger.Println("Chord : In Stabilize")

	//RPC call to get predecessor of successor
	jsonMessage := "{\"method\":\"GetPredecessor\",\"params\":[]}"

	clientServerInfo := rpcclient.ServerInfo{}
	clientServerInfo.ServerID = chordNode.FtServerMapping[chordNode.FingerTable[1]].ServerID
	clientServerInfo.Protocol = chordNode.FtServerMapping[chordNode.FingerTable[1]].Protocol
	clientServerInfo.IpAddress = chordNode.FtServerMapping[chordNode.FingerTable[1]].IpAddress
	clientServerInfo.Port = chordNode.FtServerMapping[chordNode.FingerTable[1]].Port

	client := &rpcclient.RPCClient{}
	err, response := client.RpcCall(clientServerInfo, jsonMessage)

	if err != nil {
		chordNode.Logger.Println(err)
		return
	}

	// process only if response is present -- CASE WHERE SUCCESSOR LEAVES ABRUPTLY
	if response.(*(rpcclient.ResponseParameters)).Result != nil {
		isPredecessorOfSuccessorNil := (response.(*(rpcclient.ResponseParameters)).Result[0]).(bool)
		predecessorOfSuccessor := uint32((response.(*(rpcclient.ResponseParameters)).Result[1]).(float64))

		resultServerInfo := rpcclient.ServerInfo{}
		for key, value := range response.(*(rpcclient.ResponseParameters)).Result[2].(map[string]interface{}) {
			switch key {
			case "serverID":
				resultServerInfo.ServerID = value.(string)
				break
			case "protocol":
				resultServerInfo.Protocol = value.(string)
				break
			case "IpAddress":
				resultServerInfo.IpAddress = value.(string)
				break
			case "Port":
				resultServerInfo.Port = int(value.(float64))
			}
		}
		predecessorOfSuccessorServerInfo := resultServerInfo

		//update the successor
		if !isPredecessorOfSuccessorNil {
			isPredecessorNil, _ := chordNode.GetPredecessor()
			//predecessor == chordNode.Id refers to the case where the ActualNodesInRing = 1 i.e. predecessor is the node itself
			if (predecessorOfSuccessor > chordNode.Id && predecessorOfSuccessor < chordNode.Successor) ||
				(!isPredecessorNil && chordNode.Successor == chordNode.Id) ||
				(chordNode.Successor < chordNode.Id && predecessorOfSuccessor < chordNode.Successor) ||
				(chordNode.Successor < chordNode.Id && predecessorOfSuccessor > chordNode.Successor && predecessorOfSuccessor > chordNode.Id) {
				chordNode.Successor = predecessorOfSuccessor
				chordNode.FtServerMapping[chordNode.Successor] = predecessorOfSuccessorServerInfo
			}
		}
	}

	chordNode.Logger.Println("About to make RPC call: Notify")
	//RPC call to notify the successor about the predecessor(i.e. current node)
	jsonMessage = "{\"method\":\"Notify\",\"params\":[" + fmt.Sprint(chordNode.Id) + ", {\"serverID\":\"" + chordNode.MyServerInfo.ServerID + "\", \"protocol\":\"" + chordNode.MyServerInfo.Protocol + "\",\"IpAddress\":\"" + chordNode.MyServerInfo.IpAddress + "\",\"Port\":" + fmt.Sprint(chordNode.MyServerInfo.Port) + "}]}"

	clientServerInfo = rpcclient.ServerInfo{}
	clientServerInfo.ServerID = chordNode.FtServerMapping[chordNode.FingerTable[1]].ServerID
	clientServerInfo.Protocol = chordNode.FtServerMapping[chordNode.FingerTable[1]].Protocol
	clientServerInfo.IpAddress = chordNode.FtServerMapping[chordNode.FingerTable[1]].IpAddress
	clientServerInfo.Port = chordNode.FtServerMapping[chordNode.FingerTable[1]].Port

	client = &rpcclient.RPCClient{}
	err, _ = client.RpcCall(clientServerInfo, jsonMessage)

	if err != nil {
		chordNode.Logger.Println(err)
		return
	}
}