def test_peer(self): # Creation peers peer1 = Peer(9999) peer2 = Peer(9998) # Send first message to peer2 peer1.client.set_client(socket.gethostname(), 9998) message_peer1 = Message.create(Message.LIST, Message.REQUEST, 1234) peer1.produce_response(IP=socket.gethostname(), port=9998, close=False, message=message_peer1) # Take back the message send by peer1 IP, sock_peer2_peer1, mess = peer2.consume_receive() message_peer2 = Message.create(Message.LIST, Message.ERROR, None) peer2.produce_response(socket=sock_peer2_peer1, close=True, message=message_peer2) print(peer1.consume_receive()) peer1.server.close() peer2.server.close()
def test_list_request(self): # Tracker tracker = Tracker(9990) tracker.list = Tracker.populate(40) client1 = Peer(9991) # List Request Message request = Message() request.set_packet_type(Message.REQUEST) request.set_packet(Message.LIST) request.set_data(9991) client1.produce_response(IP=socket.gethostbyname(socket.gethostname()), port=9990, message=request) response = client1.consume_receive()[2] # Checking the sublist flag = True for i in response.get_data(): if not tracker.list.is_member(i): flag = False client1.client.close() tracker.client.close() client1.server.close() tracker.server.close() self.assertEqual(flag, True)
def test_list_error(self): # Tracker tracker = Tracker(9995) tracker.list = Tracker.populate(40) client1 = Peer(9992) # List Error Message request = Message() request.set_packet_type(Message.ERROR) request.set_packet(Message.LIST) request.set_data(9992) client1.produce_response(IP=socket.gethostbyname(socket.gethostname()), port=9995, message=request) flag = True try: response = client1.consume_receive()[2] except Exception: flag = False client1.client.close() tracker.client.close() client1.server.close() tracker.server.close() self.assertEqual(flag, True)
def test_cheese_response(self): message = Message() message.set_packet(Message.CHEESE) message.set_packet_type(Message.RESPONSE) data = { "transactions": [{ "input": [("110812f67fa1e1f0117f6f3d70241c1a42a7b07711a93c2477cc516d9042f9db", 0)], "wallet": [ "110812f67fa1e1f0117f6f3d70241c1a42a7b07711a93c2477cc516d9042f9db01", "110812f67fa1e1f0117f6f3d70241c1a42a7b07711a93c2477cc516d9042f9db02", "00000000000000000000000000000000000000000000000000000000000000000" ], "amount": [10, 10, 0], "signature": [ "110812f67fa1e1f0117f6f3d70241c1a42a7b07711a93c2477cc516d9042f9d" ] }, { "input": [("110812f67fa1e1f0117f6f3d70241c1a42a7b07711a93c2477cc516d9042f9db", 0)], "wallet": [ "110812f67fa1e1f0117f6f3d70241c1a42a7b07711a93c2477cc516d9042f9db01", "110812f67fa1e1f0117f6f3d70241c1a42a7b07711a93c2477cc516d9042f9db02", "00000000000000000000000000000000000000000000000000000000000000000" ], "amount": [10, 10, 0], "signature": [ "110812f67fa1e1f0117f6f3d70241c1a42a7b07711a93c2477cc516d9042f9d" ] }], "nonce": 123456789 } message.set_data(data) writer = MessageWriter(message) string = writer.write() self.assertEqual( string, "CHEESE RESPONSE " + "110812f67fa1e1f0117f6f3d70241c1a42a7b07711a93c2477cc516d9042f9db" + " 0 110812f67fa1e1f0117f6f3d70241c1a42a7b07711a93c2477cc516d9042f9db01 110812f67fa1e1f0117f6f3d70241c1a42a7b07711a93c2477cc516d9042f9db02" + " 00000000000000000000000000000000000000000000000000000000000000000" + " 10 10 0 110812f67fa1e1f0117f6f3d70241c1a42a7b07711a93c2477cc516d9042f9d " + "110812f67fa1e1f0117f6f3d70241c1a42a7b07711a93c2477cc516d9042f9db" + " 0 110812f67fa1e1f0117f6f3d70241c1a42a7b07711a93c2477cc516d9042f9db01 110812f67fa1e1f0117f6f3d70241c1a42a7b07711a93c2477cc516d9042f9db02" + " 00000000000000000000000000000000000000000000000000000000000000000" + " 10 10 0 110812f67fa1e1f0117f6f3d70241c1a42a7b07711a93c2477cc516d9042f9d 123456789\r\n" )
def handle_thread(): update = True while(update and not(self.event_halt.is_set())): # Get the member list while(not(self.event_member_list.is_set()) and not(self.event_halt.is_set())): pass if(self.event_halt.is_set()): return None member_list = self.member_list.ressource # If the member list is not empty then if(self.member_list.read(member_list.__len__) != 0): ttl = self.ttl.ressource cheese_stack = self.cheese_stack.ressource # If the ttl is not dead, while(not(self.ttl.read(ttl.is_zero))): # We get the last cheese last_cheese = self.cheese_stack.read(cheese_stack.last) last_smell = last_cheese.smell # We send the request every sleep seconds time.sleep(sleep) # and we will ask if there is a new cheese message = Message.create(Message.CHEESE, Message.REQUEST, last_smell) self.send(message) update = False else: time.sleep(sleep)
def test_member_report(self): message = Message() message.set_packet(Message.MEMBER) message.set_packet_type(Message.REPORT) message.set_data(("192.168.1.1", 2)) writer = MessageWriter(message) string = writer.write() self.assertEqual(string, "MEMBER REPORT 192.168.1.1 2\r\n")
def test_cheese_request(self): message = Message() message.set_packet(Message.CHEESE) message.set_packet_type(Message.REQUEST) message.set_data("af4721920") writer = MessageWriter(message) string = writer.write() self.assertEqual(string, "CHEESE REQUEST af4721920\r\n")
def test_list_request(self): message = Message() message.set_packet(Message.LIST) message.set_packet_type(Message.REQUEST) message.set_data(1234) writer = MessageWriter(message) string = writer.write() self.assertEqual(string, "LIST REQUEST 1234\r\n")
def test_list_response(self): message = Message() message.set_packet(Message.LIST) message.set_packet_type(Message.RESPONSE) message.set_data([("192.168.1.1", 2), ("127.0.0.0.1", 1234)]) writer = MessageWriter(message) string = writer.write() self.assertEqual( string, "LIST RESPONSE 192.168.1.1 2 " + "127.0.0.0.1 1234\r\n")
def process_cheese_request(self, message): """ We process the message CHEESE REQUEST """ # We get the parent smell parent_smell = message.get_data() # We get the cheese stak cheese_stack = self.cheese_stack.ressource # We get the requested cheese try: cheese = self.cheese_stack.read(cheese_stack.__getitem__, parent_smell) except KeyError: cheese = None # If we have the requested cheese, if(cheese is not None): # we return the response message = Message.create(Message.CHEESE, Message.RESPONSE, cheese) else: # otherwise, we get the cheese error message = Message.create(Message.CHEESE, Message.ERROR, None) return message
def process_transaction_request(self): """ We process a TRANSACTION REQUEST """ # We get a list of transactions transaction_list = self.transaction_list.ressource # We get the last transaction last = self.transaction_list.read(transaction_list.get_last) # We send back the response message = Message() message.set_packet(Message.TRANSACTION) message.set_packet_type(Message.RESPONSE) message.set_data(last) return message
def test_list_error(self): message = Message() message.set_packet(Message.LIST) message.set_packet_type(Message.ERROR) writer = MessageWriter(message) string = writer.write() self.assertEqual(string, "LIST ERROR\r\n")
def test_cheese_error(self): message = Message() message.set_packet(Message.CHEESE) message.set_packet_type(Message.ERROR) writer = MessageWriter(message) string = writer.write() self.assertEqual(string, "CHEESE ERROR\r\n")
def test_member_error(self): # Tracker print('begin') tracker = Tracker(9996) print(tracker.client) print('end') tracker.list = Tracker.populate(5) print('beginC') client1 = Peer(9997) print('endC') print("step 1") # Add the client to Member List print(tracker.list.print_list()) tracker.list.add_member( (socket.gethostbyname(client1.server.host_name), client1.server.port)) print("step 2") print(tracker.list.print_list()) # List Request Message request = Message() request.set_packet_type(Message.REPORT) request.set_packet(Message.MEMBER) request.set_data((socket.gethostbyname(client1.server.host_name), client1.server.port)) print("step 3") client1.produce_response(IP=socket.gethostbyname(socket.gethostname()), port=9996, message=request) print("step 4") # NOOOOOOOOOT FINISHEDDDDDDDDDDDDDD print("step 5") # Checking if Client is in Member List flag = tracker.list.is_member( (socket.gethostbyname(client1.server.host_name), client1.server.port)) print(flag) print("step 6") #time.sleep(2) print('Socket ' + str(client1.client.socket)) client1.client.close() #tracker.client.close() client1.server.close() tracker.server.close() print("fini") self.assertEqual(flag, True)
def test_transaction_error(self): message = Message() message.set_packet(Message.TRANSACTION) message.set_packet_type(Message.ERROR) writer = MessageWriter(message) string = writer.write() self.assertEqual(string, "TRANSACTION ERROR\r\n")
def test_transaction_request(self): message = Message() message.set_packet(Message.TRANSACTION) message.set_packet_type(Message.REQUEST) writer = MessageWriter(message) string = writer.write() self.assertEqual(string, "TRANSACTION REQUEST\r\n")
def handle_thread(): while(not(self.event_halt.is_set())): while(not(self.event_mining.is_set()) and not(self.event_halt.is_set())): pass if(self.event_halt.is_set()): return None print("Debug: we are trying to mine ...") mining_cheese = self.mining_cheese.ressource if(self.mining_cheese.write(mining_cheese.mine, ntimes) is True): # If we can add the cheese to the stack, cheese_stack = self.cheese_stack.ressource if(self.cheese_stack.write(cheese_stack.add, mining_cheese)): # We remove the transactions from our list trans_list = self.transaction_list.ressource self.transaction_list.write(trans_list.remove_all, mining_cheese.data) print("Debug: We mined a cheese " + str(self.mining_cheese.ressource.smell)) # We save the cheese stack self.cheese_stack.write(cheese_stack.save) # We add the money self.money_list.add(mining_cheese) # We broadcast the cheese message = Message.create(Message.CHEESE, Message.BROADCAST, mining_cheese) self.broadcast(message) # We create a new cheese to mine self.mining_cheese = Cheese() self.mining_cheese = Ressource(self.mining_cheese) self.create_mining_cheese() time.sleep(sleep)
def handle_thread(): while(not(self.event_halt.is_set())): member_list = self.member_list.ressource size_member = self.member_list.read(member_list.__len__) if size_member < size: self.event_member_list.clear() # We create a message to send to the tracker message = Message.create(Message.LIST, Message.REQUEST, self.port) # and we send it self.produce_response(IP=self.ip_tracker, port=self.port_tracker, message=message) # We ask test the list every sleep seconds time.sleep(sleep)
def process_message(self, tuple): (ip, socket, message) = tuple # Handling Messages if message.get_packet() == Message.LIST: # List REQUEST # Creating a RESPONSE message if message.get_packet_type() == Message.REQUEST: # Adding member to list port = int(message.get_data()) member_list = self.member_list.ressource self.member_list.write(member_list.add_member, (ip, port)) response = Message() response.set_packet(Message.LIST) response.set_packet_type(Message.RESPONSE) member_list = self.member_list.ressource sublist = self.member_list.read(member_list.get_sublist) response.set_data(sublist) self.produce_response(socket=socket, message=response, close=True) # List ERROR elif message.get_packet_type() == Message.ERROR: print(message.get_data()) # Member REPORT elif (message.get_packet_type() == Message.REPORT and message.get_packet() == Message.MEMBER): try: ip_port = message.get_data() except ValueError: raise Exception('Error: Invalid IP Port') (ip, port) = ip_port self.produce_ping(ip, port) else: print('Error: No Message Type Detected\n')
def tes_connection(self): # Start the sever s = Server('localhost', 9999) # Start the client c = Client('localhost', 9999) socket, _ = s.server_socket.accept() # Send a message and close the socket message_client = Message.create(Message.LIST, Message.REQUEST, 1234) c.send(message_client) message_server = s.read(socket) s.close() c.close() self.assertEqual(message_client.packet, message_server.packet) self.assertEqual(message_client.packet_type, message_server.packet_type) self.assertEqual(message_client.data, message_server.data)
def handle_thread(): while(not(self.event_halt.is_set())): # We get the response of a pong response = self.consume_pong() if(response is None): return None ip, port, pong = response if(not(pong)): # We get the member list member_list = self.member_list.ressource # We remove the member from our list self.member_list.write(member_list.remove_member, (ip, port)) # and we report to the tracker that # a member is not connected message = Message.create(Message.MEMBER, Message.REPORT, (ip, port)) self.produce_response(IP=self.ip_tracker, port=self.port_tracker, message=message)
def create_transaction(self): """ We will create a transaction after pushing the button """ # We get the amount amount = int(self.entry_amount.get()) # We create the transaction transaction_user = Transaction.create_user(self.member.money_list, amount, self.entry_receiver.get()) # We add it to the transactions list transaction_list = self.member.transaction_list.ressource self.member.transaction_list.write(transaction_list.add, transaction_user) # We broadcast the transaction message = Message() message.set_packet(Message.TRANSACTION) message.set_packet_type(Message.BROADCAST) message.set_data(transaction_user) self.member.broadcast(message) self.entry_amount.delete(0, 'end') self.entry_receiver.delete(0, 'end')
def test_transaction_response(self): message = Message() message.set_packet(Message.TRANSACTION) message.set_packet_type(Message.RESPONSE) data = { "input": [("110812f67fa1e1f0117f6f3d70241c1a4" + "2a7b07711a93c2477cc516d9042f9db", 0)], "wallet": [ "110812f67fa1e1f0117f6f3d70241c1a" + "42a7b07711a93c2477cc516d9042f9db01", "110812f67fa1e1f0117f6f3d70241c1a42" + "a7b07711a93c2477cc516d9042f9db02", "0000000000000000000000000000000000" + "0000000000000000000000000000000" ], "amount": [10, 10, 0], "signature": [ "110812f67fa1e1f0117f6f3d70241" + "c1a42a7b07711a93c2477cc516d9042f9d" ] } message.set_data(data) writer = MessageWriter(message) string = writer.write() self.assertEqual( string, "TRANSACTION RESPONSE 110812f67fa1e1f0117f6f3d70241c1a42a7b07711a93c2477cc516d9042f9db" + " 0 110812f67fa1e1f0117f6f3d70241c1a42a7b07711a93c2477cc516d9042f9db01 110812f67fa1e1f0117f6f3d70241c1a42a7b07711a93c2477cc516d9042f9db02" + " 00000000000000000000000000000000000000000000000000000000000000000" + " 10 10 0 110812f67fa1e1f0117f6f3d70241c1a42a7b07711a93c2477cc516d9042f9d\r\n" )
def test_set_packet(self): message = Message() message.set_packet(Message.LIST) self.assertEqual(message.get_packet(), Message.LIST) message.set_packet(Message.MEMBER) self.assertEqual(message.get_packet(), Message.MEMBER) message.set_packet(Message.TRANSACTION) self.assertEqual(message.get_packet(), Message.TRANSACTION) message.set_packet(Message.CHEESE) self.assertEqual(message.get_packet(), Message.CHEESE) message.set_packet(Message.RESPONSE) self.assertEqual(message.get_packet(), Message.NOTHING) message.set_packet(Message.REQUEST) self.assertEqual(message.get_packet(), Message.NOTHING) message.set_packet(Message.REPORT) self.assertEqual(message.get_packet(), Message.NOTHING) message.set_packet(Message.ERROR) self.assertEqual(message.get_packet(), Message.NOTHING)
def test_set_data(self): string = "TEST" message = Message() message.set_data(string) self.assertEqual(message.get_data(), string)
def test_get_data(self): message = Message() self.assertEqual(message.get_data(), message.data)
def test_get_packet(self): message = Message() self.assertEqual(message.packet, message.get_packet())
def produce_pong(self, ip, port, pong): """ We put in the queue the response of the ping """ message = Message.create(Message.PING, Message.RESPONSE, pong) self.queue_pong.put((ip, port, message))
def produce_ping(self, IP, port): """ Ask for a ping """ message = Message.create(Message.PING, Message.REQUEST, None) self.ping.queue_ping.put((IP, port, message))