def test_migrations(tmp_path):
# Use our own cluster to isolate this test from the others (given
# otherwise it failure would most likely provoke inconsistent DB schemas
# errors in any subsequent tests)
with pg_cluster_factory(tmp_path) as pg_cluster:
postgresql_url = url_from_pg_cluster(pg_cluster)
pg_dump = pg_cluster._find_pg_binary("pg_dump")
psql = pg_cluster._find_pg_binary("psql")
# Need to run trio loop after pg_cluster is ready
trio_asyncio.run(_trio_test_migration, postgresql_url, pg_dump, psql)
def main():
stdout_level = logging.INFO
if os.environ.get('BOT_DEBUG', False):
stdout_level = logging.DEBUG
logging.basicConfig(stream=sys.stdout, format='%(name)-12s: %(levelname)-8s %(message)s', level=stdout_level)
logger = logging.getLogger()
logger.addHandler(logging.FileHandler('bot.log'))
logger.addHandler(logging.FileHandler('last.log', 'w'))
main_cfg = yaml.safe_load(open("config/main.yml"))
bot, world = interface.make_game(main_cfg['gamefile'], main_cfg['prefix'])
for s in yaml.safe_load(open("config/irc.yml")):
print('Opening IRC connection: ', s['name'])
account = s.get('account', None)
if account:
account = (account.get('username', None), account.get('password', None))
print('Using account: {} [{}]'.format(account[0], '*' * len(account[1])))
bot.register_backend(triarc.backends.irc.IRCConnection(
nickname = s.get('nickname', 'SMAdventure'),
realname = s.get('realname', 'The official Sentient Mushes: Adventure bot!'),
host = s['server'],
port = s.get('port', 6667),
channels = s.get('channels', ()),
nickserv_user = account and account[0],
nickserv_pass = account and account[1]
))
#conns[s['name']] = IRCInterface(s['name'],s['nickname'], s['realname'], s['server'], s['port'], s.get('channels', ()), s.get('account', None), s.get('prefix', '=='))
#t = Thread(target=conns[s['name']].start, name="Bot: {}".format(s['name']))
#threads.append(t)
#t.start()
for s in yaml.safe_load(open("config/discord.yml").read()):
print('Opening Discord client: ', s['name'])
bot.register_backend(triarc.backends.discord.DiscordClient(s['token']))
async def smadv_main():
async with trio.open_nursery() as nursery:
nursery.start_soon(world._broadcast_loop)
nursery.start_soon(bot.start)
trio_asyncio.run(smadv_main)
def trio_run(async_fn, *args, use_asyncio=False, monitor_tasks=True):
if use_asyncio:
# trio_asyncio is an optional dependency
import trio_asyncio
return trio_asyncio.run(async_fn, *args)
instruments = (TaskMonitoringInstrument(), ) if monitor_tasks else ()
return trio.run(async_fn, *args, instruments=instruments)
def init_cmd(db, force):
"""
Initialize a new backend's PostgreSQL database.
"""
if not (db.startswith("postgresql://") or db.startswith("postgres://")):
raise SystemExit("Can only initialize a PostgreSQL database.")
debug = "DEBUG" in os.environ
with cli_exception_handler(debug):
async def _init_db(db, force):
async with spinner("Initializing database"):
already_initialized = await init_db(db, force)
if already_initialized:
click.echo("Database already initialized, nothing to do.")
trio_asyncio.run(_init_db, db, force)
sms_id)
async def listen():
# WAS BEFORE: *_, channel = await redis.subscribe('updates')
*_, channel = await trio_asyncio.run_asyncio(
redis.subscribe, "updates")
while True:
# WAS BEFORE: raw_message = await channel.get()
raw_message = await trio_asyncio.run_asyncio(channel.get)
if not raw_message:
raise ConnectionError("Connection was lost")
message = raw_message.decode("utf-8")
print("Got message:", message)
# WAS BEFORE: await asyncio.gather(send(), listen())
async with trio.open_nursery() as nursery:
nursery.start_soon(send)
nursery.start_soon(listen)
finally:
redis.close()
# WAS BEFORE: await redis.wait_closed()
await trio_asyncio.run_asyncio(redis.wait_closed)
if __name__ == "__main__":
trio_asyncio.run(main)
def test_run2(self):
trio_asyncio.run(self._test_run)
def test_run2_depr(self):
trio_asyncio.run(self._test_run_depr)
git_dir = '.git'
class Handler(FileSystemEventHandler):
def on_modified(self, event):
if event.src_path == os.path.abspath(os.path.join(git_dir,
'HEAD')):
callback()
on_created = on_modified
def callback():
session.message = ps1()
session.app.invalidate()
async def watch():
observer = Observer()
observer.schedule(Handler(), git_dir)
observer.start()
try:
while True:
await trio.sleep(1)
finally:
observer.stop()
observer.join()
return watch
if __name__ == '__main__':
trio_asyncio.run(run)
def run_app():
config = Config()
config.bind = ['0.0.0.0:8000']
trio_asyncio.run(functools.partial(serve, app, config))
while True:
await asyncio.sleep(1)
await redis.publish('updates', sms_id)
async def listen():
*_, channel = await redis.subscribe('updates')
while True:
raw_message = await channel.get()
if not raw_message:
raise ConnectionError('Connection was lost')
message = raw_message.decode('utf-8')
print('Got message:', message)
await asyncio.gather(send(), listen())
finally:
redis.close()
await redis.wait_closed()
async def trio_main():
asyncio._set_running_loop(asyncio.get_event_loop()) # noqa
await trio_asyncio.run_asyncio(main)
if __name__ == '__main__':
trio_asyncio.run(trio_main)
sms_mailings = await db.get_sms_mailings("1")
print("sms_mailings")
print(sms_mailings)
async def send():
while True:
await asyncio.sleep(1)
await redis.publish("updates", sms_id)
async def listen():
*_, channel = await redis.subscribe("updates")
while True:
raw_message = await channel.get()
if not raw_message:
raise ConnectionError("Connection was lost")
message = raw_message.decode("utf-8")
print("Got message:", message)
await asyncio.gather(send(), listen())
finally:
redis.close()
await redis.wait_closed()
if __name__ == "__main__":
trio_asyncio.run(trio_asyncio.aio_as_trio(main))
def run_cmd(
host,
port,
db,
blockstore,
ssl_keyfile,
ssl_certfile,
log_level,
log_format,
log_file,
log_filter,
):
configure_logging(log_level, log_format, log_file, log_filter)
debug = "DEBUG" in os.environ
with cli_exception_handler(debug):
try:
config = config_factory(blockstore_type=blockstore,
db_url=db,
debug=debug,
environ=os.environ)
except ValueError as exc:
raise ValueError(f"Invalid configuration: {exc}")
if config.sentry_url:
configure_sentry_logging(config.sentry_url)
backend = BackendApp(config)
if ssl_certfile or ssl_keyfile:
ssl_context = trio.ssl.create_default_context(
trio.ssl.Purpose.SERVER_AUTH)
if ssl_certfile:
ssl_context.load_cert_chain(ssl_certfile, ssl_keyfile)
else:
ssl_context.load_default_certs()
else:
ssl_context = None
async def _serve_client(stream):
if ssl_context:
stream = trio.ssl.SSLStream(stream,
ssl_context,
server_side=True)
try:
await backend.handle_client(stream)
except Exception as exc:
# If we are here, something unexpected happened...
logger.error("Unexpected crash", exc_info=exc)
await stream.aclose()
async def _run_backend():
async with trio.open_nursery() as nursery:
await backend.init(nursery)
try:
await trio.serve_tcp(_serve_client, port, host=host)
finally:
await backend.teardown()
print(
f"Starting Parsec Backend on {host}:{port} (db={config.db_type}, "
f"blockstore={config.blockstore_config.type})")
try:
trio_asyncio.run(_run_backend)
except KeyboardInterrupt:
print("bye ;-)")
