def parse_config_file(conf_file):
    conf_file = os.path.join( config.uhphome ,"uhpweb","etc","uhpweb.conf" )
    if os.path.exists(conf_file):
        options.parse_config_file(conf_file)
        gen_log.info("Load config file from %s" %(conf_file))
    else:
        gen_log.error("Cant load the config file from %s " % (conf_file))

def boreas():
    from tornado.options import define, options    
    from boreas import server
    
    define("config", help="Configuration module", type=str)
    
    define("debug", default=True, help="Enable debugging urls", type=bool)
    define("api_port", default=8001, help="API port", type=int)
    define("api_host", default='127.0.0.1', help="API host", type=str)
    define("ws_port", default=8002, help="Websocket port", type=int)
    define("ws_host", default='127.0.0.1', help="Websocket host", type=str)
    define("token_provider", default='boreas.utils.tokens:no_tokens', help="Function providing initial tokens", type=str)
    define("require_auth", default=True, help="Flag indicating if user has to authenticate", type=bool)
    
    options.parse_command_line()
    
    if options.config is None:
        # assume boreas.conf in working directory
        conf_file = 'boreas.conf'
        try:
            options.parse_config_file(conf_file)
        except IOError:
            pass # just use defaults
    else:
        conf_file = options.config
        options.parse_config_file(conf_file)
    
    server.run(options)

def main():

    # Defines
    define("port", default=8082, help="run on the given port", type=int)
    define("log_level", default="INFO", type=str,
           help="[NOTSET, DEBUG, INFO, WARNING, ERROR, CRITICAL]")
    define("dbconf", default="sqlite:///vanzilla.db", type=str,
           help="sqlalchemy db config string")
    define("mail_server", default="localhost", help="server mail", type=str)
    define("mail_from", default="", help="sender address for mail error reports", type=str)
    define("mail_to", default="", help="recipient addresses for mail error reports", type=str)
    define("root_ips", default=[], help="IPs with global access", type=list)
    define("promiscuous_load", default=False,
           help="load all apps, whether they are enabled or not", type=bool)

    options.parse_config_file("vanzilla.conf")
    options.parse_command_line()
    logging.debug(options.logging)

    # Initalising applications
    apps = AppsLoader(options)

    # Starting tornado server
    http_server = tornado.httpserver.HTTPServer(apps)
    http_server.listen(options.port)
    ioloop = tornado.ioloop.IOLoop.instance()
    tornado.autoreload.add_reload_hook(apps.reload_tasks)
    tornado.autoreload.start(ioloop)
    ioloop.start()

def config_app(config, default_options_file, replace_options):
    init_env()
    app_log.set_logging_level(app_common_const.LOG_LEVEL)

    with open(default_options_file, 'r') as f:
        default_options = json.load(f)
        if default_options:
            for option in default_options.get('global_option', {}):
                if option:
                    define(option[0], default=option[1],
                           help=option[2], type=get_builtin_type(option[3]))

    options.parse_config_file(config)

    if not check_server_config():
        raise EnvironmentError('app server config')

    if app_common_const.OPTION_LOG_PATH in options:
        app_log.define_file_logging()

    options.template_path = str(os.path.join(app_common_const.PROJECT_BASE_FOLDER, options.template_path))
    options.static_path = str(os.path.join(app_common_const.PROJECT_BASE_FOLDER, options.static_path))

    if replace_options and replace_options['port']:
        options.port = int(replace_options['port'])

    config_jinja2()

def main():
    if os.path.isfile(CONFIG_FILE_PATH):
        options.parse_config_file(CONFIG_FILE_PATH, False)
    options.parse_command_line()

    if options.help:
        return

    start_worker()
    start_web()

def parse_config_file(conf_file):
    if not conf_file:
        conf_file = "/etc/uhp/uhpweb.conf"
    conf_file_other = "etc/uhpweb.conf"
    if os.path.exists(conf_file):
        options.parse_config_file(conf_file)
        gen_log.info("Load config file from %s" %(conf_file))
    elif os.path.exists(conf_file_other):
        options.parse_config_file(conf_file_other)
        gen_log.info("Load config file from %s" %(conf_file_other))
    else:
        gen_log.error("Cant load the config file from %s or %s" % (conf_file, conf_file_other))

def parse_options_config(path):
    """从配置文件读取配置参数.

        :parameter path: 配置文件目录
    """

    options.parse_command_line()
    if options.config:
        machine = os.getenv("service_host")
        if machine:
            options.config = "%s.%s" % (options.config, machine)
        app_log.info("初始化配置文件：%s" % options.config)
        options.parse_config_file(os.path.join(path, 'web_config.conf'))

def main():
    parse_command_line()
    options.parse_config_file(join(app_root, "conf/%s/server.conf" % options.env))


    http_server = tornado.httpserver.HTTPServer(app.HelloWorldApplication(), xheaders=True)
    http_server.listen(options.port, "0.0.0.0")

    print("Starting Tornado with config {0} on http://localhost:{1}/".format(options.env, options.port))
    try:
        tornado.ioloop.IOLoop.instance().start()
    except KeyboardInterrupt:
        sys.exit(0)

def init_options():
    # maybe some options will be use before load config file
    options.parse_command_line()
    options.cfg_file = os.path.abspath(options.cfg_file)
    options.parse_config_file(options.cfg_file)
    if not options.log_path or not options.port:
        options.print_help()
        _usage()

    options.log_path = os.path.abspath(options.log_path)

    if not os.path.exists(options.log_path):
        os.makedirs(options.log_path)

def main():
    # Load config.
    options.parse_config_file(opengb.config.CONFIG_FILE)

    # Initialize database.
    ODB.initialize(options.db_file)

    # Initialize printer queues.
    to_printer = multiprocessing.Queue()
    from_printer = multiprocessing.Queue()

    # Initialize printer using queue callbacks.
    printer_callbacks = opengb.printer.QueuedPrinterCallbacks(from_printer)
    printer_type = getattr(opengb.printer, options.printer)
    printer = printer_type(to_printer, printer_callbacks,
                           baud_rate=options.baud_rate, port=options.serial_port)
    printer.daemon = True
    printer.start()

    # Initialize web server.
    install_dir = resource_filename(Requirement.parse('openGB'), 'opengb')
    static_dir = os.path.join(install_dir, 'static')
    handlers = [
        (r"/ws", WebSocketHandler, {"to_printer": to_printer}),
        (r"/api/status", StatusHandler),
        (r"/fonts/(.*)", StaticFileHandler, {"path": os.path.join(static_dir, "fonts")}),
        (r"/views/(.*)", StaticFileHandler, {"path": os.path.join(static_dir, "views")}),
        (r"/images/(.*)", StaticFileHandler, {"path": os.path.join(static_dir, "images")}),
        (r"/scripts/(.*)", StaticFileHandler, {"path": os.path.join(static_dir, "scripts")}),
        (r"/styles/(.*)", StaticFileHandler, {"path": os.path.join(static_dir, "styles")}),
        (r"/(.*)", StaticFileHandler, {"path": os.path.join(static_dir, "index.html")}),
    ]
    app = Application(handlers=handlers, debug=options.debug)
    httpServer = tornado.httpserver.HTTPServer(app)
    httpServer.listen(options.http_port)

    # Create event loop and periodic callbacks
    main_loop = tornado.ioloop.IOLoop.instance()
    printer_event_processor = tornado.ioloop.PeriodicCallback(
        lambda: process_printer_events(from_printer), 10, io_loop=main_loop)
    counter_updater = tornado.ioloop.PeriodicCallback(
        lambda: update_counters(), 60000)
    # TODO: ioloop for watchdog
    # TODO: ioloop for camera

    # Rock and roll.
    printer_event_processor.start()
    counter_updater.start()
    main_loop.start()

    return(os.EX_OK)

def getTornadoUrl():
    import socket
    from tornado.options import options
    ip = socket.gethostbyname(socket.gethostname())
    # Check config file
    SERVER_CONFIG = '/etc/domoweb.cfg'
    if not os.path.isfile(SERVER_CONFIG):
        sys.stderr.write("Error: Can't find the file '%s'\n" % SERVER_CONFIG)
        sys.exit(1)

    options.define("port", default=40404, help="Launch on the given port", type=int)
    options.parse_config_file(SERVER_CONFIG)

    return "http://%s:%s/" % (ip, options.port)

def main():
    options.parse_command_line()
    if not options.config_file is None:
        options.parse_config_file(options.config_file)
        options.parse_command_line()

    if options.client_secret:
        settings["cookie_secret"] = options.client_secret

    logging.info("Starting Tornado web server on http://localhost:%s" % options.port)
    logging.info("--data_path=%s" % options.data_path)
    logging.info("--client_host=%s" % options.client_host)
    logging.info("--authorized_users=%s" % options.authorized_users)
    logging.info("--mongo_storage_uri=%s" % options.mongo_storage_uri)
    logging.info("--mongo_storage_db=%s" % options.mongo_storage_db)
    logging.info("--mongo_rows_limit=%s" % options.mongo_rows_limit)

    if not options.config_file is None:
        logging.info("--config_file=%s" % options.config_file)

    if not options.github_repo_api_url is None:
        logging.info("--github_repo_api_url=%s" % options.github_repo_api_url)
        logging.info("--github_project_root=%s" % options.github_project_root)
        logging.info("--github_branches_root=%s" % options.github_branches_root)
        logging.info("--github_postproc_cmd=%s" % options.github_postproc_cmd)
        logging.info("--github_git_cmd=%s" % options.github_git_cmd)
        logging.info("--github_branches_json_path=%s" % options.github_branches_json_path)
        logging.info("Starting GitHub Web Hook at http://localhost:%s/gitWebHook" % options.port)

    MongoDbQueryHandler.datastores = parse_datastore_configuration()
    TabixLookupHandler.tabix_file_map = parse_tabix_lookup_configuration()
    
    application = tornado.web.Application([
        (r"/", MainHandler),
        (r"/auth/signin/google", GoogleOAuth2Handler),
        (r"/auth/signin/google/oauth2_callback", GoogleOAuth2Handler),
        (r"/auth/signout/google", GoogleSignoutHandler),
        (r"/auth/whoami", WhoamiHandler),
        (r"/auth/providers", AuthProvidersHandler),
        (r"/datastores", MongoDbQueryHandler),
        (r"/datastores/(.*)", MongoDbQueryHandler),
        (r"/data?(.*)", LocalFileHandler),
        (r"/storage/(.*)", MongoDbStorageHandler),
        (r"/collections/(.*)", MongoDbCollectionsHandler),
        (r"/tabix/(\w+)/(X|Y|M|\d{1,2})/(\d+)", TabixLookupHandler),
        (r"/tabix/(\w+)/(X|Y|M|\d{1,2})/(\d+)/(\d+)", TabixLookupHandler),
        (r"/gitWebHook?(.*)", GitWebHookHandler)
    ], **settings)
    application.listen(options.port, **server_settings)
    tornado.ioloop.IOLoop.instance().start()

def parse_config_options():
    ''' Load up all of the cli and config file options '''
    app_root = os.path.abspath(__file__)
    os.chdir(os.path.dirname(app_root))
    tornado.log.enable_pretty_logging()
    try:
        options.parse_command_line()
        if os.path.isfile(options.config):
            logging.debug("Parsing config file `%s`",
                          os.path.abspath(options.config))
            options.parse_config_file(options.config)
        options.parse_command_line()  # CLI takes precedence
    except Error as error:
        logging.critical(str(error))
        sys.exit()

def load_config():
    """
    Use default.conf as the definition of options with default values
    using tornado.options.define.
    Then overrides the values from: local.conf.
    This mapping allows to access the application configuration across the
    application.

    NOTE:
    logging in load_config() is not going to work because logging is
    configured only when tornado.options.parse_command_line(final=True)
    """
    define_options()
    local_conf = os.path.join(CONF_DIR, 'local.conf')
    if os.path.isfile(local_conf):
        options.parse_config_file(local_conf, final=False)

def run(args):
    define_global_options()
    options.parse_command_line(['server'] + args, final=False)
    config_file = path.expanduser(options.config)
    if path.isfile(config_file):
        options.parse_config_file(config_file, final=False)
    _set_x_display(options)
    options.run_parse_callbacks()
    try:
        chmod(options.tmp_dir, 0o755)
    except (NotImplementedError, OSError, IOError) as e:
        gen_log.warn('Unable to chmod tmp dir: {}'.format(e))

    if path.isfile(config_file):
        gen_log.info('Config loaded from {}'.format(config_file))
    build_app()
    IOLoop.instance().start()

def bootstrap(config_file=None):
    options.define('config', config_file or tinyurld.default_config, type=str, help='Config file path')
    options.define('host', '0.0.0.0', type=str, help='Ip address for bind')
    options.define('port', 8888, type=int, help='application port')
    options.define('autoreload', False, type=bool,
                   help='Autoreload application after change files', group='application')
    options.define('debug', False, type=bool, help='Debug mode', group='application')
    options.define('mongo_host', type=str, help='MongoDB host IP', group='mongodb')
    options.define('mongo_port', 27017, type=int, help='MongoDB port', group='mongodb')
    options.define('mongo_user', None, type=str, help='MongoDB user', group='mongodb')
    options.define('mongo_password', None, type=str, help='MongoDB user password', group='mongodb')
    options.parse_command_line()

    options.parse_config_file(options.config)

    # override options from config file with command line args
    options.parse_command_line()
    tornado.log.app_log.info('Read config: {}'.format(options.config))

def start(prefix, settings, modules, routes, known_exceptions, **kwargs):
    """starts the tornado application.
    :param prefix: the url prefix
    :param settings: the user defined settings
    :param modules: the modules to load
    :param handlers: the list of url routes (url, handler)
    :param known_exceptions: the mapping of known exceptions to HTTP codes
    :param kwargs: the tornado application arguments
    """
    from tornado.options import options

    options.define("config", type=str, help="path to config file",
                   callback=lambda p: options.parse_config_file(p, final=False))
    options.define("port", default=8000, help="listening port", type=int)
    options.define("address", default='127.0.0.1', help="listening address")

    options.add_parse_callback(log.patch_logger)

    loop = _get_event_loop()
    modules_registry = ModulesRegistry(loop.asyncio_loop, log.gen_log)

    for module in modules:
        modules_registry.lazy_load(module, options)

    for opt in settings:
        options.define(**opt)

    options.parse_command_line(final=True)

    if not prefix.endswith('/'):
        prefix += '/'

    kwargs.update(options.group_dict('application'))
    kwargs.setdefault('default_handler_class', handler.DefaultHandler)
    # prevent override this option
    kwargs['known_exceptions'] = known_exceptions
    kwargs['modules'] = modules_registry

    handlers = []
    for uri, methods in routes:
        log.app_log.info("add resource: %s", uri)
        handlers.append((_concat_url(prefix, uri), compile_handler(methods)))

    app = web.Application(handlers, **kwargs)
    app.listen(options.port, options.address, xheaders=True)

    signal.signal(signal.SIGTERM, lambda *x: loop.stop())
    log.app_log.info("start listening on %s:%d", options.address, options.port or 80)

    try:
        loop.start()
    except (KeyboardInterrupt, SystemExit):
        pass

    loop.close()
    log.app_log.info("gracefully shutdown.")

def main():
    options.define('environment')
    options.define('templatesPath')
    options.define('staticPath')
    options.define('locale')
    options.define('port', type=int)
    options.define('login_url')
    options.define('attachmentPath')
    options.define('avatarPath')
    options.define('repositoryPath')
    options.define('debug', type=bool)
    options.define('cache_enabled', type=bool)
    options.define('redis', type=dict)
    options.define('smtp', type=dict)
    options.define('sqlalchemy_engine')
    options.define('sqlalchemy_kwargs', type=dict)
    options.define('allowImageFileType', type=set)
    options.define('allowDocumentFileType', type=dict)
    options.define('salt')
    options.define('domain')
    options.define('jsonFilter', type=set)
    options.define('assets_path')

    options.parse_config_file("conf/config.conf")
    ui_modules = {
        'uimodle' : UIModule,
    }

    settings = dict(
        cookie_secret = "__TODO:_Generate_your_own_random_value_here__",
        template_path = os.path.join(os.path.dirname(__file__), options.templatesPath),
        static_path = os.path.join(os.path.dirname(__file__), options.staticPath),
        assets_path = os.path.join(os.path.dirname(__file__), options.assets_path),
        ui_methods = ui_methods,
        xsrf_cookies = False,
        autoescape = None,
        debug = True,
        login_url = options.login_url,
        ui_modules = ui_modules,
    )
    app = Application(settings)
    app.listen(options.port)
    tornado.ioloop.IOLoop.instance().start()

def main():
    if os.path.isfile(SERVER_CONF_NAME):
        options.parse_config_file(SERVER_CONF_NAME)

    options.parse_command_line()

    if options.login_password is None:
        print('please configure login password first')
        sys.exit(-1)

    app = App()

    server = HTTPServer(app, xheaders=True)
    server.listen(options.port)

    try:
        ioloop.IOLoop.instance().start()
    except KeyboardInterrupt:
        print('Exit by KeyboardInterrupt')

 def init_options(self):
     define("port", type=int, help="The port on which this app will listen.")
     define("static_path", help="Location of static assets.")
     define("template_path", help="Location of template files.")
     define("db_name", help="Name of database.")
     define("db_path", help="Path to mongodb instance.")
     define("cookie_secret", help="Cookie secret key")
     define("xsrf_cookies", default=True)
     define("config", help="Path to config file", callback=lambda path: options.parse_config_file(path, final=False))
     options.parse_command_line()