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