def rpc(self, remote_procedure, args, kwargs):
self.lock.acquire()
try:
msg = message.Request(self.next_id, remote_procedure,
[args, kwargs])
self.next_id += 1
# Attempt sending and connection if neccessary
try:
msg.serialize(self.socket)
except socket.error as e:
# Connection error, try to connect and send
if e.args[0] == 32:
try:
self.socket.connect((self.host, self.port))
msg.serialize(self.socket)
except socket.error as e:
raise exception.JRPCError(
"Unable to connect to remote service", e)
else:
raise e
response = message.deserialize(self.socket)
if not type(response) is message.Response:
raise exception.JRPCError("Received a message of uknown type")
if response.id != msg.id:
raise exception.JRPCError(
0, "Got a response for a different request ID")
if hasattr(response, "result"):
return response.result
elif hasattr(response, "error"):
raise exception.JRPCError.from_error(response.error)
raise Exception("Deserialization failure!!")
finally:
self.lock.release()
def start(self):
peers = self.tracker.get_peers_from_trackers()
self.peers_manager.add_peers(peers)
while not self.pieces_manager.all_pieces_completed():
if not self.peers_manager.has_unchoked_peers():
time.sleep(0.1)
continue
self.display_progression()
for piece in self.pieces_manager.pieces:
if piece.is_full: continue
peer = self.peers_manager.get_random_peer_having_piece(
piece.piece_index)
if not peer: continue
data = self.pieces_manager.pieces[
piece.piece_index].get_empty_block()
if data:
piece_index, block_offset, block_length = data
piece_data = message.Request(piece_index, block_offset,
block_length).to_bytes()
peer.send_to_peer(piece_data)
if piece.all_blocks_full():
piece.set_to_full()
piece.update_block_status()
time.sleep(0.1)
self._exit_threads()
def ExeUpdate(cmdline_input):
global RequestQueue
if cmdline_input.strip()[:5] == "delay":
tmpstr = cmdline_input.strip()[6:]
Ltmpstr = tmpstr.split()
global DelayTime
DelayTime = float(Ltmpstr[0])
return
# utility tool: show-all
if cmdline_input.strip() == "show-all":
#print "going to tell server to print out all <key,value> pairs..."
ClientThread.sendMsg("show-all", NodeID)
return
# utility tool: search key
if cmdline_input.strip()[:6] == "search":
for i in xrange(NUM_NODES):
ClientThread.sendMsg(cmdline_input.strip() + " " + str(NodeID),
i)
return
# replica operation: insert/delete/update/get...
request = message.Request(cmdline_input)
if not utils.IsCmdValid(request.cmd):
print "Client: Invalid command!"
#TODO: print out help menu
return
print "Client: Received request {request} at {timestamp}".format( \
request=cmdline_input.strip(), \
timestamp=datetime.datetime.now().time().strftime("%H:%M:%S"))
RequestQueue.append(request)
def listMembers(self, group):
cont = {'Group': group}
req = msg.Request(msg.RequestType.ListMembers, cont)
reply = msg.Reply.fromString(self.askTracker(req))
return [peer['Username'] for peer in reply.getContent()]
def quit(self):
cont = {'Username': self.username}
req = msg.Request(msg.RequestType.Quit, cont)
_ = msg.Reply.fromString(self.askTracker(req))
self.sock.close()
def listGroups(self):
cont = {}
req = msg.Request(msg.RequestType.ListGroups, cont)
reply = msg.Reply.fromString(self.askTracker(req))
return reply.getContent()
def register(self):
cont = {
'Ip': self.address[0],
'Port': self.address[1],
'Username': self.username
}
req = msg.Request(msg.RequestType.Register, cont)
reply = msg.Reply.fromString(self.askTracker(req))
return reply.getContent()
def heartbeat(self):
while True:
time.sleep(60)
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
sock.connect(self.TRACKER_ADDR)
lg.debug('heartbeat')
cont = {'Username': self.username}
heartbeat = msg.Request(msg.RequestType.Heartbeat, cont)
sock.send(str(heartbeat).encode())
# wait for answer
sock.recv(4096)
sock.close()
def parseNonHandshakeMessage(data,sock):
bytestring = data
if (bytestring[0:4] == '\x00\x00\x00\x00'):
# Its a Keep Alive message #
message_obj = message.KeepAlive(response=bytestring)
else:
message_obj = {
0: lambda: message.Choke(response=bytestring),
1: lambda: message.Unchoke(response=bytestring),
2: lambda: message.Interested(response=bytestring),
3: lambda: message.Interested(response=bytestring),
4: lambda: message.Have(response=bytestring),
5: lambda: message.Bitfield(response=bytestring),
6: lambda: message.Request(response=bytestring),
7: lambda: message.Piece(response=bytestring),
8: lambda: message.Cancel(response=bytestring),
9: lambda: message.Port(response=bytestring),
}[ struct.unpack('!b',data[4])[0] ]() # The 5th byte in 'data' is the message type/id
process_message(message_obj,sock)
def handle_connection(self, conn, addr):
"""Handle a new connection"""
print "[Connected to: " + addr[0] + ":" + str(addr[1]) + "]"
requests = conn.recv(1024)
p = parser.RequestParser()
m = message.Request()
parsed = p.parse_requests(requests)
t = parsed[0]
r = composer.ResponseComposer(15)
response = r.compose_response(t)
conn.send(str(response))
print addr[0] + ":" + str(
addr[1]) + " requested " + t.get_header("URI") + "\t[" + str(
response.code) + "]"
print response.get_header("URI")
if t.get_header("Connection") == "close":
conn.close()
print "[Closed connection: " + addr[0] + ":" + str(
addr[1]) + " because the client requested it]"
pass
def exitGroup(self, groupname):
group = self.groups.getGroupByName(groupname)
if group is None:
print("well you don't belong in that group anyway")
return
cont = {'Username': self.username, 'Group': groupname}
req = msg.Request(msg.RequestType.ExitGroup, cont)
_ = msg.Reply.fromString(self.askTracker(req))
for member in group.getMembers():
member.resetCounterForGroup(group)
self.multicastInGroup(group, msg.MessageType.Bye, '')
if self.selectedGroup == group:
self.selectedGroup = None
self.groups.removeGroup(group)
def joinGroup(self, groupname):
cont = {'Username': self.username, 'Group': groupname}
req = msg.Request(msg.RequestType.JoinGroup, cont)
reply = msg.Reply.fromString(self.askTracker(req))
group = self.groups.getGroupByName(groupname)
if group is None:
group = Group(groupname)
self.groups.addNewGroup(group)
group.clearMembers()
for peer in reply.getContent():
mem = Member((peer['Ip'], int(peer['Port'])), peer['Username'])
self.members.addNewMember(mem)
group.addMember(mem)
"""Send Hello message"""
self.unicastInGroup(group, mem, msg.MessageType.Hello, '',
group.getCounter())
def start(self):
peers_dict = self.tracker.get_peers_from_trackers()
self.peers_manager.add_peers(peers_dict.values())
while not self.pieces_manager.all_pieces_completed():
if not self.peers_manager.has_unchoked_peers():
time.sleep(1)
logging.info("No unchocked peers")
continue
for piece in self.pieces_manager.pieces:
index = piece.piece_index
if self.pieces_manager.pieces[index].is_full:
continue
peer = self.peers_manager.get_random_peer_having_piece(index)
if not peer:
continue
self.pieces_manager.pieces[index].update_block_status()
data = self.pieces_manager.pieces[index].get_empty_block()
if not data:
continue
piece_index, block_offset, block_length = data
piece_data = message.Request(piece_index, block_offset,
block_length).to_bytes()
peer.send_to_peer(piece_data)
self.display_progression()
time.sleep(0.1)
logging.info("File(s) downloaded successfully.")
self.display_progression()
self._exit_threads()
time.sleep(1)
continue
for piece in pieces_manager.pieces:
index = piece.piece_index
if pieces_manager.pieces[index].is_full:
continue
peer = peers_manager.get_random_peer_having_piece(index)
if not peer:
continue
pieces_manager.pieces[index].update_block_status()
data = pieces_manager.pieces[index].get_empty_block()
if not data:
continue
piece_index, block_offset, block_length = data
piece_data = message.Request(piece_index, block_offset, block_length).to_bytes()
peer.send_to_peer(piece_data)
print((pieces_manager.complete_pieces/pieces_manager.number_of_pieces))
time.sleep(0.1)
peers_manager.is_active = False
os._exit(0)
