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))
