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)