#!/usr/bin/python
"""
signing-server [options] server.ini
"""
import os
import site
# Modify our search path to find our modules
site.addsitedir(os.path.join(os.path.dirname(__file__), "../../lib/python"))
import shutil
import signal
import multiprocessing
import socket
import tempfile

import logging
import logging.handlers

from util.file import sha1sum as sync_sha1sum, safe_unlink
from util.file import load_config, get_config, get_config_int, get_config_bool
from signing.server import SigningServer, create_server, run_signscript

# External dependencies
import daemon

import gevent.backdoor
from gevent.event import Event

log = logging.getLogger(__name__)

# We need to ignore SIGINT (KeyboardInterrupt) in the children so that the
# parent exits properly.


def init_worker():
    signal.signal(signal.SIGINT, signal.SIG_IGN)

_sha1sum_worker_pool = None


def sha1sum(fn):
    "Non-blocking sha1sum. Will calculate sha1sum of fn in a subprocess"
    result = _sha1sum_worker_pool.apply_async(sync_sha1sum, args=(fn,))
    # Most of the time we'll complete pretty fast, so don't need to sleep very
    # long
    sleep_time = 0.1
    while not result.ready():
        gevent.sleep(sleep_time)
        # Increase the time we sleep next time, up to a maximum of 5 seconds
        sleep_time = min(5, sleep_time * 2)
    return result.get()


def run(config_filename, passphrases):
    log.info("Running with pid %i", os.getpid())

    # Start our worker pool now, before we create our sockets for the web app
    # otherwise the workers inherit the file descriptors for the http(s)
    # socket and we have problems shutting down cleanly
    global _sha1sum_worker_pool
    if not _sha1sum_worker_pool:
        _sha1sum_worker_pool = multiprocessing.Pool(None, init_worker)
    app = None
    listener = None
    server = None
    backdoor = None
    handler = None
    backdoor_state = {}
    while True:
        log.info("Loading configuration")
        config = load_config(config_filename)
        if not app:
            app = SigningServer(config, passphrases)
        else:
            app.load_config(config)

        listen_addr = (
            config.get('server', 'listen'), config.getint('server', 'port'))
        if not listener or listen_addr != listener.getsockname():
            if listener and server:
                log.info(
                    "Listening address has changed, stopping old wsgi server")
                log.debug("Old address: %s", listener.getsockname())
                log.debug("New address: %s", listen_addr)
                server.stop()
            listener = gevent.socket.socket()
            listener.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
            listener.bind(listen_addr)
            listener.listen(256)

        server = create_server(app, listener, config)

        backdoor_state['server'] = server
        backdoor_state['app'] = app

        if config.has_option('server', 'backdoor_port'):
            backdoor_port = config.getint('server', 'backdoor_port')
            if not backdoor or backdoor.server_port != backdoor_port:
                if backdoor:
                    log.info("Stopping old backdoor on port %i",
                             backdoor.server_port)
                    backdoor.stop()
                log.info("Starting backdoor on port %i", backdoor_port)
                backdoor = gevent.backdoor.BackdoorServer(
                    ('127.0.0.1', backdoor_port),
                    locals=backdoor_state)
                gevent.spawn(backdoor.serve_forever)

        # Handle SIGHUP
        # Create an event to wait on
        # Our SIGHUP handler will set the event, allowing us to continue
        sighup_event = Event()
        h = gevent.signal(signal.SIGHUP, lambda e: e.set(), sighup_event)
        if handler:
            # Cancel our old handler
            handler.cancel()
        handler = h
        log.info("Serving on %s", repr(server))
        try:
            gevent.spawn(server.serve_forever)
            # Wait for SIGHUP
            sighup_event.wait()
        except KeyboardInterrupt:
            break
    log.info("pid %i exiting normally", os.getpid())


def setup_logging(loglevel=None, logfile=None, log_maxsize=None, log_maxfiles=None):
    if logfile:
        handler = logging.handlers.RotatingFileHandler(
            logfile,
            maxBytes=log_maxsize,
            backupCount=log_maxfiles,
        )
    else:
        handler = logging.StreamHandler()

    formatter = logging.Formatter("%(asctime)s - %(levelname)s - %(message)s")
    handler.setFormatter(formatter)

    logger = logging.getLogger()
    logger.addHandler(handler)
    logger.setLevel(logging.INFO)

    if logfile:
        log.info("Logging to %s; maxBytes=%s; backupCount=%s; loglevel=%s",
                 logfile, log_maxsize, log_maxfiles,
                 logging.getLevelName(loglevel)
                 )
    else:
        log.info("Logging to stderr; loglevel=%s",
                 logging.getLevelName(loglevel)
                 )

    logger.setLevel(loglevel)


if __name__ == '__main__':
    from optparse import OptionParser
    import getpass
    import sys

    parser = OptionParser(__doc__)
    parser.set_defaults(
        # Defaults for these are actually set below
        # We set default to None here so we can tell if the user has overridden
        # them on the cmdline
        logfile=None,
        loglevel=None,
        log_maxfiles=None,
        log_maxsize=None,
        daemonize=None,
        pidfile="signing.pid",
        action="run",
    )
    parser.add_option("-v", dest="loglevel", action="store_const",
                      const=logging.DEBUG, help="be verbose")
    parser.add_option("-q", dest="loglevel", action="store_const",
                      const=logging.WARNING, help="be quiet")
    parser.add_option(
        "-l", dest="logfile", help="log to this file instead of stderr")
    parser.add_option("-d", dest="daemonize", action="store_true",
                      help="daemonize process")
    parser.add_option("--pidfile", dest="pidfile")
    parser.add_option(
        "--stop", dest="action", action="store_const", const="stop")
    parser.add_option(
        "--reload", dest="action", action="store_const", const="reload")
    parser.add_option(
        "--restart", dest="action", action="store_const", const="restart")

    options, args = parser.parse_args()

    if options.action == "stop":
        try:
            pid = int(open(options.pidfile).read())
            os.kill(pid, signal.SIGINT)
        except (IOError, ValueError):
            log.info("no pidfile, assuming process is stopped")
        sys.exit(0)
    elif options.action == "reload":
        pid = int(open(options.pidfile).read())
        os.kill(pid, signal.SIGHUP)
        sys.exit(0)

    if len(args) != 1:
        parser.error("Need just one server.ini file to read")

    config = load_config(args[0])
    if not config:
        parser.error("Error reading config file: %s" % args[0])

    # Set up options if they haven't been overridden on the cmdline
    if options.logfile is None:
        options.logfile = get_config(config, "logging", "logfile", None)
    if options.loglevel is None:
        loglevel = get_config(config, "logging", "loglevel", "INFO")
        options.loglevel = getattr(logging, loglevel)
    if options.log_maxfiles is None:
        options.log_maxfiles = get_config_int(
            config, "logging", "log_maxfiles", 50)
    if options.log_maxsize is None:
        # 10 MB log size by default
        options.log_maxsize = get_config_int(
            config, "logging", "log_maxsize", 10 * (1024 ** 2))
    if options.daemonize is None:
        options.daemonize = get_config_bool(
            config, "server", "daemonize", False)
    os.umask(0o077)
    setup_logging(logfile=options.logfile,
                  loglevel=options.loglevel,
                  log_maxsize=options.log_maxsize,
                  log_maxfiles=options.log_maxfiles,
                  )

    # Read passphrases
    passphrases = {}
    formats = [f.strip() for f in config.get('signing', 'formats').split(',')]
    for format_ in formats:
        passphrase = getpass.getpass("%s passphrase: " % format_)
        if not passphrase:
            passphrase = None
        tmpdir = tempfile.mkdtemp()
        try:
            log.info("checking %s passphrase", format_)
            src = config.get('signing', 'testfile_%s' % format_)
            dst = os.path.join(tmpdir, os.path.basename(src))
            shutil.copyfile(src, dst)
            # Our test app doesn't work with 10.9.5 signing machines yet, bug 1073644
            if format_ != "dmg":
                if 0 != run_signscript(config.get('signing', 'signscript'), src, dst, src, format_, passphrase, max_tries=2):
                    log.error("Bad passphrase: %s", open(dst + ".out").read())
                    assert False
            log.info("%s passphrase OK", format_)
            passphrases[format_] = passphrase
        finally:
            shutil.rmtree(tmpdir)

    # Possibly stop the old instance
    # We do this here so that we don't have to wait for the user to enter
    # passwords before stopping/starting the new instance.
    if options.action == 'restart':
        try:
            pid = int(open(options.pidfile).read())
            log.info("Killing old server pid:%i", pid)
            os.kill(pid, signal.SIGINT)
            # Wait for it to exit
            while True:
                log.debug("Waiting for pid %i to exit", pid)
                # This will raise OSError once the process exits
                os.kill(pid, 0)
                gevent.sleep(1)
        except (IOError, ValueError):
            log.info("no pidfile, assuming process is stopped")
        except OSError:
            # Process is done
            log.debug("pid %i has exited", pid)

    if options.daemonize:
        curdir = os.path.abspath(os.curdir)
        pidfile = os.path.abspath(options.pidfile)
        logfile = os.path.abspath(options.logfile)

        daemon_ctx = daemon.DaemonContext(
            # We do our own signal handling in run()
            signal_map={},
            working_directory=curdir,
            umask=0o077,
        )
        daemon_ctx.open()

        # gevent needs to be reinitialized after the hardcore forking action
        gevent.reinit()
        open(pidfile, 'w').write(str(os.getpid()))

        # Set up logging again! createDaemon has closed all our open file
        # handles
        setup_logging(logfile=options.logfile,
                      loglevel=options.loglevel,
                      log_maxsize=options.log_maxsize,
                      log_maxfiles=options.log_maxfiles,
                      )

    try:
        run(args[0], passphrases)
    except:
        log.exception("error running server")
        raise
    finally:
        try:
            if options.daemonize:
                daemon_ctx.close()
                safe_unlink(pidfile)
            log.info("exiting")
        except:
            log.exception("error shutting down")