async def run(self):
print(f"{self.agent.pid} is working")
diff = time.time() - self.agent.time
break_time = 50
leave_time = random.randint(25, 45)
await asyncio.sleep(5)
if diff <= break_time:
if random.random() > 0.3:
await asyncio.sleep(break_time - diff)
self.agent.go_to = "break"
self.set_next_state(STATE_TWO)
else:
for person in self.agent.team:
msg3 = util.make_message(meeting_inform_template,
to=person + '@anoxinon.me')
await self.send(msg3)
self.agent.go_to = "meeting"
self.set_next_state(STATE_TWO)
else:
if random.random() > 0.3:
await asyncio.sleep(break_time - diff)
self.agent.go_to = "lobby"
self.set_next_state(STATE_TWO)
else:
for person in self.agent.team:
msg4 = util.make_message(meeting_inform_template,
to=person + '@anoxinon.me')
await self.send(msg4)
self.agent.go_to = "meeting"
self.set_next_state(STATE_TWO)
async def run(self):
msg = await self.receive(timeout=20)
if msg:
if msg.metadata["ontology"] == "pref":
reply = util.make_message(room_pref_redirect, to=msg.body+'@anoxinon.me')
await self.send(reply)
elif msg.metadata["ontology"] == "na":
reply = util.make_message(non_attandance_redirect, to=msg.body+'@anoxinon.me')
await self.send(reply)
elif msg.metadata["ontology"] == "ok":
reply = util.make_message(arrival_inform_redirect, to=msg.body+'@anoxinon.me')
await self.send(reply)
def extract_file(self, msg, msg_unsplit, addr):
'''
provided with the client message the function returns a constructed message
'''
total_recievers = msg[2]
total_recievers = int(total_recievers)
recievers = []
sender = ''
for s in self.clients:
if self.clients[s] == addr:
sender = s
sender = str(sender)
for i in range(3, total_recievers + 3):
recievers.append(msg[i])
file_name = msg[total_recievers + 3]
d = msg_unsplit.split("<delimtter>")
text = d[1]
tmp = "1 " + sender + " " + file_name + " <delimtter>" + text
res = util.make_message("forward_file", 4, tmp)
#print("file:",sender)
recievers = list(dict.fromkeys(recievers))
return res, recievers, sender
async def run(self):
await asyncio.sleep(20)
rooms = ["Agent5-om","Agent6-om","Agent7-om"]#doldur
if random.random() < 0.2:
for room in rooms:
msg = util.make_message(default_temp_template, to=room+'@anoxinon.me')
msg.body = str(random.randrange(20,30))
await self.send(msg)
def send(self, address, msgFormat, msgType, msg=None):
'''
Function to make message then packet
and then send it
'''
sendMessage = util.make_message(msgFormat, msgType,
msg) #Make the formated message
sendPacket = util.make_packet(msg=sendMessage) #Make the packet
self.sock.sendto(sendPacket.encode("utf-8"), address) #Send packet
def send(self, msgFormat, msgType, msg=None):
'''
Function to make message then packet
and then send it
'''
sendMessage = util.make_message(msgFormat, msgType,
msg) #Make the message
sendPacket = util.make_packet(msg=sendMessage) #Make the packet
self.sock.sendto(sendPacket.encode("utf-8"),
(self.server_addr,
self.server_port)) #Send the list request message
async def run(self):
print(f"{self.agent.pid} is taking a break")
if self.agent.pref != False and random.random() < 0.3:
self.agent.pref = random.randrange(20, 30)
if self.agent.position != "C":
msg = util.make_message(pref_inform_template,
to='*****@*****.**')
msg.body = str(self.agent.pref)
await self.send(msg)
await asyncio.sleep(random.randint(5, 15))
self.agent.go_to = self.agent.office
self.set_next_state(STATE_TWO)
async def run(self):
await asyncio.sleep(5)
if random.random() > 0.2:
move_time = random.randint(0, 15) #10 average on time
await asyncio.sleep(move_time)
self.agent.location = "lobby"
self.agent.go_to = self.agent.office
if self.agent.position != "C":
msg = util.make_message(arrival_inform_template,
to='*****@*****.**')
msg.body = self.agent.office
await self.send(msg)
self.set_next_state(STATE_TWO)
else:
print(f"{self.agent.pid} not going to work")
msg = util.make_message(absence_inform_template,
to='*****@*****.**')
if self.agent.position != "C":
msg.body = self.agent.office
await self.send(msg)
def join(self):
'''
makes the join request
'''
req = ""
self.start_conn()
join_req = util.make_message("join", 1, self.name)
self.incrementPacketn()
packet = util.make_packet('data', self.packet_num, join_req)
self.send_req(packet)
self.waitAndreSend(packet)
self.end_conn()
def send(self, msgFormat, msgType, msg=None):
'''
Function to make message then packet and then send it
'''
global stop
global acknowledged
global nextSeqNumber
sendMessage = util.make_message(msgFormat, msgType, msg)
chunks = util.make_chunks(sendMessage)
#Start packet
sequenceNumber = random.randint(10, 100)
sendPacket = util.make_packet(
"start",
sequenceNumber,
)
self.sock.sendto(sendPacket.encode("utf-8"),
(self.server_addr, self.server_port))
#Data packets
#For each data packet send it once acknowledge message is received
for chunk in chunks:
while not acknowledged:
pass
sendPacket = util.make_packet("data", nextSeqNumber, chunk)
self.sock.sendto(sendPacket.encode("utf-8"),
(self.server_addr, self.server_port))
acknowledged = False
#End packet
#Stop until acknowled message is not received
while not acknowledged:
pass
sendPacket = util.make_packet(
"end",
nextSeqNumber,
)
self.sock.sendto(sendPacket.encode("utf-8"),
(self.server_addr, self.server_port))
acknowledged = False
def extract_message(self, msg, addr):
'''
provided with the clients message the function returns a constructed message
'''
total_recievers = msg[2]
total_recievers = int(total_recievers)
recievers = []
sender = ''
for s in self.clients:
if self.clients[s] == addr:
sender = s
sender = str(sender)
for i in range(3, total_recievers + 3):
recievers.append(msg[i])
text = ''
for i in range(total_recievers + 3, len(msg)):
text = text + " " + msg[i]
text = text.strip()
tmp = "1 " + sender + " " + text
res = util.make_message("forward_message", 4, tmp)
recievers = list(dict.fromkeys(recievers))
return res, recievers, sender
def start(self):
'''
Main Loop is here
Start by sending the server a JOIN message.
Waits for userinput and then process it
'''
#Join
string = f"{self.name}"
msg = util.make_message('join', self.dict['join'], string)
packet = util.make_packet('data', 0, msg)
self.sock.sendto(packet.encode('utf-8'),
(self.server_addr, self.server_port))
while True:
inp = str(input(''))
if 'quit' == inp:
s = 'quitting'
print(s)
sys.stdout.flush()
inp = str(inp.replace('msg', ''))
msg = util.make_message('disconnect', self.dict['disconnect'],
inp)
packet = util.make_packet('data', 0, msg)
self.sock.sendto(packet.encode('utf-8'),
(self.server_addr, self.server_port))
self.sock.close()
os._exit(1)
elif 'list' == inp:
inp = inp.replace('list', '')
msg = util.make_message('request_list',
self.dict['request_list'], inp)
packet = util.make_packet('data', 0, msg)
self.sock.sendto(packet.encode('utf-8'),
(self.server_addr, self.server_port))
elif 'msg' in inp:
inp = inp.replace('msg', '')
msg = util.make_message('msg', self.dict['msg'], inp)
packet = util.make_packet('data', 0, msg)
self.sock.sendto(packet.encode('utf-8'),
(self.server_addr, self.server_port))
elif 'file' in inp:
file = inp.split(' ')[-1]
try:
with open(file, 'r') as f:
data = f.read()
except:
print('file not found')
pass
data = data.replace(' ', '[s]').replace('\n', '[nl]')
string = " ".join(inp.split()[1:])
string = string + ' ' + data
msg = util.make_message('send_file', self.dict['send_file'],
string)
packet = util.make_packet('data', 0, msg)
self.sock.sendto(packet.encode('utf-8'),
(self.server_addr, self.server_port))
else:
print(f'incorrect userinput format')
async def run(self):
msg = util.make_message(exit_inform_template,
to='*****@*****.**')
msg.body = self.agent.office
await self.send(msg)
self.agent.location = "home"
def start(self):
'''
Main loop.
continue receiving messages from Clients and processing it
'''
print("HOST IS UP !! ")
while True:
packet, client_soc = self.sock.recvfrom(util.CHUNK_SIZE)
msg = packet.decode('utf-8').split('|')[2]
command = list(msg.split(' '))[0]
length = int(list(msg.split(' '))[1])
username = ''
if command == 'join':
user = msg.split()[2]
username = user
if len(self.clients) >= util.MAX_NUM_CLIENTS:
string = "disconnected:server_full!!"
msg = util.make_message('ERR_SERVER_FULL',
self.dict['ERR_SERVER_FULL'],
string)
packet = util.make_packet('data', 0, msg)
self.sock.sendto(packet.encode('utf-8'), client_soc)
elif user in self.clients.keys():
string = "disconnected:username_unavailable!!"
msg = util.make_message(
'ERR_USERNAME_UNAVAILABLE',
self.dict['ERR_USERNAME_UNAVAILABLE'], string)
packet = util.make_packet('data', 0, msg)
self.sock.sendto(packet.encode('utf-8'), client_soc)
else:
print(f"join: {user}")
self.clients[user] = client_soc[1]
if command == 'request_list':
if length == 0:
lst = ''
lst = '$'.join(sorted(self.clients.keys()))
user = list(self.clients.keys())[list(
self.clients.values()).index(client_soc[1])]
#lst.replace(user,'')
print(f'request_users_list: {user}')
string = f"{lst}"
msg = util.make_message('response_list',
self.dict['response_list'], string)
packet = util.make_packet('data', 0, msg)
self.sock.sendto(packet.encode('utf-8'), client_soc)
else:
self.dc(user, client_soc)
elif command == 'msg':
msg = msg.replace(' ', ' ')
if re.match('msg \d+ \d+ .*', msg):
lst = msg.split(' ')
no = int(lst[2])
clients = lst[3:2 + no + 1]
msg = ' '.join(lst[3 + len(clients):])
msg = msg.replace('$', ' ')
user = list(self.clients.keys())[list(
self.clients.values()).index(client_soc[1])]
print(f'msg: {user}')
string = f'msg: {user}: {msg}'
msg = util.make_message('FORWARD', self.dict['FORWARD'],
string)
packet = util.make_packet('data', 0, msg)
for i in range(0, no):
if clients[i] in self.clients.keys():
self.sock.sendto(
packet.encode('utf-8'),
(client_soc[0], self.clients[clients[i]]))
else:
print(
f"msg: {user} to non-existent user {clients[i]}"
)
else:
self.dc(user, client_soc)
elif command == 'disconnect':
if length == 4:
user = list(self.clients.keys())[list(
self.clients.values()).index(client_soc[1])]
del self.clients[user]
print(f'disconnected: {user}')
else:
self.dc(user, client_soc)
elif command == 'send_file':
try:
user = list(self.clients.keys())[list(
self.clients.values()).index(client_soc[1])]
lst = msg.split()
no = int(lst[2])
clients = lst[3:2 + no + 1]
lst2 = lst[3 + len(clients):]
file = lst2[0]
data = lst2[1]
print(f'file: {user}: {file}')
sys.stdout.flush()
string = f'{user} {file} {data}'
msg = util.make_message('forward_file',
self.dict['forward_file'], string)
packet = util.make_packet('data', 0, msg)
for i in range(0, no):
if clients[i] in self.clients.keys():
self.sock.sendto(
packet.encode('utf-8'),
(client_soc[0], self.clients[clients[i]]))
else:
print(
f"file: {user} to non-existent user {clients[i]}"
)
except:
self.dc(user, client_soc)
def dc(self, user, client_soc):
print(f'diconnected: {user} sent unknown command')
del self.clients[user]
msg = util.make_message('DISCONNECT', self.dict['DISCONNECT'], '')
packet = util.make_packet('data', 0, msg)
self.sock.sendto(packet.encode('utf-8'), client_soc)
def send(self, address, msgFormat, msgType, msg=None):
'''
Function to make message then packet and then send it and
maintain the window
'''
global ACKSTORE
global EXPECTEDACK
windowStore = queue.Queue()
retransmissions = 0
packetIndex = 0
sendMessage = util.make_message(msgFormat, msgType, msg)
chunks = util.make_chunks(sendMessage)
#Start packet functionality
sequenceNumber = random.randint(10, 100)
sendPacket = util.make_packet("start", sequenceNumber,)
self.sock.sendto(sendPacket.encode("utf-8"), address)
sequenceNumber += 1
EXPECTEDACK[address] = sequenceNumber
#Resend the start packet if no ack received
while True:
try:
_ = ACKSTORE[address].get(timeout=util.TIME_OUT)
break
except:
if retransmissions == util.NUM_OF_RETRANSMISSIONS:
break
retransmissions += 1
self.sock.sendto(sendPacket.encode("utf-8"), address)
#Data packets functionality
#Store the packets in the queue (number of packets stored <= window size)
for i in range(self.window):
sendPacket = util.make_packet("data", sequenceNumber, chunks[i])
windowStore.put(sendPacket)
sequenceNumber += 1
#If packets required to send < window size
if i == len(chunks) - 1:
break
packetIndex = self.window
EXPECTEDACK[address] += 1
self.send_window(address, windowStore)
#Resend the data packet if no ack received and slide the window on receiving the ack
while not windowStore.empty():
try:
_ = ACKSTORE[address].get(timeout=util.TIME_OUT)
_ = windowStore.get()
#If all the packets have been catered for we wont go in this block
if packetIndex < len(chunks):
sendPacket = util.make_packet("data", sequenceNumber, chunks[packetIndex])
self.sock.sendto(sendPacket.encode("utf-8"), address)
windowStore.put(sendPacket)
packetIndex += 1
sequenceNumber += 1
retransmissions = 0
EXPECTEDACK[address] += 1
except:
if retransmissions == util.NUM_OF_RETRANSMISSIONS:
break
retransmissions += 1
self.send_window(address, windowStore)
#End packet functionality
sendPacket = util.make_packet("end", sequenceNumber,)
self.sock.sendto(sendPacket.encode("utf-8"), address)
#Resend the start packet if no ack received
while True:
try:
_ = ACKSTORE[address].get(timeout=util.TIME_OUT)
break
except:
if retransmissions == util.NUM_OF_RETRANSMISSIONS:
break
retransmissions += 1
self.sock.sendto(sendPacket.encode("utf-8"), address)
def start(self):
'''
Main Loop is here
Start by sending the server a JOIN message.
Waits for userinput and then process it
'''
#joins the server
self.join()
# handle commands in this loop
while True:
cmd = input()
cmd = cmd.split()
cmd_type = cmd[0]
if cmd_type == "list":
req = util.make_message("request_users_list", 2)
self.send_tcp(req)
elif cmd_type == "quit":
req = util.make_message("disconnect", 1, self.name)
self.send_tcp(req)
print("quitting")
sys.exit()
elif cmd_type == "msg":
try:
tmp = self.extract_message(cmd)
req = util.make_message("send_message", 4, tmp)
chunks = []
#if the length is less than 1400 just send the packet
if len(req) <= 1400:
self.send_tcp(req)
else:
# make chunks of size 1400
size = 1400
numberOfPackets = int(len(req) / size) + 1
#slice the message in 1400 packets
for i in range(0, numberOfPackets):
chunks.append(req[i * size:(i + 1) * size])
tmp_str = ""
tmp_str = chunks[0]
tmp_str = tmp_str[18:]
chunks[0] = util.make_message("send_message", 4,
tmp_str)
#call the send window function
self.send_window_tcp(chunks)
except:
print("arguments to \"msg\" are incomplete")
print("enter \"help\"")
elif cmd_type == "file":
try:
tmp = self.extract_file(cmd)
req = util.make_message("send_file", 4, tmp)
chunks = []
#if the length is less than 1400 just send the packet
if len(req) <= 1400:
self.send_tcp(req)
else:
size = 1400
# make chunks of size 1400
numberOfPackets = int(len(req) / size) + 1
#slice the message in 1400 packets
for i in range(0, numberOfPackets):
chunks.append(req[i * size:(i + 1) * size])
tmp_str = ""
tmp_str = chunks[0]
tmp_str = tmp_str[15:]
chunks[0] = util.make_message("send_file", 4, tmp_str)
#call the send window function
self.send_window_tcp(chunks)
except:
print("arguments to \"file\" incomplete")
print("enter \"help\"")
elif cmd_type == "help":
print(
"Message:\nFormat: msg <number_of_users> <username1> <username2> ... <message>"
)
print(
"------------------------------------------------------------------------------"
)
print(
"File:\nFormat: file <number_of_users> <username1> <username2> ... <file_name>"
)
print(
"------------------------------------------------------------------------------"
)
print("Available Users:\nInput: list")
print(
"------------------------------------------------------------------------------"
)
print("Quit:\nInput: quit")
print(
"------------------------------------------------------------------------------"
)
print("Help:\nInput: help")
print(
"------------------------------------------------------------------------------"
)
else:
print("incorrect userinput format")
print("enter \"help\"")
def processAndServe(self, addr):
'''
this function always runs in a seperate thread to
avoid blocking the socket
'''
#some constants
MAX_NUM_CLIENTS = 10
ERR_SERVER_FULL = "err_server_full 0"
ERR_USERNAME_UNAVAILABLE = "err_username_unavailable 0"
ERR_UNKNOWN_MESSAGE = "err_unknown_message 0"
packet_number = random.randint(0, 40000)
all_packets = self.getPacketsFromBuffer(addr)
message = self.construct_message(all_packets)
msg_unsplit = message
msg = message.split()
msg_cmd = msg[0]
res = ''
#process the data and outpur
if msg_cmd == "join":
if len(self.clients) < MAX_NUM_CLIENTS:
duplicate_flag = False
for user in self.clients:
if user == msg[2]:
duplicate_flag = True
if duplicate_flag:
res = ERR_USERNAME_UNAVAILABLE
self.send_tcp(res, addr, packet_number)
print("disconnected: username unavailable")
if not duplicate_flag:
self.clients[msg[2]] = addr
print("join:", msg[2])
else:
res = ERR_SERVER_FULL
self.send_tcp(res, addr, packet_number)
print("disconnected: server full")
elif msg_cmd == "request_users_list":
total_clients = len(self.clients)
all_clients = ""
for u in sorted(self.clients.keys()):
all_clients = all_clients + u + " "
all_clients = all_clients.strip()
tmp = str(total_clients) + " " + all_clients
for s in self.clients:
if self.clients[s] == addr:
res = util.make_message("response_users_list", 3, tmp)
self.send_tcp(res, addr, packet_number)
sender = s
print("request_users_list:", sender)
elif msg_cmd == "disconnect":
client_to_disconnect = msg[2]
if client_to_disconnect in self.clients:
self.clients.pop(client_to_disconnect)
print("disconnected:", client_to_disconnect)
elif msg_cmd == "send_message":
res, recievers, sender = self.extract_message(msg, addr)
chunks = []
if len(res) <= 1400:
chunks.append(res)
print("msg:", sender)
for r in recievers:
if not r in self.clients:
print("msg:", sender, "to non-existent user", r)
else:
self.send_window_tcp(chunks, self.clients[r],
packet_number)
else:
numberOfPackets = int(len(res) / 1400) + 1
size = 1400
for i in range(0, numberOfPackets):
chunks.append(res[i * size:(i + 1) * size])
tmp_str = ""
tmp_str = chunks[0]
tmp_str = tmp_str[21:]
chunks[0] = util.make_message("forward_message", 4, tmp_str)
for r in recievers:
if not r in self.clients:
print("msg:", sender, "to non-existent user", r)
else:
self.send_window_tcp(chunks, self.clients[r],
packet_number)
elif msg_cmd == "send_file":
res, recievers, sender = self.extract_file(msg, msg_unsplit, addr)
chunks = []
print("file:", sender)
if len(res) <= 1400:
chunks.append(res)
for r in recievers:
if not r in self.clients:
print("file:", sender, "to non-existent user", r)
else:
self.send_window_tcp(chunks, self.clients[r],
packet_number)
packet_number = packet_number + len(chunks) + 2
else:
numberOfPackets = int(len(res) / 1400) + 1
size = 1400
for i in range(0, numberOfPackets):
chunks.append(res[i * size:(i + 1) * size])
tmp_str = ""
tmp_str = chunks[0]
tmp_str = tmp_str[18:]
chunks[0] = util.make_message("forward_file", 4, tmp_str)
for r in recievers:
if not r in self.clients:
print("file:", sender, "to non-existent user", r)
else:
self.send_window_tcp(chunks, self.clients[r],
packet_number)
packet_number = packet_number + len(chunks) + 2
else:
res_packet = util.make_packet("data", 0, ERR_UNKNOWN_MESSAGE)
self.send_res(res_packet, addr)
for s in self.clients:
if self.clients[s] == addr:
print("disconnected:", s, "sent unknown command")
self.clients.pop(s)
break
self.resetBuffer(addr)
sys.exit()
def start(self):
'''
Main Loop is here
Start by sending the server a JOIN message.
Waits for userinput and then process it
'''
#SOCK_DGRAM means UDP
'''soc = socket.socket( type=socket.SOCK_DGRAM)'''
self.start_comms()
# print(is_ack)
first_run = True
while not self.comms_completed:
if not self.q.empty():
is_ack = self.q.get(timeout=util.TIME_OUT)
if is_ack and first_run:
catch_message = util.make_message('join', 1, self.name)
catch_packet = util.make_packet('data',
int(self.seq_no) + 1,
msg=catch_message)
self.seq_no = int(self.seq_no) + 1
self.sock.sendto(catch_packet.encode("utf-8"),
("localhost", self.server_port))
is_ack = False
first_run = False
self.comms_completed = True
if self.comms_completed:
self.end_comms()
while True:
# In python3 you can only send bytes over connection, encode and decode inter-convert between bytes and string
to_send = input()
split = to_send.split(' ')
if split[0] == 'list':
self.start_comms()
catch_message = util.make_message('request_users_list', 2)
self.comms_handler(catch_message)
self.end_comms()
elif split[0] == 'msg':
catch_message = util.make_message('send_message', 4,
' '.join(split[1:]))
self.start_comms()
print(self.comms_completed)
self.comms_handler(catch_message)
self.end_comms()
elif split[0] == 'help':
print('Your options are the following:')
print(
'\t1) msg <number_of_users> <username1> <username2> … <message>'
)
print('\t2) list')
print(
'\t3) file <number_of_users> <username1> <username2> … <file_name>'
)
print('\t4) quit')
elif split[0] == 'quit':
print('quitting', end='')
catch_message = util.make_message('disconnect', 1,
self.name)
self.start_comms()
print(self.comms_completed)
self.comms_handler(catch_message)
self.end_comms()
return
elif split[0] == 'file':
try:
file_name = split[-1]
f = open(file_name)
catch_message = util.make_message(
'send_file', 4,
' '.join(split[1:]) + ' ' + f.read())
self.start_comms()
print(self.comms_completed)
self.comms_handler(catch_message)
self.end_comms()
except:
print('incorrect userinput format')
else:
print('incorrect userinput format')
