Use click for CLI

Replace obsolete self-written logger by logbook

Author: lgrahl

bin/saltyrtc-server

@@ -0,0 +1,59 @@
+#!/usr/bin/env python3
+"""
+The command line interface for the SaltyRTC Signalling Server.
+"""
+import functools
+import asyncio
+
+import click
+
+from saltyrtc.server import __version__ as _version
+from saltyrtc import server
+
+
+def aio_run(func, run_forever=False):
+    func = asyncio.coroutine(func)
+
+    def _wrapper(*args, **kwargs):
+        loop = asyncio.get_event_loop()
+        task = loop.create_task(func(*args, **kwargs))
+        loop.run_until_complete(task)
+        if run_forever:
+            loop.run_forever()
+        return task.result()
+    return functools.update_wrapper(_wrapper, func)
+
+
+def aio_serve(func):
+    return aio_run(func, run_forever=True)
+
+
+@click.group()
+@click.pass_context
+def cli(ctx):
+    """
+    Command Line Interface. Use --help for details.
+    """
+    ctx.obj = {}
+
+
+@cli.command(short_help='Show version information.', help="""
+Show the current version of the SaltyRTC Signalling Server.
+""")
+def version():
+    click.echo('Version: {}'.format(_version))
+
+
+@cli.command()
+@aio_serve
+def serve():
+    yield from server.serve()
+
+
+if __name__ == '__main__':
+    with server.logging_handler.applicationbound():
+        try:
+            cli()
+        except Exception as exc:
+            click.echo('An error occurred:', err=True)
+            click.echo(exc, err=True)

saltyrtc/server/__init__.py

@@ -8,19 +8,24 @@
 
 import websockets
 
-from . import settings
+from . import config
 from ._asyncio import gather
 
-from . import exception
+from . import exception, util
+from .util import get_logging_handler
 from .exception import *
 
 __author__ = 'Lennart Grahl <[email protected]>'
 __status__ = 'Development'
 __version__ = '0.0.1'
 __all__ = (
-
+    'serve',
+    'logging_handler',
 ) + exception.__all__
 
+# Create default logger and handler
+logging_handler = util.get_logging_handler()
+log = util.get_logger()
 
 # Globals
 paths = {}
@@ -151,17 +156,17 @@ def register(self, ws):
             raise MessageFlowError('Sent invalid JSON object while registering') from exc
 
         # Check type
-        type_ = data.get(settings.field_type)
-        if type_ == settings.type_hello_server:
+        type_ = data.get(config.field_type)
+        if type_ == config.type_hello_server:
             # Check for key
-            key = data.get(settings.type_key)
+            key = data.get(config.type_key)
             if key is not None:
                 # Register connection and set key
                 role = Role.server
                 self.set(ws, role, key=key)
             else:
                 raise MessageFlowError('Registered as server but key is missing')
-        elif type_ == settings.type_hello_client:
+        elif type_ == config.type_hello_client:
             # Register connection
             role = Role.client
             self.set(ws, role)
@@ -185,8 +190,8 @@ def send_key(self, ws):
 
         # Create key message
         message = {
-            settings.field_type: settings.type_key,
-            settings.field_data: self.key
+            config.field_type: config.type_key,
+            config.field_data: self.key
         }
 
         # Send key message
@@ -248,8 +253,8 @@ def handle(self, ws, role, message):
             raise MessageFlowError(error) from exc
 
         # Check type
-        type_ = data.get(settings.field_type)
-        if type_ == settings.type_reset:
+        type_ = data.get(config.field_type)
+        if type_ == config.type_reset:
             # Dispatch silently
             yield from self.send_reset(ws, role, message)
         else:
@@ -260,7 +265,7 @@ def handle(self, ws, role, message):
     @asyncio.coroutine
     def send_error(self, ws, role):
         # Create error message
-        message = {settings.field_type: settings.type_send_error}
+        message = {config.field_type: config.type_send_error}
 
         # Send error message
         self.logger.info('Sending send error notification to {}', role)
@@ -306,14 +311,14 @@ def keep_alive(logger, ws, role):
             logger.debug('Ping to {}', role)
             try:
                 # Send ping
-                yield from asyncio.wait_for(ws.ping(), settings.ping_timeout)
+                yield from asyncio.wait_for(ws.ping(), config.ping_timeout)
             except asyncio.TimeoutError:
                 raise PingTimeoutError(role)
             else:
                 logger.debug('Pong from {}', role)
 
             # Wait
-            yield from asyncio.sleep(settings.ping_interval)
+            yield from asyncio.sleep(config.ping_interval)
     except asyncio.CancelledError:
         logger.debug('Ping cancelled {}', role)
 
@@ -325,7 +330,7 @@ def signaling(ws, path):
 
     try:
         # Validate path
-        if len(path) != settings.path_length:
+        if len(path) != config.path_length:
             raise PathError(len(path))
     except PathError as exc:
         logging.getLogger('signaling').error(exc)
@@ -365,35 +370,18 @@ def signaling(ws, path):
         path.logger.warning('Unreachable section')
 
 
-def start_server():
-    server = websockets.serve(signaling, port=8765)
-    loop = asyncio.get_event_loop()
-    loop.run_until_complete(server)
-    loop.run_forever()
-
-
-def setup_logging():
-    # Setup formatter and handler
-    formatter = logging.Formatter(
-        fmt=settings.logging_formatter,
-        datefmt=settings.logging_date_formatter,
-        style=settings.logging_style
-    )
-    # handler = logging.color.ColorStreamHandler()
-    handler = logging.StreamHandler()
-    handler.setFormatter(formatter)
-
-    # Setup websockets logger
-    ws_logger = logging.getLogger('websockets')
-    ws_logger.setLevel(settings.logging_level)
-    ws_logger.addHandler(handler)
-
-    # Setup signaling logger
-    logger = logging.getLogger('signaling')
-    logger.set_level(settings.logging_level)
-    logger.add_handler(handler)
-
-
-if __name__ == '__main__':
-    setup_logging()
-    start_server()
+@asyncio.coroutine
+def serve(port=8765, loop=None):
+    """
+    TODO: Describe.
+    """
+    # Get loop
+    loop = loop if loop is not None else asyncio.get_event_loop()
+
+    # Start server
+    log.debug('Starting server')
+    server = yield from websockets.serve(signaling, port=port)
+
+    # Return server
+    log.notice('Listening')
+    return server

saltyrtc/server/config.py

@@ -0,0 +1,24 @@
+"""
+Guess we should override this with some
+whatever-configuration-is-in-now config file.
+"""
+
+# Logging
+logging = True
+log_level = 'DEBUG'
+
+# Keep-Alive settings
+ping_timeout = 10.0
+ping_interval = 60.0
+
+# TODO: This stuff should not be in here as it is constant
+# Signalling
+path_length = 64
+# Signalling messages
+field_type = 'type'
+field_data = 'data'
+type_hello_server = 'hello-server'
+type_hello_client = 'hello-client'
+type_reset = 'reset'
+type_key = 'key'
+type_send_error = 'send-error'

saltyrtc/server/settings.py

@@ -0,0 +1,100 @@
+"""
+This module provides utility functions for the SaltyRTC Signalling
+Server.
+"""
+from contextlib import contextmanager
+
+from saltyrtc.server import config
+
+__all__ = (
+    'Logger',
+    'get_logger',
+    'get_logging_handler',
+)
+
+
+try:
+    # noinspection PyPackageRequirements,PyUnresolvedReferences
+    import logbook
+except ImportError:
+    class Logger(object):
+        """
+        Dummy logger in case :mod:`logbook` is not present.
+        """
+        def __init__(self, name, level=0):
+            self.name = name
+            self.level = level
+        debug = info = warn = warning = notice = error = exception = \
+            critical = log = lambda *a, **kw: None
+else:
+    class Logger(logbook.Logger):
+        """
+        Disable logger depending on config.
+        """
+        @property
+        def disabled(self):
+            return config.logging is False
+
+    # Enable debug logging for `asyncio`
+    import os
+    # Enable asyncio debug logging
+    os.environ['PYTHONASYNCIODEBUG'] = '1'
+
+    import logbook.compat
+    import logging
+
+    # Redirect asyncio logger
+    _logger = logging.getLogger('asyncio')
+    _logger.setLevel(logging.INFO)
+    _logger.addHandler(logbook.compat.RedirectLoggingHandler())
+
+
+def _get_log_level():
+    """
+    Return the translated log level in case :mod:`logbook` is present.
+    """
+    try:
+        # noinspection PyUnresolvedReferences,PyPackageRequirements
+        from logbook import lookup_level
+    except ImportError:
+        return config.log_level
+    else:
+        return lookup_level(config.log_level)
+
+
+def _get_logging_handler():
+    """
+    Return a :class:`~logbook.more.ColorizedStderrHandler` instance
+    in case :mod:`logbook` is present. Otherwise return a mock handler.
+    """
+    try:
+        # noinspection PyPackageRequirements,PyUnresolvedReferences
+        import logbook.more
+    except ImportError:
+        class _LoggingHandler:
+            @contextmanager
+            def applicationbound(self):
+                yield
+
+        return _LoggingHandler()
+    else:
+        return logbook.more.ColorizedStderrHandler()
+
+
+def get_logger(name=None):
+    """
+    Return the default :class:`Logger` instance of the library.
+
+    Arguments:
+        - `name`: The name of a specific sub-logger.
+    """
+    base_name = 'saltyrtc.server'
+    name = base_name if name is None else '.'.join((base_name, name))
+    return Logger(name, level=_get_log_level())
+
+
+def get_logging_handler():
+    """
+    Return the logging handler.
+    """
+    return _get_logging_handler()

saltyrtc/server/util.py

@@ -21,10 +21,11 @@ def get_version():
     name='saltyrtc.server',
     version=get_version(),
     packages=find_packages(),
-    namespace_packages=['threema'],
+    namespace_packages=['saltyrtc'],
     install_requires=[
         'libnacl>=1.4.4',
         'click>=6.3',
+        'logbook>=0.12.5',
         'websockets>=3.0',
         'asyncio>=3.4.3',
     ],