async def emojis(self, ctx): """ List currently cached emojis. Enclose the name (case sensitive) of cached emoji in `:`s to auto-load it into a message """ settings = self.bot.settings[ctx.guild] if not settings.manage_emojis: message = f"The emoji manager is disabled, you can enable it in `{settings.command_prefix}settings`" await ctx.send(message) else: # message = '```\n • ' + '\n • '.join(self.managers[ctx.guild.id].list_unloaded()) + '```\n' logger.debug("generating list image") file = self.managers[ctx.guild.id].list_unloaded() if file is not None: logger.debug("file is good") message = "Enclose the name (case sensitive) of cached emoji in `:`s to auto-load it into a message" # msg = await ctx.send(message, file=discord.File(file, "cool.png")) try: data = await self.bot.manager_client.publish_file( iter([message_type.File(file=file.getvalue())])) except Exception: logger.info( f"Shard {self.bot.shard_id} failed to upload emoji") await ctx.send("Failed to generate cached emoji preview") return em = discord.Embed(title="Cached Emojis", description=ctx.guild.name) # em.set_image(url=msg.attachments[0].url) em.set_image(url=data.url) em.color = 0x7b8fb7 em.set_footer(text=message) await ctx.send(embed=em) else: await ctx.send("No cached emoji")
async def emojis(self, ctx): """ List currently cached emojis. Enclose the name (case sensitive) of cached emoji in `:`s to auto-load it into a message """ settings = self.bot.settings[ctx.guild] if not settings.manage_emojis: message = f"The emoji manager is disabled, you can enable it in `{settings.command_prefix}settings`" await ctx.send(message) else: # message = '```\n • ' + '\n • '.join(self.managers[ctx.guild.id].list_unloaded()) + '```\n' logger.debug("generating list image") file = self.managers[ctx.guild.id].list_unloaded() if file is not None: logger.debug("file is good") message = "Enclose the name (case sensitive) of cached emoji in `:`s to auto-load it into a message" # msg = await ctx.send(message, file=discord.File(file, "cool.png")) data, _ = await self.bot.manager_client.publish_file( data=base64.b64encode(file.getvalue()).decode('ascii')) em = discord.Embed(title="Cached Emojis", description=ctx.guild.name) # em.set_image(url=msg.attachments[0].url) em.set_image(url=data['url']) em.color = 0x7b8fb7 em.set_footer(text=message) await ctx.send(embed=em) else: await ctx.send("No cached emoji")
def call(self, method: str, *args, routing_key: str = None, **kwargs): """Remotely call a method :param method: name of method to call :param *args: arguments to pass to method :param routing_key: queue to route to in rabbitmq :param **kwargs: keyword args to pass to method """ assert routing_key is not None with self.hb_lock: logger.debug(f'calling {method} on queue: {routing_key}') self.resp = None self.corr_id = str(uuid.uuid4()) self.channel.basic_publish(exchange='', routing_key=routing_key, properties=pika.BasicProperties( reply_to=self.callback_queue, correlation_id=self.corr_id, ), body=json.dumps({ 'method': method, 'args': args, 'kwargs': kwargs })) while self.resp is None: self.connection.process_data_events() return self.resp, self.status_code
def login_with_hash(self, ipaddress, port, hashes): user_hash_pair_list = [] for hash in hashes: user_hash_pair_list.append(hash.strip().split(",")) for user_hash_pair in user_hash_pair_list: try: fp = SMBConnection('*SMBSERVER', ipaddress, sess_port=int(port), timeout=self.timeout) except Exception as E: logger.debug('ConnectException: {} {} {}'.format(E, ipaddress, port)) return try: if fp.login(user_hash_pair[1], "", domain=user_hash_pair[0], lmhash=user_hash_pair[2].split(":")[0], nthash=user_hash_pair[2].split(":")[1]): if fp.isGuestSession() == 0: log_success("SMB", ipaddress, port, [ "{}/{}".format(user_hash_pair[0], user_hash_pair[1]), user_hash_pair[2] ]) except Exception as E: logger.debug('AuthenticationException: %s' % E) finally: fp.getSMBServer().get_socket().close()
def login(self, ipaddress, port, user_passwd_pair_list): for user_passwd_pair in user_passwd_pair_list: try: fp = SMBConnection('*SMBSERVER', ipaddress, sess_port=int(port), timeout=self.timeout) except Exception as E: logger.debug('ConnectException: {} {} {}'.format(E, ipaddress, port)) return try: if "\\" in user_passwd_pair[0]: domain = user_passwd_pair[0].split("\\")[0] username = user_passwd_pair[0].split("\\")[1] else: domain = "" username = user_passwd_pair[0] if fp.login(username, user_passwd_pair[1], domain=domain): if fp.isGuestSession() == 0: if domain == "": log_success("SMB", ipaddress, port, user_passwd_pair) else: log_success("SMB", ipaddress, port, ["{}\\{}".format(domain, username), user_passwd_pair[1]]) except Exception as E: logger.debug('AuthenticationException: %s' % E) finally: fp.getSMBServer().get_socket().close()
def login(self, ipaddress, port, user_passwd_pair_list): for user_passwd_pair in user_passwd_pair_list: s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) try: s.settimeout(self.timeout) s.connect((ipaddress, port)) except Exception as E: logger.debug('ConnectException: {} {} {}'.format(E, ipaddress, port)) return finally: s.close() try: conn = psycopg2.connect(host=ipaddress, port=int(port), user=user_passwd_pair[0], password=user_passwd_pair[1], connect_timeout=self.timeout ) log_success("PostgreSQL", ipaddress, port, user_passwd_pair) conn.close() except Exception as E: logger.debug('AuthenticationException: %s' % E) continue finally: pass
def __init__(self, **kwargs): self.session = get_session() self.asyncpg_wrapper = AsyncConnWrapper() self.deletable_messages = [] self.hoarfrost_gen = HoarFrostGenerator() logger.debug("registering with manager...") manager_client = grpc_client.get_blocking_client('manager:50051') while True: try: shard_info = manager_client.register(message.RegisterRequest()) break except Exception: logger.info("Trying to get shard id from manager") time.sleep(3) self.shard_id = shard_info.shard_id shard_dict = { 'shard_id': shard_info.shard_id, 'shard_count': shard_info.shard_count } logger.info(f"Got shard_id {self.shard_id}") kwargs.update(shard_dict) super().__init__(**kwargs)
def __init__(self, bot): logger.debug("creating new smart player") self.bot = bot self.q = deque() self.voice = None self.name = '' self.playing_file = False
def serve(manager): server = grpc.server(ThreadPoolExecutor(max_workers=20), options=grpc_options) manager_grpc.add_ManagerServicer_to_server(manager, server) server.add_insecure_port("0.0.0.0:50051") server.start() logger.debug("gRPC server started") server.wait_for_termination()
async def cache_emoji(self, emoji: ArchitusEmoji) -> None: """remove an emoji from the guild""" discord_emoji = self.bot.get_emoji(emoji.discord_id) if discord_emoji is None: return logger.debug(f"cache {emoji} from {self.guild.name}") await discord_emoji.delete(reason="cached") emoji.cache()
def login(self, ipaddress, port, user_passwd_pair_list): for user_passwd_pair in user_passwd_pair_list: try: flag = check_rdp(ipaddress, port, user_passwd_pair[0], user_passwd_pair[1], "", timeout=self.timeout) if flag: log_success("RDP", ipaddress, port, user_passwd_pair) except Exception as E: logger.debug('ConnectException: {} {} {}'.format(E, ipaddress, port)) return
def member_to_dict(member: discord.Member) -> dict: params = ('id', 'name', 'nick', 'avatar', 'discriminator') data = {p: getattr(member, p) for p in params} data['id'] = str(data['id']) data['roles'] = [str(r.id) for r in member.roles] data['color'] = str(member.color) data['joined_at'] = member.joined_at.isoformat() logger.debug(data) return data
def get_blocking_client(server): while True: try: channel = grpc.insecure_channel(server, options=grpc_options) stub = manager_pb2_grpc.ManagerStub(channel) return SyncRPCClient(stub) except Exception as e: logger.debug(f"Waiting to connect to gRPC {e}") time.sleep(3)
async def poll_for_async_connection(loop): name = socket.gethostname() while True: try: return await connect("amqp://*****:*****@rabbit/", loop=loop) except (ConnectionError, Exception) as e: logger.debug(f"{name} is waiting to connect to rabbit: {e}") await asyncio.sleep(3) finally: logger.debug(f"{name} successfully connected to rabbit")
async def skip(self): if self.voice is None: logger.debug("no voice") return if (len(self.q) < 1): logger.debug("len(q) < 1") await self.voice.disconnect() return '' self.stop() return self.q[-1].title
async def add_emoji(self, emoji: ArchitusEmoji) -> None: """Inserts an emoji into the guild, making space if necessary does not check for duplicates """ logger.debug(f"added emoji: {emoji}") while len(self.guild_emojis) >= self.max_emojis: await self.cache_worst_emoji() self.emojis.append(emoji) await self._insert_into_db(emoji) self.sort()
async def download_emoji(emoji: discord.Emoji) -> io.BytesIO: async with ClientSession() as session: async with session.get(str(emoji.url)) as resp: if resp.status == 200: buf = io.BytesIO() buf.write(await resp.read()) buf.seek(0) return buf logger.debug("API gave unexpected response (%d) emoji not saved" % resp.status) return None
async def on_emoji_renamed(self, before, after) -> None: """updates our version of an emoji that just got renamed""" logger.debug(f'renamed emoji {before.name}->{after.name}') e = next((e for e in self.emojis if before.id == e.discord_id), None) if e is None: logger.warning( f"someone renamed an emoji that I don't know about! {after.name}:{after.id}" ) else: e.update_from_discord(after) await self._update_emojis_db((e, ))
def connect(self, host, port): self.fp = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.fp.settimeout(self.timeout) self.fp.connect((host, port)) resp = self.fp.recv(99) # banner logger.debug('banner: %r' % resp) self.version = resp[:11] if len(resp) > 12: raise VNC_Error('%s %r' % (self.version, resp[12:])) return self.version
def login(self, ipaddress, port, user_passwd_pair_list): for user_passwd_pair in user_passwd_pair_list: try: fp = pymysql.connect(host=ipaddress, port=int(port), user=user_passwd_pair[0], passwd=user_passwd_pair[1], connect_timeout=self.timeout) fp.get_server_info() log_success("MYSQL", ipaddress, port, user_passwd_pair) except Exception as E: logger.debug('AuthenticationException: %s' % E) continue finally: pass
def guild_update(self, request_iterator, context): """Update the manager with the latest information about a shard's guilds""" guilds = [] for guild in request_iterator: guilds.append(guild) if len(guilds) == 0: return message.UpdateResponse() logger.debug( f"Received guild list from shard {guilds[0].shard_id + 1} of {len(guilds)} guilds" ) self.store[guilds[0].shard_id] = guilds return message.UpdateResponse()
def get_async_client(server): stub = None while True: try: channel = grpc.insecure_channel(server, options=grpc_options) stub = manager_pb2_grpc.ManagerStub(channel) logger.debug("Connected to gRPC") break except Exception: logger.debug("Waiting to connect to gRPC") time.sleep(3) return AsyncRPCClient(stub)
def login(self, ipaddress, port, user_passwd_pair_list): v = VNC(self.timeout) for user_passwd_pair in user_passwd_pair_list: try: version = v.connect(ipaddress, int(port)) if v.login(user_passwd_pair[1]): log_success("VNC", ipaddress, port, user_passwd_pair) return except Exception as E: logger.debug('AuthenticationException: %s' % E) continue finally: pass
def login_with_pool(self, ipaddress, port, user_passwd_pair_list, pool_size=10): for user_passwd_pair in user_passwd_pair_list: try: client = ParallelSSHClient(hosts=[ipaddress], port=port, user=user_passwd_pair[0], password=user_passwd_pair[1], num_retries=0, timeout=self.timeout, pool_size=pool_size) output = client.run_command('whoami', timeout=self.timeout) log_success("SSH", ipaddress, port, user_passwd_pair) except Exception as E: logger.debug('AuthenticationException: ssh') continue finally: pass
async def on_connect(self, sid: str, environ: dict): logger.debug(f"{environ['REMOTE_ADDR']} has connected with sid: {sid}") request = environ['aiohttp.request'] try: jwt = JWT(token=request.cookies['token']) except (InvalidTokenError, KeyError): logger.info( "No valid token found, logging into unprivileged gateway...") else: logger.info("Found valid token, logging into elevated gateway...") sio.enter_room(sid, f"{sid}_auth") async with sio.session(sid) as session: session['jwt'] = jwt
async def notify_deletion(self, emoji: discord.Emoji) -> None: """send a dm to whomever's emoji we just deleted""" user = emoji.user if user is None: logger.debug("I don't know who created this emoji") return try: await user.send( f"**Notice:** your emoji has been deleted from {self.guild.name} because it is a duplicate.\n" f"Type the emoji name as you normally would (`:{emoji.name}:`) if it was cached.\n" f"emoji: {emoji.url}") except Exception: logger.exception('')
async def bump_emoji(self, emoji: ArchitusEmoji) -> ArchitusEmoji: """boost an emoji's priority, while lowering all others""" if emoji.priority >= 100: return emoji logger.debug(f"bumping {emoji}") penalty = 0.5 / len(self.emojis) emoji.priority += 0.5 + penalty for e in self.emojis: if e.priority <= -100: continue e.priority -= penalty return await self.load_emoji(emoji)
async def play(self): if (self.voice is None or len(self.q) == 0): return '' if (self.voice and self.voice.is_playing()): return await self.skip() self.stop() song = self.q.pop() url = song.url self.name = song.title logger.debug("starting " + url) if ('spotify' in url): url = await self.spotify_to_youtube(url) self.name = url['name'] url = url['url'] opts = { 'prefer_ffmpeg': True, 'format': 'bestaudio/best', 'outtmpl': '%(extractor)s-%(id)s-%(title)s.%(ext)s', 'restrictfilenames': True, 'noplaylist': True, 'nocheckcertificate': True, 'ignoreerrors': False, 'logtostderr': False, 'quiet': True, 'no_warnings': True, 'default_search': 'auto', 'source_address': '0.0.0.0' # bind to ipv4 since ipv6 addresses cause issues sometimes } ffmpeg_options = { 'options': '-vn -reconnect 1 -reconnect_streamed 1 -reconnect_delay_max 5' } ydl = youtube_dl.YoutubeDL(opts) func = functools.partial(ydl.extract_info, url, download=True) info = await self.bot.loop.run_in_executor(None, func) if "entries" in info: info = info['entries'][0] # download_url = info['url'] download_url = ydl.prepare_filename(info) logger.debug(f"downloading url {download_url}") self.voice.play(discord.FFmpegPCMAudio(download_url, **ffmpeg_options), after=self.agane) # await asyncio.sleep(2) # os.remove(download_url) return self.name
async def cache_guild(self, guild): '''cache interesting information about all the messages in a guild''' logger.debug(f"Downloading messages in {len(guild.channels)} channels for '{guild.name}'...") for channel in guild.text_channels: try: await self.cache_channel(channel) except Forbidden: logger.warning(f"Insuffcient permissions to download messages from '{guild.name}.{channel.name}'") except HTTPException as e: logger.error(f"Caught {e} when downloading '{guild.name}.{channel.name}'") logger.error("trying again in 10 seconds...") await asyncio.sleep(10) try: await self.cache_channel(channel) except Exception: logger.exception("failed to download channel a second time, giving up :(")
def login(self, ipaddress, port, user_passwd_pair_list): for user_passwd_pair in user_passwd_pair_list: try: fp = SMBConnection('*SMBSERVER', ipaddress, sess_port=int(port), timeout=self.timeout) except Exception as E: logger.debug('ConnectException: {} {} {}'.format(E, ipaddress, port)) return try: if fp.login(user_passwd_pair[0], user_passwd_pair[1], ""): if fp.isGuestSession() == 0: log_success("SMB", ipaddress, port, user_passwd_pair) except Exception as E: logger.debug('AuthenticationException: %s' % E) finally: fp.getSMBServer().get_socket().close()