async def run_service(opts):
data_dir = opts.get("data_dir")
mapping = config.json.load(opts["config"])
preferences = config.from_mapping(mapping)
logger = log.new_logger("ircd", preferences.logging_verbosity)
logger.info("Starting server process with pid %d.", os.getpid())
logger.info("Hostname: %s", preferences.server_hostname)
logger.info("Max clients: %d", preferences.server_max_clients)
logger.info("ICB endpoint: %s", preferences.icb_endpoint)
if os.name == "posix":
loop = asyncio.get_event_loop()
loop.add_signal_handler(signal.SIGINT, lambda: server.close())
loop.add_signal_handler(signal.SIGTERM, lambda: server.close())
try:
server = Server(logger, preferences)
await server.run()
except asyncio.CancelledError:
pass
except:
logger.warning(traceback.format_exc())
logger.info("Server stopped.")
def __init__(self, logger=None):
super(AxoCtl, self).__init__()
self.db_path = self.data_dir + "/conversations.db"
self.handshakes_dir = self.data_dir + "/handshakes"
self.queues_dir = self.data_dir + "/queues"
self.logger = new_logger('axonaut', logging.DEBUG) if logger is None else logger
dirs = [self.data_dir, self.handshakes_dir, self.queues_dir];
for d in dirs:
ensure_dir(d)
def __init__(self,
name,
verbosity=core.Verbosity.DEBUG,
level=logging.DEBUG):
self.__buffer = StringIO()
self.__verbosity = verbosity
self.__level = level
self.__log = log.new_logger(name, verbosity, log.PROTOCOL_FORMAT)
asyncio.Protocol.__init__(self)
di.Injected.__init__(self)
def run(m):
logger = log.new_logger()
logger.info("Starting websocket server: %s", m["url"])
logger.info("Listen on: %s:%d", m["address"], m["port"])
factory = WebSocketServerFactory(m["url"])
factory.protocol = lambda: WSProtocol(logger, m["remote-address"], m[
"remote-port"])
loop = asyncio.get_event_loop()
sc = None
if m["ssl-cert"] and m["ssl-key"]:
sc = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH)
sc.load_cert_chain(m["ssl-cert"], m["ssl-key"])
server = loop.create_server(factory, m["address"], m["port"], ssl=sc)
loop.run_until_complete(server)
loop.run_forever()
opts = lm.SMFIF_CHGFROM | lm.SMFIF_ADDRCPT | lm.SMFIF_QUARANTINE | lm.SMFIF_ADDHDRS | lm.SMFIF_CHGBODY
# We initialize the factory we want to use (you can choose from an
# AsyncFactory, ForkFactory or ThreadFactory. You must use the
# appropriate mixin classes for your milter for Thread and Fork)
logger.debug("Setting up ForkFactory")
f = lm.ThreadFactory("inet:127.0.0.1:5000", AxoMilter, opts)
def sigHandler(num, frame):
logger.info("Good bye!")
f.close()
sys.exit(0)
signal.signal(signal.SIGINT, sigHandler)
try:
# run it
logger.debug("Magic Milter ready to go.")
sys.stdout.flush()
f.run()
except Exception, e:
f.close()
logger.exception("Whut just happenend?!? o.O")
traceback.print_tb(sys.exc_traceback)
sys.exit(3)
logger = new_logger("milter", logging.DEBUG)
if __name__ == "__main__":
main()
def main():
print_logo()
BOARDS = {}
LOGGER = new_logger("joerg")
async def new_game(websocket, payload):
board = init_game()
board_id = random.randint(0, 100)
BOARDS[board_id] = board
LOGGER.info(f"Board {board_id} created!")
await websocket.send(
json.dumps({
"type": "board",
"board_id": board_id,
"board": board
},
cls=MyEncoder))
async def hello(websocket, path):
LOGGER.info(f"{websocket._host}: Connected!")
while True:
try:
raw_payload = await websocket.recv()
except websockets.exceptions.ConnectionClosedOK:
LOGGER.info(f"{websocket._host}: left")
break
except websockets.exceptions.ConnectionClosedError:
LOGGER.info(f"{websocket._host}: left")
break
try:
payload = json.loads(raw_payload)
except json.decoder.JSONDecodeError as jde:
msg = f"! Malformed request: {jde}"
LOGGER.info(msg)
await websocket.send(error(msg))
continue
if not isinstance(payload, dict):
msg = "! Malformed request, payload must be json object"
LOGGER.info(msg)
await websocket.send(error(msg))
continue
if "type" not in payload:
msg = "! Missing key `type` in JSON payload"
await websocket.send(error(msg))
continue
LOGGER.info(f"< {payload}")
payload_type = payload["type"]
LOGGER.info(f"New incoming payload: {payload_type}")
if payload_type == NEW_GAME_ACTION:
LOGGER.info("Here!")
await new_game(websocket, payload)
continue
await websocket.send(
json.dumps({"message": "type queried not yet implemented."}))
start_server = websockets.serve(hello, "192.168.1.109", 8000)
asyncio.get_event_loop().run_until_complete(start_server)
asyncio.get_event_loop().run_forever()
async def run(opts):
mapping = config.json.load(opts["config"])
preferences = config.from_mapping(mapping)
logger = log.new_logger("avatar", log.Verbosity.DEBUG,
log.SIMPLE_TEXT_FORMAT)
logger.info("Starting avatar process with interval %d.",
preferences.avatar_interval)
container = di.default_container
container.register(config.Config, preferences)
container.register(logging.Logger, logger)
container.register(avatar.Connection,
sqlite.Connection(preferences.database_filename))
container.register(avatar.Reader, avatar.sqlite.Reader())
container.register(
avatar.Writer,
avatar.sqlite.Writer(preferences.avatar_reload_timeout,
preferences.avatar_retry_timeout,
preferences.avatar_max_errors,
preferences.avatar_error_timeout))
container.register(
avatar.Storage,
avatar.fs.AsciiFiles(preferences.avatar_directory,
preferences.avatar_ascii_width,
preferences.avatar_ascii_height))
client = ipc.Client(preferences.server_ipc_binding)
download = Download()
conn_f = await client.connect()
msg_f = asyncio.ensure_future(client.read())
timeout_f = asyncio.ensure_future(asyncio.sleep(1))
clean_f = asyncio.ensure_future(
asyncio.sleep(preferences.avatar_cleanup_interval))
if os.name == "posix":
loop = asyncio.get_event_loop()
logger.debug("Registerung SIGINT handler.")
loop.add_signal_handler(signal.SIGINT, lambda: None)
quit = False
class Action(Enum):
NONE = 0
FETCH = 1
CLEANUP = 2
QUIT = 3
while not quit:
done, _ = await asyncio.wait([conn_f, msg_f, timeout_f, clean_f],
return_when=asyncio.FIRST_COMPLETED)
action = Action.NONE
for f in done:
if f is msg_f:
receiver, message = msg_f.result()
if receiver == "avatar":
logger.debug("Message received: '%s'", message)
if message == "put":
action = Action.FETCH
elif f is conn_f:
action = Action.QUIT
elif f is timeout_f:
action = Action.FETCH
elif f is clean_f:
action = Action.CLEANUP
if action == Action.QUIT:
quit = True
elif action == Action.FETCH:
download.fetch()
elif action == Action.CLEANUP:
download.cleanup()
for f in done:
if f is msg_f:
msg_f = asyncio.ensure_future(client.read())
elif f is timeout_f:
timeout_f = asyncio.ensure_future(
asyncio.sleep(preferences.avatar_interval))
elif f is clean_f:
clean_f = asyncio.ensure_future(
asyncio.sleep(preferences.avatar_cleanup_interval))
logger.info("Stopped.")
import random
from collections import defaultdict
from enum import Enum
from typing import List, Deque, Optional, Dict, Set, Callable
from cards.card import Card
from order import Order
from played_card import PlayedCard
from player import Player
from log import new_logger
LOGGER = new_logger("board")
class PlayerStates(Enum):
HandFaceDown = 1
UnableToWin = 2
class Victory(Exception):
pass
class ActivePlayerState:
def __init__(self, state: PlayerStates, duration: int, action: Callable[[], None]):
self.state: PlayerStates = state
# 0 denotes indefinite.
self.duration: int = duration
self.action: Callable[[], None] = action
import logging
import random
from enum import Enum
from typing import List, Optional, Tuple, Any, Union, Dict
from cards.card import Card
from log import new_logger
_NAME_LOOKUP = ["Emil", "Henry", "Robin", "Bob"]
LOGGER = new_logger("player", logging.DEBUG)
class HandCardState(Enum):
VisibleOnlyForPlayer = 1
VisibleForEveryone = 2
HiddenFromEveryone = 3
class Player:
def __init__(self, num: int):
self.num = num
self.hand: List[Card] = []
self.hand_states: Dict[Card, HandCardState] = {}
def remove_card_from_hand(self, card: Card) -> Tuple[int, Card]:
assert card in self.hand
assert card in self.hand_states
index = self.hand.index(card)
removed_card = self.hand.pop(index)
del self.hand_states[removed_card]
async def run_services(opts):
data_dir = opts.get("data_dir")
mapping = config.json.load(opts["config"])
preferences = config.from_mapping(mapping)
logger = log.new_logger("icbd", preferences.logging_verbosity)
registry = log.Registry()
registry.register(logger)
logger.info("Starting server process with pid %d.", os.getpid())
container = di.default_container
connection = sqlite.Connection(preferences.database_filename)
ipfilter_storage = ipfilter.sqlite.Storage()
ipfilter_cached = ipfilter.cache.Storage(ipfilter_storage)
container.register(logging.Logger, logger)
container.register(log.Registry, registry)
container.register(config.Config, preferences)
container.register(ipc.Broadcast, ipc.Broadcast())
container.register(shutdown.Shutdown, shutdown.Shutdown())
container.register(ipfilter.Connection, connection)
container.register(ipfilter.Storage, ipfilter_cached)
container.register(broker.Broker, broker.memory.Broker())
container.register(session.Store, session.memory.Store())
container.register(session.AwayTimeoutTable, timer.TimeoutTable())
container.register(session.NotificationTimeoutTable, timer.TimeoutTable())
container.register(reputation.Reputation, reputation.memory.Reputation())
container.register(group.Store, group.memory.Store())
container.register(nickdb.Connection, connection)
container.register(nickdb.NickDb, nickdb.sqlite.NickDb())
container.register(statsdb.Connection, connection)
container.register(statsdb.StatsDb, statsdb.sqlite.StatsDb())
container.register(confirmation.Connection, connection)
container.register(confirmation.Confirmation,
confirmation.sqlite.Confirmation())
container.register(passwordreset.Connection, connection)
container.register(passwordreset.PasswordReset,
passwordreset.sqlite.PasswordReset())
container.register(motd.Motd,
motd.plaintext.Motd(os.path.join(data_dir, "motd")))
container.register(manual.Manual,
manual.plaintext.Manual(os.path.join(data_dir, "help")))
container.register(news.News,
news.plaintext.News(os.path.join(data_dir, "news")))
container.register(
template.Template,
template.plaintext.Template(os.path.join(data_dir, "templates")))
container.register(mail.Connection, connection)
container.register(mail.Sink, mail.sqlite.Sink())
container.register(avatar.Connection, connection)
container.register(avatar.Reader, avatar.sqlite.Reader())
container.register(
avatar.Writer,
avatar.sqlite.Writer(preferences.avatar_reload_timeout,
preferences.avatar_retry_timeout,
preferences.avatar_max_errors,
preferences.avatar_error_timeout))
if avatar.is_available():
container.register(
avatar.Storage,
avatar.fs.AsciiFiles(preferences.avatar_directory,
preferences.avatar_ascii_width,
preferences.avatar_ascii_height))
else:
logger.info("Avatar preview not available.")
container.register(avatar.Storage, avatar.void.Storage())
with connection.enter_scope() as scope:
container.resolve(ipfilter.Storage).setup(scope)
container.resolve(nickdb.NickDb).setup(scope)
container.resolve(statsdb.StatsDb).setup(scope)
container.resolve(confirmation.Confirmation).setup(scope)
container.resolve(mail.Sink).setup(scope)
container.resolve(avatar.Reader).setup(scope)
container.resolve(avatar.Writer).setup(scope)
container.resolve(passwordreset.PasswordReset).setup(scope)
scope.complete()
container.resolve(avatar.Storage).setup()
bus = ipc.Bus()
await bus.start()
if os.name == "posix":
loop = asyncio.get_event_loop()
loop.add_signal_handler(signal.SIGINT, lambda: server.close())
loop.add_signal_handler(signal.SIGTERM, lambda: server.close())
processes = [MailProcess()]
if avatar.is_available():
processes.append(AvatarProcess())
asyncio.gather(*[p.spawn(opts) for p in processes])
failed = False
try:
server = network.Server()
await server.run()
except asyncio.CancelledError:
pass
except:
logger.warning(traceback.format_exc())
failed = True
await bus.close()
for p in processes:
p.exit()
logger.info("Server stopped.")
with container.resolve(nickdb.Connection).enter_scope() as scope:
container.resolve(nickdb.NickDb).set_signoff(scope, core.NICKSERV,
dateutils.now())
scope.complete()
sys.exit(server.exit_code if not failed else core.EXIT_FAILURE)
async def run(opts):
mapping = config.json.load(opts["config"])
preferences = config.from_mapping(mapping)
logger = log.new_logger("mail", log.Verbosity.DEBUG, log.SIMPLE_TEXT_FORMAT)
logger.info("Starting mail process with interval %.2f.", preferences.mail_interval)
container = di.default_container
container.register(config.Config, preferences)
container.register(logging.Logger, logger)
container.register(mail.Connection, sqlite.Connection(preferences.database_filename))
container.register(mail.Queue, mail.sqlite.Queue(preferences.mail_ttl,
preferences.mail_max_errors,
preferences.mail_retry_timeout))
container.register(mail.MTA, mail.smtp.MTA(preferences.smtp_hostname,
preferences.smtp_port,
preferences.smtp_ssl_enabled,
preferences.smtp_start_tls,
preferences.smtp_sender,
preferences.smtp_username,
preferences.smtp_password))
client = ipc.Client(preferences.server_ipc_binding)
mailer = Sendmail()
conn_f = await client.connect()
msg_f = asyncio.ensure_future(client.read())
cleanup_f = asyncio.ensure_future(asyncio.sleep(0))
timeout_f = asyncio.ensure_future(asyncio.sleep(1))
if os.name == "posix":
loop = asyncio.get_event_loop()
logger.debug("Registerung SIGINT handler.")
loop.add_signal_handler(signal.SIGINT, lambda: None)
quit = False
class Action(Enum):
NONE = 0
SEND = 1
CLEANUP = 2
QUIT = 3
while not quit:
done, _ = await asyncio.wait([conn_f, msg_f, cleanup_f, timeout_f], return_when=asyncio.FIRST_COMPLETED)
action = Action.NONE
for f in done:
if f is msg_f:
receiver, message = msg_f.result()
if receiver == "mail":
logger.debug("Message received: '%s'", message)
if message == "put":
action = Action.SEND
elif f is cleanup_f:
action = Action.CLEANUP
elif f is timeout_f:
action = Action.SEND
elif f is conn_f:
action = Action.QUIT
if action == Action.SEND:
mailer.send()
elif action == Action.CLEANUP:
mailer.cleanup()
elif action == Action.QUIT:
quit = True
for f in done:
if f is msg_f:
msg_f = asyncio.ensure_future(client.read())
if f is cleanup_f:
cleanup_f = asyncio.ensure_future(asyncio.sleep(preferences.mail_cleanup_interval))
if f is timeout_f:
timeout_f = asyncio.ensure_future(asyncio.sleep(preferences.mail_interval))
logger.info("Stopped.")
#!/usr/bin/env python2
from log import new_logger
import logging
logger = new_logger('tester',logging.DEBUG)
logger.debug("helpful trace")
logger.info("nice info")
logger.warning("don't worry, be happy")
logger.error("Truly sorry :(")
logger.critical("Terrible Failure :'(")
logger.fatal("FAIL xD")
try:
port = kwargs['port']
except Exception, e:
port = 22
try:
private_key_path = kwargs['private_key_path']
except Exception, e:
private_key_path = None
if private_key_path is not None:
pk_file = os.path.expanduser(private_key_path)
private_key = paramiko.RSAKey.from_private_key_file(pk_file)
else:
private_key = None
if self.verbose:
logger = new_logger('worker', 'debug')
if self.debug:
logger = new_logger('worker', 'info')
else:
logger = new_logger('worker', 'warning')
self.logger = logging.getLogger('worker')
self.logger.debug("Defaulting to port 22")
(self.hostname, self.username, self.password) = (host, un, pw)
if private_key is not None:
ssh_password = None
else:
ssh_password = self.password
self.logger.info("Connecting to %s@%s using pw: %s and key: %s" %
(self.username, self.hostname,
ssh_password, private_key_path))
