136 lines
4.1 KiB
Python
Executable file
136 lines
4.1 KiB
Python
Executable file
#!/usr/bin/env python
|
|
"""
|
|
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 argparse
|
|
import ConfigParser
|
|
import logging
|
|
import sys
|
|
import threading
|
|
import time
|
|
|
|
from core import load_logging_config
|
|
from core import constants
|
|
from core import enumerations
|
|
from core.corehandlers import CoreHandler
|
|
from core.coreserver import CoreServer
|
|
from core.grpc.server import CoreGrpcServer
|
|
from core.misc.utils import close_onexec
|
|
|
|
load_logging_config()
|
|
|
|
|
|
def banner():
|
|
"""
|
|
Output the program banner printed to the terminal or log file.
|
|
|
|
:return: nothing
|
|
"""
|
|
logging.info("CORE daemon v.%s started %s", constants.COREDPY_VERSION, time.ctime())
|
|
|
|
|
|
def cored(cfg):
|
|
"""
|
|
Start the CoreServer object and enter the server loop.
|
|
|
|
:param dict cfg: core configuration
|
|
:param bool use_ovs: flag to determine if ovs nodes should be used
|
|
:return: nothing
|
|
"""
|
|
host = cfg["listenaddr"]
|
|
port = int(cfg["port"])
|
|
if host == "" or host is None:
|
|
host = "localhost"
|
|
|
|
try:
|
|
server = CoreServer((host, port), CoreHandler, cfg)
|
|
if cfg["ovs"] == "True":
|
|
from core.netns.openvswitch import OVS_NODES
|
|
server.coreemu.update_nodes(OVS_NODES)
|
|
except:
|
|
logging.exception("error starting main server on: %s:%s", host, port)
|
|
sys.exit(1)
|
|
|
|
# initialize grpc api
|
|
if cfg["grpc"] == "True":
|
|
api_server = CoreGrpcServer(server.coreemu)
|
|
grpc_thread = threading.Thread(target=api_server.listen)
|
|
grpc_thread.daemon = True
|
|
grpc_thread.start()
|
|
|
|
close_onexec(server.fileno())
|
|
logging.info("server started, listening on: %s:%s", host, port)
|
|
server.serve_forever()
|
|
|
|
|
|
def get_merged_config(filename):
|
|
"""
|
|
Return a configuration after merging config file and command-line arguments.
|
|
|
|
:param str filename: file name to merge configuration settings with
|
|
:return: merged configuration
|
|
:rtype: dict
|
|
"""
|
|
# these are the defaults used in the config file
|
|
defaults = {
|
|
"port": "%d" % enumerations.CORE_API_PORT,
|
|
"listenaddr": "localhost",
|
|
"xmlfilever": "1.0",
|
|
"numthreads": "1",
|
|
}
|
|
|
|
parser = argparse.ArgumentParser(
|
|
description="CORE daemon v.%s instantiates Linux network namespace nodes." % constants.COREDPY_VERSION)
|
|
parser.add_argument("-f", "--configfile", dest="configfile",
|
|
help="read config from specified file; default = %s" % filename)
|
|
parser.add_argument("-p", "--port", dest="port", type=int,
|
|
help="port number to listen on; default = %s" % defaults["port"])
|
|
parser.add_argument("-n", "--numthreads", dest="numthreads", type=int,
|
|
help="number of server threads; default = %s" % defaults["numthreads"])
|
|
parser.add_argument("--ovs", action="store_true", help="enable experimental ovs mode, default is false")
|
|
parser.add_argument("--grpc", action="store_true", help="enable grpc api, default is false")
|
|
|
|
# parse command line options
|
|
args = parser.parse_args()
|
|
|
|
# read the config file
|
|
if args.configfile is not None:
|
|
filename = args.configfile
|
|
del args.configfile
|
|
cfg = ConfigParser.SafeConfigParser(defaults)
|
|
cfg.read(filename)
|
|
|
|
section = "core-daemon"
|
|
if not cfg.has_section(section):
|
|
cfg.add_section(section)
|
|
|
|
# merge command line with config file
|
|
for opt in args.__dict__:
|
|
val = args.__dict__[opt]
|
|
if val is not None:
|
|
cfg.set(section, opt, str(val))
|
|
|
|
return dict(cfg.items(section))
|
|
|
|
|
|
def main():
|
|
"""
|
|
Main program startup.
|
|
|
|
:return: nothing
|
|
"""
|
|
# get a configuration merged from config file and command-line arguments
|
|
cfg = get_merged_config("%s/core.conf" % constants.CORE_CONF_DIR)
|
|
banner()
|
|
|
|
try:
|
|
cored(cfg)
|
|
except KeyboardInterrupt:
|
|
logging.info("keyboard interrupt, stopping core daemon")
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|