def GetBlock(self, request, context):
try:
with self.mutex:
blk1 = self.blocks[request.idx]
tmp = pickle.dumps(blk1)
return P2PNode_pb2.GetBlockReply(blk = tmp)
except Exception:
return P2PNode_pb2.GetBlockReply(blk = 'None')
def SendBlock(self, request, context):
try:
blk = pickle.loads(request.blk)
except Exception:
return
self.handle_send_block(blk)
return P2PNode_pb2.SendBlockReply()
def reponseFindNode(self, request, context):
#add sendId
self.add(request.sendAddr.ip, request.sendAddr.port, request.sendId)
#query
ansNode = [(self.distance(request.targetId, self.id), self.addr[0],
self.addr[1], self.id)]
for bucket in self.buckets:
for item in bucket:
ansNode.append(
(self.distance(request.targetId,
item[2]), item[0], item[1], item[2]))
ansNode.sort(key=lambda x: x[0])
response = P2PNode_pb2.FindNodeReply()
tot = 0
for node in ansNode:
nodeinfo = response.nodes.add()
nodeinfo.addr.ip = node[1]
nodeinfo.addr.port = node[2]
nodeinfo.id = node[3]
tot = tot + 1
if (tot > self.k): #can be more?
break
return response
def send_block(self, node, blk):
format_addr = "%s:%s" % (node[0], node[1])
with grpc.insecure_channel(format_addr) as channel:
stub = P2PNode_pb2_grpc.BlockChainStub(channel)
response = stub.SendBlock(P2PNode_pb2.SendBlockRequest(blk=blk))
return
def get_block(self, node, idx):
format_addr = "%s:%s" % (node[0], node[1])
with grpc.insecure_channel(format_addr) as channel:
stub = P2PNode_pb2_grpc.BlockChainStub(channel)
response = stub.GetBlock(P2PNode_pb2.GetBlockRequest(idx=idx))
return response.blk
def ping(self, ip, port):
#print("ping:",ip,port)
format_addr = "%s:%s" % (ip, port)
channel = grpc.insecure_channel(format_addr)
stub = P2PNode_pb2_grpc.KademliaStub(channel)
request = P2PNode_pb2.pingRequest()
request.sendAddr.ip = self.addr[0]
request.sendAddr.port = self.addr[1]
request.message = "ping-pong"
response = stub.pong(request)
def FindNode(self, addr, id):
format_addr = "%s:%s" % (addr[0], addr[1])
with grpc.insecure_channel(format_addr) as channel:
stub = P2PNode_pb2_grpc.KademliaStub(channel)
request = P2PNode_pb2.FindNodeRequest()
request.sendAddr.ip = self.addr[0]
request.sendAddr.port = self.addr[1]
request.sendId = self.id
request.targetId = id
response = stub.reponseFindNode(request)
return response
return None
def GetBlockNum(self, request, context):
block_num = len(self.blocks)
return P2PNode_pb2.BlockNumReply(num = block_num)
def pong(self, request, context):
#print("pong:",request.sendAddr,self.addr)
return P2PNode_pb2.pongReply(message=request.message)
def setAddr(self, addr):
self.addr = addr
def join(self, static_addr):
peers = [static_addr]
used = set()
used.add(self.id)
while len(peers) > 0: # can be limit times
response = self.FindNode(peers[0], self.id)
#print("-------------",peers[0]);
del peers[0]
#print(response)
for node in response.nodes:
if node.id not in used:
if (node.addr.ip, node.addr.port) != static_addr:
peers.append((node.addr.ip, node.addr.port))
used.add(node.id)
self.add(node.addr.ip, node.addr.port, node.id)
if __name__ == '__main__':
#unit test
a = KademliaTable()
a.setAddr(("10.0.0.1", 50000))
request = P2PNode_pb2.FindNodeRequest()
request.sendAddr.ip = "10.0.0.2"
request.sendAddr.port = 50000
request.sendId = a.random_id()
request.targetId = request.sendId
a.reponseFindNode(request, 1)
def SayHello(self, request, context):
print("recive:", request.name)
return P2PNode_pb2.HelloReply(message='hello {msg}'.format(
msg=request.name))
def get_block_num(self, node):
format_addr = "%s:%s" % (node[0], node[1])
with grpc.insecure_channel(format_addr) as channel:
stub = P2PNode_pb2_grpc.BlockChainStub(channel)
response = stub.GetBlockNum(P2PNode_pb2.BlockNumRequest())
return response.num
async def sendData(self):
format_addr = "%s:%s" % (self.static_addr[0], self.static_addr[1])
with grpc.insecure_channel(format_addr) as channel:
stub = P2PNode_pb2_grpc.BlockChainStub(channel)
response = stub.SayHello(P2PNode_pb2.HelloRequest(name='czl'))
print("response : " + response.message)