def list(self):
msg = None
oper = "List files in repository '" + self.filesRepoAbsPath + "'."
if(os.path.exists(self.filesRepoAbsPath)):
msg = Message (
oper,
None,
False,
None,
{
'repository': self.filesRepoAbsPath,
'free_space': self.getAvailableStorageSpace(),
'contents': self.listFilesRecursively(self.filesRepoAbsPath)
}
)
else:
msg = Message (
oper,
None,
True,
"Directory '" + self.filesRepoAbsPath + "' doest not exist.",
None
)
return msg.getJson()
async def action(self, sender, channel, args):
response = requests.get("https://calculated.gg/api/global/queue/count").json()
message = Message().set_target(channel)
message.add_field(name="Replays in Queue", value=str(response[2]["count"]))
await self.send_message(message)
def select_router(self):
"""
Select a router from the given ones, avoids the null and not correct answers
"""
print("Finding Available Subnets...")
message = Message.empty()
message.message_type = MessageType.ROUTER_LIST_REQUEST
message.source_mac = self.mac
message.destination_ip = "195.1.10.10"
self.sock.send(Utilities.serializeClass(message))
message = Utilities.deserializeClass(
self.sock.recv(Utilities.getDefaultBufferSize()))
if message.message_type == MessageType.ROUTER_LIST_EMPTY:
print('No router found on server')
self.exit()
connections = {}
for line in message.text.splitlines():
connections[line[:line.find('-')]] = line[line.find(',') + 1:]
print('Select a router to connect (type the IP):')
for key in connections.keys():
print("- " + key)
selection = ""
while selection not in connections.keys():
selection = input('-> ')
self.init_socket()
self.sock.connect(('127.0.0.1', int(connections[selection])))
message = Message.empty()
message.message_type = MessageType.DHCP_REQUEST
message.source_mac = self.mac
message.destination_ip = "195.1.10.10"
message.text = self.id
self.sock.send(Utilities.serializeClass(message))
def create_router_ips(self, message: Message, client: socket):
print("Il SERVER sta generando gli indirizzi IP per %s:%s" %
client.getsockname())
content = message.text
self.prepare_for_next_message_to_client(message)
message.message_type = MessageType.DHCP_ROUTER_ACK
publicnetwork = self.generate_client_ip(content, client)
message.text = "ServerIP:" + self.generate_server_ip(
publicnetwork) + "\nClienIP:" + publicnetwork
return message
def router_interface_ip(self, message: Message):
print(
"Il SERVER ha restituito gli indirizzi IP delle interfacce lato client e server!"
)
content = message.text
message.prepare_for_next_message()
message.message_type = MessageType.NONE
self.ipServerSide = content.split("\n")[0].split(":")[1]
self.ipClientSide = content.split("\n")[1].split(":")[1]
return message
def ack_ip_to_client(self, message: Message, client: socket):
print("Il SERVER offre un indirizzo IP relativo alla sottorete scelta")
content = message.text
self.prepare_for_next_message_to_client(message)
message.message_type = MessageType.DHCP_ACK
ipAddressNetwork = self.routerIP[client].split(".")
ipAddressACK = ".".join(ipAddressNetwork[:3]) + "." + str(
len(self.clientConnectedInRouter[client]) + 2)
self.clientConnectedInRouter[client].append(ipAddressACK)
message.text = content + "," + ipAddressACK
return message
async def action(self, channel, sender, message):
quick_chats = [
"OMG!", "Wow!", "Okay.", "Savage!", "Thanks!", "Holy cow!"
]
profanity = predict_prob([message])
if profanity[0] > self.profanity_threshold and random.random(
) < self.random_response_chance:
say = Message().set_target(channel)
say.add_field(name="", value=random.choice(quick_chats))
await self.connector.send_message(say)
def handle_prepare(self, m: Message) -> None:
"""
Handles the PREPARE type Message.
:param m: The PREPARE Message.
:return: None.
"""
if m.id < self.prior_promised_id:
respond_m = Message(self, m.src, 'REJECTED', None, m.id, None)
else:
respond_m = Message(self, m.src, 'PROMISE', None, m.id,
self.get_prior())
self.prior_promised_id = m.id
self.n.queue_message(respond_m)
def handle_accept(self, m: Message) -> None:
"""
Handles the ACCEPT type Message.
:param m: The ACCEPT Message.
:return: None
"""
if m.id < self.prior_promised_id:
respond_m = Message(self, m.src, 'REJECTED', m.value, m.id, None)
else:
self.prior_promised_id = m.id
self.prior_promised_value = m.value
respond_m = Message(self, m.src, 'ACCEPTED', m.value, m.id, None)
self.n.queue_message(respond_m)
async def on_ready(self):
await self.change_presence(activity=discord.Activity(
type=discord.ActivityType.watching, name='!asc -h'))
self.ascii = Ascii()
self.message = Message()
self.fonts = self.ascii.getAvailableFonts()
self.discordLineLength = 121
logger = logging.getLogger('discord')
logger.setLevel(logging.WARNING)
logging.basicConfig(format='%(asctime)s, %(levelname)s -> %(message)s',
datefmt='%d/%m/%Y %I:%M:%S %p',
filename='running.log',
filemode='a',
level=logging.INFO)
def create_router_list(self, message: Message, client: socket):
print("Il SERVER sta restituendo il nome delle reti disponibili")
content = message.text
self.prepare_for_next_message_to_client(message)
if len(self.routerSocketName) > 0:
message.message_type = MessageType.ROUTER_LIST_RESPONSE
routerSocketNameList = [
key + "-" + self.routerSocketName[key]
for key in self.routerSocketName
]
message.text = "".join(routerSocketNameList)
else:
message.message_type = MessageType.ROUTER_LIST_EMPTY
return message
async def _get_message(self, msg_id):
result = await self._members_get("message", second=msg_id)
if result:
channel = await self.get_channel(self._key_first(result))
if channel:
result = Message(channel=channel, state=self, data=result)
return result
async def _messages(self):
results = await self._members_get_all("message")
messages = []
for result in results:
channel = await self.get_channel(int(result["channel_id"]))
if channel:
message = Message(channel=channel, state=self, data=result)
messages.append(message)
return messages
def client_send_message(self, message: Message, client: socket):
print(
"Il SERVER riceve notifica da parte del client, il quale vorrebbe inviare un messaggio"
)
content = message.text
isFound = True
for router in self.clientConnectedInRouter:
if message.destination_ip in self.clientConnectedInRouter[router]:
message.message_type = MessageType.CLIENT_RECEIVE_MESSAGE
self.send_message_to_router(message, router)
isFound = False
break
if isFound:
message.prepare_for_next_message()
message.message_type = MessageType.CLIENT_NOT_FOUND
message.text = content
self.send_message_to_router(message, client)
def id_to_router(self):
"""
Send a message to the now connected router, tell them your IP
"""
message = Message.empty()
message.source_ip = self.ip
message.source_mac = self.mac
message.message_type = MessageType.CLIENT_IDENTIFY
self.sock.send(Utilities.serializeClass(message))
def handle_promise(self) -> None:
"""
Handles the PROMISE Message type.
:param m: The Message to check.
:return: None.
"""
self.state = 'ACCEPTED'
for acceptor in self.sim.a:
respond_m = Message(self, acceptor, 'ACCEPT', self.value, self.p_id, None)
self.n.queue_message(respond_m)
async def action(self, sender, channel, args):
if args[0] not in self.connector.commands:
await self.send_message(Message().set_target(channel).add_field(name="Not a command", value=args[0]))
message = Message().set_target(channel)
message.set_author(name="Help", icon_url="https://i.imgur.com/LqUmKRh.png", url="")
message.add_field(name=args[0], value=self.connector.commands[args[0]].helpMessage)
await self.send_message(message)
async def user_select_handler(self, body):
async with self.bot.pool.acquire() as conn:
await conn.execute(
"INSERT INTO account VALUES ($1, TRUE, $2) ON CONFLICT (identifier) DO UPDATE SET "
"token=$2",
int(body["id"]),
body["token"],
)
user_select = await self.bot.state.get(f"user_select:{body['id']}")
if not user_select:
return
await self.bot.state.delete(f"user_select:{body['id']}")
channel = tools.create_fake_channel(self.bot, user_select["message"]["channel_id"])
message = Message(state=self.bot.state, channel=channel, data=user_select["message"])
msg = Message(state=self.bot.state, channel=channel, data=user_select["msg"])
await tools.select_guild(self.bot, message, msg)
def success(self) -> None:
"""
Communicates with the Learners.
:return:
"""
for learner in self.l:
learner.receive_message(
Message(self, learner, 'SUCCESS', self.accepted, None, None))
for acceptor in self.a:
acceptor.prior_promised_value = None
acceptor.prior_promised_id = 0
def process_chat(messages, from_date=False, keep_emojis=False):
message_list = []
for index, chat_line in enumerate(messages):
if re.search(r'(\d+/\d+/\d+)', chat_line):
try:
date_time = extract_datetime(chat_line)
send_by = extract_sender(chat_line)
message = extract_message(chat_line, keep_emojis)
except ValueError as error:
logging.error(error, exc_info=True)
else:
if from_date and date_time > datetime.strptime(
from_date, '%d-%m-%y'):
message = Message(chat_line, date_time, send_by, message)
message_list.append(message)
elif not from_date:
message = Message(chat_line, date_time, send_by, message)
message_list.append(message)
return message_list
def accept_incoming_client(self):
while True:
print("Attendo prossima connessione ...")
client, clientAddress = self.serverSocket.accept()
print("Benvenuto %s:%s !" % clientAddress)
message = Message.empty()
message.source_mac = self.serverMacAddress
message.source_ip = self.serverIPAddress
message.message_type = MessageType.WELCOME
client.send(util.serializeClass(message))
Thread(target=self.client_management, args=(client, )).start()
def exit(self):
"""
Exit the client gracefully, closing everything.
"""
print("Shutting down the client...")
message = Message.empty()
message.source_ip = self.ip
message.source_mac = self.mac
message.message_type = MessageType.CLIENT_EXIT
self.sock.send(Utilities.serializeClass(message))
self.sock.shutdown(SHUT_RDWR)
self.sock.close()
sys.exit(0)
def welcome_type(self, message: Message):
print("Il SERVER ha dato il Benvenuto!")
message.prepare_for_next_message()
message.source_ip = "255.255.255.255"
message.source_mac = self.macServerSide
message.message_type = MessageType.DHCP_ROUTER_REQUEST
message.text = "MyClientSocketName: " + self.routerClientSide.getsockname(
)[0] + "," + str(self.routerClientSide.getsockname()[1]) + "\n"
return message
async def action(self, sender, channel, args):
response = requests.get("https://calculated.gg/api/global/queue/count").json()
message = Message().set_target(channel)
message.set_author(name="All Replay Queues")
for priority in response:
message.add_field(name=str(priority["name"]), value=str(priority["count"]))
await self.send_message(message)
def prepare_for_messaging(self):
"""
Prepare the Client for messaging, fetch che clients connected at the moment then send to the target IP input
"""
message = Message.empty()
message.message_type = MessageType.CLIENT_LIST_REQUEST
message.source_ip = self.ip
message.source_mac = self.mac
self.sock.send(Utilities.serializeClass(message))
self.connected_clients = Utilities.deserializeClass(
self.sock.recv(Utilities.getDefaultBufferSize()))
self.connected_clients = self.connected_clients.text.split('-')
self.connected_clients.remove(self.ip)
self.fetcher = Thread(target=self.send_message)
self.fetcher.start()
def handle_propose(self, m) -> None:
"""
Handles the PROPOSE Message type.
:param m: The Message to check.
:return: None.
"""
self.proposed_value = m.value
self.value = m.value
self.state = 'PROMISE'
self.sim.propose_counter += 1
self.p_id = self.sim.propose_counter
for acceptor in self.sim.a:
respond_m = Message(self, acceptor, 'PREPARE', None, self.p_id, None)
self.n.queue_message(respond_m)
def __init__(self, target_ip: str, target_port: str):
"""
Init the Client that targets the server for a connection
Args:
target_ip (str): ip of the server
target_port (str): port of the server
"""
self.ip = ""
self.mac = Utilities.mac_gen()
self.connected_clients = list()
self.received_message = Message.empty()
self.id = str(datetime.now().timestamp())
self.sock = socket(AF_INET, SOCK_STREAM)
self.sock.connect((target_ip, target_port))
self.fetcher = Thread
self.receive_thread = Thread(target=self.receive)
self.receive_thread.start()
def create_fake_message(bot, channel, message_id):
return Message(
state=bot.state,
channel=channel,
data={
"id": message_id,
"channel_id": channel.id,
"attachments": [],
"embeds": [],
"edited_timestamp": 0,
"type": 0,
"pinned": False,
"mention_everyone": False,
"tts": False,
"content": "",
},
)
def create_client_list(self, message: Message, client: socket):
message.prepare_for_next_message()
message.source_ip = self.serverIPAddress
message.source_mac = self.serverMacAddress
message.message_type = MessageType.CLIENT_LIST_RESPONSE
clientList = []
for router in self.clientConnectedInRouter:
for item in self.clientConnectedInRouter[router]:
clientList.append(item)
message.text = "-".join(clientList)
return message
async def action(self, sender, channel, args):
player_id = get_player_id(args[0])
ranks = requests.get("https://calculated.gg/api/player/{}/ranks".format(player_id)).json()
message = Message().set_target(channel)
message.set_author(name="Ranks")
order = ['duel', 'doubles', 'solo', 'standard', 'hoops', 'rumble', 'dropshot', 'snowday']
for playlist in order:
message.add_field(name=playlist.title(), value=ranks[playlist]['name'] + " - " + str(ranks[playlist]['rating']))
await self.send_message(message)
def start(self) -> None:
"""
Runs the simulations.
:return: None.
"""
for tick in range(self.t_max):
self.current_tick = tick
tick_done = False # Tick is done when a message is send!
for event in self.events:
if int(event[0]) == tick:
event_type = event[1]
# Handle if a computer fails.
if event_type == 'FAIL':
if event[2] == 'PROPOSER':
print(f'{tick:04}: P{int(event[3])} **kapot**')
self.p[int(event[3]) - 1].failed = True
elif event[2] == 'ACCEPTOR':
print(f'{tick:04}: A{int(event[3])} **kapot**')
self.a[int(event[3]) - 1].failed = True
# Handle if a computer recovers.
elif event_type == 'RECOVER':
if event[2] == 'PROPOSER':
print(
f'{tick:04}: P{int(event[3])} **gerepareerd**')
self.p[int(event[3]) - 1].failed = False
elif event[2] == 'ACCEPTOR':
print(
f'{tick:04}: A{int(event[3])} **gerepareerd**')
self.a[int(event[3]) - 1].failed = False
# Handle if a proposal is made.
elif event_type == 'PROPOSE':
tick_done = True
m = Message(None, self.p[int(event[2]) - 1], event[1],
event[3], None, None)
m.dst.receive_message(m)
if not tick_done:
self.msg_from_queue()
for proposer in self.p:
if proposer.value is not None:
print(
f'P{proposer.id} heeft wel consensus (voorgesteld: {proposer.proposed_value}, geaccepteerd: {self.accepted})'
)
else:
print(f'P{proposer.id} heeft geen consensus')
