media-relay

#!/usr/bin/python3


if __name__ == '__main__':
    import mediaproxy
    import errno
    import sys
    import subprocess

    from application import log
    from application.process import process, ProcessError
    from application.version import Version
    from argparse import ArgumentParser

    IP_FORWARD_FILE     = '/proc/sys/net/ipv4/ip_forward'
    CONNTRACK_ACCT_FILE = '/proc/sys/net/netfilter/nf_conntrack_acct'
    KERNEL_VERSION_FILE = '/proc/sys/kernel/osrelease'

    name = 'media-relay'
    fullname = 'MediaProxy Relay'
    description = 'MediaProxy Relay component'

    process.configuration.user_directory = None
    process.configuration.subdirectory = mediaproxy.mediaproxy_subdirectory
    process.runtime.subdirectory = mediaproxy.mediaproxy_subdirectory

    parser = ArgumentParser(usage='%(prog)s [options]')
    parser.add_argument('--version', action='version', version='%(prog)s {}'.format(mediaproxy.__version__))
    parser.add_argument('--systemd', action='store_true', help='run as a systemd simple service and log to journal')
    parser.add_argument('--no-fork', action='store_false', dest='fork', help='run in the foreground and log to the terminal')
    parser.add_argument('--config-dir', dest='config_directory', default=None, help='the configuration directory ({})'.format(process.configuration.system_directory), metavar='PATH')
    parser.add_argument('--runtime-dir', dest='runtime_directory', default=None, help='the runtime directory ({})'.format(process.runtime.directory), metavar='PATH')
    parser.add_argument('--debug', action='store_true', help='enable verbose logging')
    parser.add_argument('--debug-memory', action='store_true', help='enable memory debugging')

    options = parser.parse_args()

    log.Formatter.prefix_format = '{record.levelname:<8s} '

    if options.config_directory is not None:
        process.configuration.local_directory = options.config_directory

    if options.runtime_directory is not None:
        process.runtime.directory = options.runtime_directory

    if not sys.platform.startswith('linux'):
        log.critical('Cannot start %s. A Linux host is required for operation.' % fullname)
        sys.exit(1)

    try:
        kernel_version = Version.parse(open(KERNEL_VERSION_FILE).read().strip())
    except (OSError, IOError, ValueError):
        log.critical('Could not determine Linux kernel version')
        sys.exit(1)

    if kernel_version < Version(2, 6, 18):
        log.critical('Linux kernel version 2.6.18 or newer is required to run the media relay')
        sys.exit(1)

    try:
        ip_forward = bool(int(open(IP_FORWARD_FILE).read()))
    except (OSError, IOError, ValueError):
        ip_forward = False

    if not ip_forward:
        log.critical('IP forwarding is not available or not enabled (check %s)' % IP_FORWARD_FILE)
        sys.exit(1)

    try:
        with open(CONNTRACK_ACCT_FILE, 'w') as acct_file:
            acct_file.write('1')
    except (IOError, OSError) as e:
        if e.errno != errno.ENOENT:
            log.critical('Could not enable conntrack rule counters (check %s): %s' % (CONNTRACK_ACCT_FILE, e))
            sys.exit(1)

    if options.systemd:
        from systemd.journal import JournalHandler
        log.set_handler(JournalHandler(SYSLOG_IDENTIFIER=name))
        log.capture_output()
    elif options.fork:
        try:
            process.daemonize(pidfile='{}.pid'.format(name))
        except ProcessError as e:
            log.critical('Cannot start %s: %s' % (fullname, e))
            sys.exit(1)
        log.use_syslog(name)

    log.info('Starting %s %s' % (fullname, mediaproxy.__version__))

    try:
        process.wait_for_network(wait_time=10, wait_message='Waiting for network to become available...')
    except KeyboardInterrupt:
        sys.exit(0)
    except RuntimeError as e:
        log.critical('Cannot start %s: %s' % (fullname, e))
        sys.exit(1)

    try:
        from mediaproxy.relay import MediaRelay
        from mediaproxy.configuration import RelayConfig
        log.level.current = log.level.DEBUG if options.debug else RelayConfig.log_level
        if options.debug_memory:
            from application.debug.memory import memory_dump
        relay = MediaRelay()
    except Exception as e:
        log.critical('Failed to create %s: %s' % (fullname, e))
        if type(e) is not RuntimeError:
            log.exception()
        sys.exit(1)

    relay.run()

    if options.debug_memory:
        memory_dump()