#!/usr/bin/env python
#
# CORE
# Copyright (c)2010-2013 the Boeing Company.
# See the LICENSE file included in this distribution.
#
# authors: Tom Goff <thomas.goff@boeing.com>
#          Jeff Ahrenholz <jeffrey.m.ahrenholz@boeing.com>
#

"""
core-daemon: the CORE daemon is a server process that receives CORE API
messages and instantiates emulated nodes and networks within the kernel. Various
message handlers are defined and some support for sending messages.
"""

import ConfigParser
import atexit
import importlib
import logging
import optparse
import os
import signal
import socket
import sys
import threading
import time

from core import constants
from core import corehandlers
from core import coreserver
from core import enumerations
from core.api import coreapi
from core.enumerations import MessageFlags
from core.enumerations import RegisterTlvs
from core.misc import log
from core.misc import nodemaps
from core.misc import nodeutils
from core.misc.utils import closeonexec
from core.misc.utils import daemonize
from core.services import bird
from core.services import dockersvc
from core.services import nrl
from core.services import quagga
from core.services import security
from core.services import startup
from core.services import ucarp
from core.services import utility
from core.services import xorp

DEFAULT_MAXFD = 1024


#
# UDP server startup
#
def startudp(mainserver, server_address):
    """ Start a thread running a UDP server on the same host,port for
    connectionless requests.
    """
    mainserver.udpserver = coreserver.CoreUdpServer(
            server_address,
            corehandlers.CoreDatagramRequestHandler,
            mainserver)
    mainserver.udpthread = threading.Thread(target=mainserver.udpserver.start)
    mainserver.udpthread.daemon = True
    mainserver.udpthread.start()
    return mainserver.udpserver


#
# Auxiliary server startup
#
def startaux(mainserver, aux_address, aux_handler):
    """ Start a thread running an auxiliary TCP server on the given address.
    This server will communicate with client requests using a handler
    using the aux_handler class. The aux_handler can provide an alternative
    API to CORE.
    """
    handlermodname, dot, handlerclassname = aux_handler.rpartition(".")
    handlermod = importlib.import_module(handlermodname)
    handlerclass = getattr(handlermod, handlerclassname)
    mainserver.auxserver = coreserver.CoreAuxServer(aux_address, handlerclass, mainserver)
    mainserver.auxthread = threading.Thread(target=mainserver.auxserver.start)
    mainserver.auxthread.daemon = True
    mainserver.auxthread.start()
    return mainserver.auxserver


def banner():
    """ Output the program banner printed to the terminal or log file.
    """
    sys.stdout.write("CORE daemon v.%s started %s\n" % (constants.COREDPY_VERSION, time.ctime()))
    sys.stdout.flush()


def cored(cfg=None):
    """ Start the CoreServer object and enter the server loop.
    """
    host = cfg["listenaddr"]
    port = int(cfg["port"])
    if host == "" or host is None:
        host = "localhost"
    try:
        server = coreserver.CoreServer((host, port), corehandlers.CoreRequestHandler, cfg)
    except Exception, e:
        sys.stderr.write("error starting main server on:  %s:%s\n\t%s\n" % (host, port, e))
        sys.stderr.flush()
        sys.exit(1)
    closeonexec(server.fileno())
    sys.stdout.write("main server started, listening on: %s:%s\n" % (host, port))
    sys.stdout.flush()

    udpserver = startudp(server, (host, port))
    closeonexec(udpserver.fileno())

    auxreqhandler = cfg["aux_request_handler"]
    if auxreqhandler:
        try:
            handler, auxport = auxreqhandler.rsplit(":")
            auxserver = startaux(server, (host, int(auxport)), handler)
            closeonexec(auxserver.fileno())
        except Exception as e:
            raise ValueError, "invalid auxreqhandler:(%s)\nError: %s" % (auxreqhandler, e)

    server.serve_forever()


def cleanup():
    while coreserver.CoreServer.servers:
        server = coreserver.CoreServer.servers.pop()
        server.shutdown()


atexit.register(cleanup)


def sighandler(signum, stackframe):
    print >> sys.stderr, "terminated by signal:", signum
    sys.exit(signum)


signal.signal(signal.SIGHUP, sighandler)
signal.signal(signal.SIGINT, sighandler)
signal.signal(signal.SIGPIPE, sighandler)
signal.signal(signal.SIGTERM, sighandler)
signal.signal(signal.SIGUSR1, sighandler)
signal.signal(signal.SIGUSR2, sighandler)


def logrotate(stdout, stderr, stdoutmode=0644, stderrmode=0644):
    def reopen(fileno, filename, mode):
        err = 0
        fd = -1
        try:
            fd = os.open(filename,
                         os.O_WRONLY | os.O_CREAT | os.O_APPEND, mode)
            os.dup2(fd, fileno)
        except OSError as e:
            err = e.errno
        finally:
            if fd >= 0:
                os.close(fd)
            return err

    if stdout:
        err = reopen(1, stdout, stdoutmode)
    if stderr:
        if stderr == stdout and not err:
            try:
                os.dup2(1, 2)
            except OSError as e:
                pass
        else:
            reopen(2, stderr, stderrmode)


def get_merged_config(filename):
    """ Return a configuration after merging config file and command-line
        arguments.
    """
    # these are the defaults used in the config file
    defaults = {"port": "%d" % enumerations.CORE_API_PORT,
                "listenaddr": "localhost",
                "pidfile": "%s/run/core-daemon.pid" % constants.CORE_STATE_DIR,
                "logfile": "%s/log/core-daemon.log" % constants.CORE_STATE_DIR,
                "xmlfilever": "1.0",
                "numthreads": "1",
                "verbose": "False",
                "daemonize": "False",
                "debug": "False",
                "execfile": None,
                "aux_request_handler": None,
                }

    usagestr = "usage: %prog [-h] [options] [args]\n\n" + \
               "CORE daemon v.%s instantiates Linux network namespace " \
               "nodes." % constants.COREDPY_VERSION
    parser = optparse.OptionParser(usage=usagestr)
    parser.add_option("-f", "--configfile", dest="configfile",
                      type="string",
                      help="read config from specified file; default = %s" %
                           filename)
    parser.add_option("-d", "--daemonize", dest="daemonize",
                      action="store_true",
                      help="run in background as daemon; default=%s" % \
                           defaults["daemonize"])
    parser.add_option("-e", "--execute", dest="execfile", type="string",
                      help="execute a Python/XML-based session")
    parser.add_option("-l", "--logfile", dest="logfile", type="string",
                      help="log output to specified file; default = %s" %
                           defaults["logfile"])
    parser.add_option("-p", "--port", dest="port", type=int,
                      help="port number to listen on; default = %s" % \
                           defaults["port"])
    parser.add_option("-i", "--pidfile", dest="pidfile",
                      help="filename to write pid to; default = %s" % \
                           defaults["pidfile"])
    parser.add_option("-t", "--numthreads", dest="numthreads", type=int,
                      help="number of server threads; default = %s" % \
                           defaults["numthreads"])
    parser.add_option("-v", "--verbose", dest="verbose", action="store_true",
                      help="enable verbose logging; default = %s" % \
                           defaults["verbose"])
    parser.add_option("-g", "--debug", dest="debug", action="store_true",
                      help="enable debug logging; default = %s" % \
                           defaults["debug"])

    # parse command line options
    (options, args) = parser.parse_args()

    # read the config file
    if options.configfile is not None:
        filename = options.configfile
    del options.configfile
    cfg = ConfigParser.SafeConfigParser(defaults)
    cfg.read(filename)

    section = "core-daemon"
    if not cfg.has_section(section):
        cfg.add_section(section)
    # gracefully support legacy configs (cored.py/cored now core-daemon)
    if cfg.has_section("cored.py"):
        for name, val in cfg.items("cored.py"):
            if name == "pidfile" or name == "logfile":
                bn = os.path.basename(val).replace("coredpy", "core-daemon")
                val = os.path.join(os.path.dirname(val), bn)
            cfg.set(section, name, val)
    if cfg.has_section("cored"):
        for name, val in cfg.items("cored"):
            if name == "pidfile" or name == "logfile":
                bn = os.path.basename(val).replace("cored", "core-daemon")
                val = os.path.join(os.path.dirname(val), bn)
            cfg.set(section, name, val)

    # merge command line with config file
    for opt in options.__dict__:
        val = options.__dict__[opt]
        if val is not None:
            cfg.set(section, opt, val.__str__())

    return dict(cfg.items(section)), args


def exec_file(cfg):
    """ Send a Register Message to execute a new session based on XML or Python
    script file.
    """
    filename = cfg["execfile"]
    sys.stdout.write("Telling daemon to execute file: %s...\n" % filename)
    sys.stdout.flush()
    tlvdata = coreapi.CoreRegisterTlv.pack(RegisterTlvs.EXECUTE_SERVER.value, filename)
    msg = coreapi.CoreRegMessage.pack(MessageFlags.ADD.value, tlvdata)
    sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    sock.connect(("localhost", int(cfg["port"])))  # TODO: connect address option
    sock.sendall(msg)
    return 0


def main():
    """ Main program startup.
    """
    # get a configuration merged from config file and command-line arguments
    cfg, args = get_merged_config("%s/core.conf" % constants.CORE_CONF_DIR)
    for a in args:
        sys.stderr.write("ignoring command line argument: %s\n" % a)

    if cfg["daemonize"] == "True":
        daemonize(rootdir=None, umask=0, close_fds=False,
                  stdin=os.devnull,
                  stdout=cfg["logfile"], stderr=cfg["logfile"],
                  pidfilename=cfg["pidfile"],
                  defaultmaxfd=DEFAULT_MAXFD)
        signal.signal(signal.SIGUSR1, lambda signum, stackframe:
        logrotate(stdout=cfg["logfile"],
                  stderr=cfg["logfile"]))

    banner()
    if cfg["execfile"]:
        cfg["execfile"] = os.path.abspath(cfg["execfile"])
        sys.exit(exec_file(cfg))
    try:
        cored(cfg)
    except KeyboardInterrupt:
        pass

    sys.exit(0)


if __name__ == "__main__":
    log.setup(level=logging.INFO)

    # configure nodes to use
    node_map = nodemaps.CLASSIC_NODES
    if len(sys.argv) == 2 and sys.argv[1] == "ovs":
        node_map = nodemaps.OVS_NODES
    nodeutils.set_node_map(node_map)

    # load default services
    quagga.load_services()
    nrl.load_services()
    xorp.load_services()
    bird.load_services()
    utility.load_services()
    security.load_services()
    ucarp.load_services()
    dockersvc.load_services()
    startup.load_services()

    main()