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