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