Example #1
0
def load_config_file():
    try:
        options.parse_config_file(local('config.cfg'), final=False)
    except Exception as e:
        logging.error(str(e))

    options.parse_command_line()
Example #2
0
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()
Example #3
0
def main():
    if os.path.isfile("config/server.conf"):
        options.parse_config_file("config/server.conf")
    else:
        logging.warning("server.conf is not found.")
    options.parse_command_line()

    url = urlparse(options.ws_url)
    if options.origin:
        pass
    elif url.scheme == "wss":
        options.origin = urlunparse(("https", url.netloc, "", "", "", ""))
    else:
        options.origin = urlunparse(("http", url.netloc, "", "", "", ""))

    app = web.Application([
        (urlparse(options.ws_url).path, WebSocketHandler),
        (r"/(index\.html)?", IndexHandler),
        (r"/(.*)", web.StaticFileHandler, {
            "path": os.path.join(os.getcwd(), options.static_dir)
        }),
    ])
    if options.ssl_key:
        server = httpserver.HTTPServer(app,
                                       ssl_options={
                                           "certfile": options.ssl_crt,
                                           "keyfile": options.ssl_key,
                                       })
    else:
        server = httpserver.HTTPServer(app)

    server.listen(options.port)
    ioloop.IOLoop.instance().start()
Example #4
0
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()
Example #5
0
def parse_config():
    options.parse_command_line()
    if options.config != "":
        logger.info("parse config from config file: {config}".format(
            config=options.config))
        options.parse_config_file(options.config)

    if options.slack_token == "":
        logger.error("slack token is required!!")
        sys.exit(1)

    if options.models_path == "":
        logger.error("models path is required!!")
        sys.exit(1)

    if options.db_path == "":
        logger.info(
            "path of database is not set, use the default db path: {path}".
            format(path=DEFAULT_DB_PATH))
        options.db_path = DEFAULT_DB_PATH

    mg.MODELS_PATH = options.models_path
    alert.SLACK_TOKEN = options.slack_token
    job.REPORT_ADDRESS = options.address

    logger.info("config: {config}".format(config=options.items()))
Example #6
0
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)
Example #7
0
def parse_command_line(extra_args_func=None):
    """
    Parse command line arguments for any Pyaiot application.
    """
    if not hasattr(options, "config"):
        define("config", default=None, help="Config file")

    if not hasattr(options, "broker_host"):
        define("broker_host", default="localhost", help="Broker host")
    if not hasattr(options, "broker_port"):
        define("broker_port", default=8002, help="Broker websocket port")

    if not hasattr(options, "key_file"):
        define("key_file", default=DEFAULT_KEY_FILENAME, help="Secret and private keys filename.")
    if not hasattr(options, "debug"):
        define("debug", default=False, help="Enable debug mode.")

    if extra_args_func is not None:
        extra_args_func()

    options.parse_command_line()
    if options.config:
        options.parse_config_file(options.config)
    # Parse the command line a second time to override config file options
    options.parse_command_line()
Example #8
0
    def get_app(self):

        self.app = Application
        s_file = os.path.abspath(
            os.path.join(os.path.dirname(__file__), "settings.conf"))
        options.parse_config_file(s_file)
        return self.app()
Example #9
0
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))
Example #10
0
    def __init__(self):
        """
        Constructor
        """
        options.parse_command_line()
        if options.config_name:
            config_to_read = '%s/%s' % (os.getcwd(), options.config_name)
        else:
            config_to_read = '%s/%s' % (os.getcwd(), 'config.py')
        logger.debug('path to config: %s' % config_to_read)
        options.parse_config_file(config_to_read)
        # override options from config with command line options
        options.parse_command_line()

        self.__db_engine = None  # engine for db_session
        self.__db_session = None  # singleton of SQLAlchemy connections pool
        self.__redis_session = None  # singleton of Redis connections pool
        self.__redis_scheme = redis_scheme  # Redis key mapping
        self.__thread_pool = None  # thread pool for doing some jobs in background
        self.__custom_response_headers = dict()  # custom headers, which will be mixed in every response
        self.__endpoints = list()  # list of Tornado routes with handler classes, permissions
        self.__handler_docs = dict()  # all docstrings of all methods of all routes
        self.__handler_validators = dict()  # all validators (UrlParser instance) of all methods of all routes
        self.__started = False

        # make singleton of thread pool
        self.__make_thread_pool()

        # init singleton of DB connections pool
        self.__make_db_session()

        # init singleton of Redis connections pool
        self.__make_redis_session()
Example #11
0
def parse_command_line():
    """Parse command line arguments for CoAP gateway application."""
    if not hasattr(options, "config"):
        define("config", default=None, help="Config file")
    if not hasattr(options, "broker_host"):
        define("broker_host", default="localhost", help="Pyaiot broker host")
    if not hasattr(options, "broker_port"):
        define("broker_port", default=8000, help="Pyaiot broker port")
    if not hasattr(options, "mqtt_host"):
        define("mqtt_host", default=MQTT_HOST, help="Gateway MQTT broker host")
    if not hasattr(options, "mqtt_port"):
        define("mqtt_port", default=MQTT_PORT, help="Gateway MQTT broker port")
    if not hasattr(options, "max_time"):
        define("max_time",
               default=MAX_TIME,
               help="Maximum retention time (in s) for MQTT dead nodes")
    if not hasattr(options, "key_file"):
        define("key_file",
               default=DEFAULT_KEY_FILENAME,
               help="Secret and private keys filename.")
    if not hasattr(options, "debug"):
        define("debug", default=False, help="Enable debug mode.")
    options.parse_command_line()
    if options.config:
        options.parse_config_file(options.config)
    # Parse the command line a second time to override config file options
    options.parse_command_line()
Example #12
0
def main():
    options.parse_config_file(config_file, final=False)
    options.parse_command_line()

    sanity_check(options)

    settings = dict(
        compress_response=True,
        cookie_secret=options.cookie_secret,
        debug=options.debug,
        login_url=options.login_url,
        static_handler_class=web.JsonAwareStaticFileHandler,
        static_path='static/',
        xheaders=True,
    )

    routes = initialize(options.database)

    application = Application(routes, **settings)

    server = HTTPServer(application, xheaders=True)
    server.bind(options.port)
    server.start(1)  # Forks multiple sub-processes
    logging.info('Configured for "%s"' % environment)
    logging.info('Running on port %s' % options.port)
    IOLoop.current().start()
Example #13
0
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))
Example #14
0
def _load_conf():
    options.parse_command_line()
    _update_collon_with_cwd()

    if pathlib.Path(options.conf).is_file():
        options.parse_config_file(options.conf)
        logging.info("load conf from '{}'.".format(options.conf))
    elif EXAMPLE_CONF.is_file():
        options.parse_config_file(EXAMPLE_CONF)
        logging.warning("load example conf from '{}'.".format(EXAMPLE_CONF))
    else:
        logging.error("example conf '{}' is not found.".format(EXAMPLE_CONF))
    _update_collon_with_cwd()

    options.parse_command_line()
    _update_collon_with_cwd()

    if pathlib.Path(options.mail_body_file).is_file():
        with open(options.mail_body_file) as f:
            options.mail_body = f.read()
            logging.info("load mail body from '{}'.".format(options.mail_body_file))
    elif pathlib.Path(EXAMPLE_MAIL_BODY_FILE).is_file():
        with open(EXAMPLE_MAIL_BODY_FILE) as f:
            options.mail_body = f.read()
            logging.warning("load example mail body from '{}'.".format(EXAMPLE_MAIL_BODY_FILE))
    else:
        logging.error("example mail body file '{}' is not found.".format(EXAMPLE_MAIL_BODY_FILE))
Example #15
0
 def load_options(self):
     options.logging = None
     try:
         options.parse_config_file(self.config_file, final=False)
     except FileNotFoundError as e:
         print("Error, config file {} not found".format(self.config_file))
         sys.exit(1)
     options.parse_command_line()
Example #16
0
    def __init__(self):
        options.parse_config_file('settings.py')
        handlers = [('/', ChatHandler)]

        factory = make_session_factory(options.DB_URL)
        super().__init__(session_factory=factory,
                         handlers=handlers,
                         debug=True)
def main():
    options.parse_config_file("webssh.conf")
    parse_command_line()
    django.setup()
    server = tornado.httpserver.HTTPServer(Application())
    server.listen(options.port)
    IOLoop.instance().start()
    tornado.ioloop.IOLoop.instance().start()
Example #18
0
def main():
    init_config()
    options.parse_config_file(os.path.join(BASE_DIR, "webssh.conf"))

    http_server = httpserver.HTTPServer(Application())
    http_server.listen(options.port, address="0.0.0.0")
    IOLoop.instance().start()
    welcome(options.port)
    ioloop.IOLoop.instance().start()
Example #19
0
 def connect(cls, dbname):
     db = None
     config.init_config()
     options.parse_config_file('pacado.conf')
     if dbname == 'meta':
         db = MongoClient(options.mongo_meta_uri)['metadata']
     if dbname == 'cnyb':
         db = MongoClient(options.mongo_cnyb_uri)['cnyb']
     return db
Example #20
0
 def load_options(self):
     options.logging = None
     options.parse_command_line(final=False)
     try:
         options.parse_config_file(options.config_file)
     except FileNotFoundError as e:
         application_log.critical(
             f"Error, config file {options.config_file} not found")
         sys.exit(1)
Example #21
0
def main():
    options.parse_config_file("server.ini", final=False)
    options.parse_command_line()
    log.setup()
    init()

    make_app().listen(8888)

    IOLoop.current().start()
Example #22
0
def init_options():
    # maybe some options will be use before load config file
    options.parse_command_line()
    options.parse_config_file(options.cfg_file)
    if not options.log_root_path or not options.port:
        options.print_help()
        _usage()
    options.log_root_path = _check_dir_tail(options.log_root_path)
    options.log_path = '%s/%d' % (options.log_root_path, options.port)
    _mkdir(options.log_path)
Example #23
0
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()
Example #24
0
def main():
    options.parse_config_file("server.ini", final=False)
    options.parse_command_line()
    session_factory = make_session_factory(options.database_url)
    m.DeclarativeBase.metadata.create_all(session_factory.engine)
    session = session_factory.make_session()
    fix_user_create_at(session)
    fix_queston_create_at(session)
    fix_job_create_at(session)
    session.commit()
    session.close()
Example #25
0
 def set_configs(self):
     """
     Name (define) the configuration items and load their values from configuration file
     """
     for config_item in ['tag_creds', 'encrypt_tag']:
         define(config_item)
     # Get configuration values from configuration filescript_name = path.basename(__file__)
     script_path = path.abspath(path.realpath(__file__))
     script_dir = path.split(script_path)[0]
     config_path = path.abspath(
         path.join(script_dir, 'model/EmsgEncrypt.conf'))
     options.parse_config_file(config_path)
Example #26
0
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))
Example #27
0
def main():
    options.parse_config_file(config_file, final=False)
    options.parse_command_line()

    sanity_check(options)

    settings = dict(
        compress_response=True,
        cookie_secret=options.cookie_secret,
        debug=options.debug,
        login_url=options.login_url,
        static_handler_class=web.JsonAwareStaticFileHandler,
        static_path='static/',
        xheaders=True,
    )

    routes = initialize(options.database)

    application = Application(routes, **settings)

    try:
        server_https = HTTPServer(
            application,
            xheaders=True,
            ssl_options={
                "certfile":
                "/etc/letsencrypt/live/api-usability.teco.edu/cert.pem",
                "keyfile":
                "/etc/letsencrypt/live/api-usability.teco.edu/privkey.pem",
            })
        server_https.bind(options.port)
        server_https.start(1)  # Forks multiple sub-processes
    except ValueError as exc:
        logging.error('HTTPS server couldn\'t be started %s', exc)
        logging.info('HTTP server started')
        server_https = HTTPServer(application, xheaders=True)

    logging.info('Configured HTTPS for "%s"' % environment)
    logging.info('Running HTTPS server on port %s' % options.port)

    server_http = HTTPServer(
        Application([(r"/(.*)", StaticFileHandler, {
            "path": './static/templates/',
            "default_filename": "https_required.html"
        })], **settings))
    server_http.bind(80)
    server_http.start(1)

    logging.info('Configured HTTP for "%s"' % environment)
    logging.info('Running HTTP server on port %d' % 80)

    IOLoop.current().start()
Example #28
0
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))
Example #29
0
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)
Example #30
0
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'))
Example #31
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)
Example #32
0
def parse_config():
    options.parse_command_line()
    if options.config != "":
        logger.info("parse config from config file: {config}".format(
            config=options.config))
        options.parse_config_file(options.config)

    if options.slack_token == "":
        logger.error("slack token is required!!")
        sys.exit(1)

    alert.SLACK_TOKEN = options.slack_token
    logger.info("config: {config}".format(config=options.items()))
Example #33
0
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'))
Example #34
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)
Example #35
0
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)
Example #36
0
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)
Example #37
0
File: svc.py Project: kleisb/Addama
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()
Example #38
0
def service_core_running():
    import os
    BASE_DIRS = os.path.dirname(__file__)
    config_file = os.path.join(BASE_DIRS, "./config.py")
    # try:
    # options.parse_command_line()
    options.parse_config_file(config_file)
    http_server = HTTPServer(DF_Tornado_Application())
    # http_server.listen(options.SERVER_PORT, options.SERVER_HOST)
    http_server.bind(config.options.SERVER_PORT, config.options.SERVER_HOST)
    print("[NOTICE] Development server is running at http://%s:%s" %
          (config.options.SERVER_HOST, config.options.SERVER_PORT))
    print("[NOTICE] Quit the server with Control-C")
    IOLoop.instance().start()
Example #39
0
def main():
    # Load config.
    options.parse_config_file(opengb.config.CONFIG_FILE)

    # Initialize database.
    OGD.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,
                           lcd_gpio_pin=options.lcd_gpio_pin)
    printer.daemon = True
    printer.start()

    # Initialize web server.
    # Backend handler is always required.
    handlers = [(r"/ws", WebSocketHandler, {"to_printer": to_printer})]
    # Frontend-specfic handlers added if required.
    try:
        handlers += get_frontend_handlers(options.frontend)
    except IOError as e:
        LOGGER.exception(e)
        LOGGER.warn('No frontend will be served.')
    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)
Example #40
0
async def main():
    tornado.options.parse_command_line()
    options.parse_config_file(os.path.join(APP_ROOT, "config/app.conf"))

    s = "s" if options.ssl_enabled else ""
    log.info(f"Starting Tornado on http{s}://localhost:{options.port}/")

    try:
        Database = databases.database_types[options.db_type.lower()]
    except KeyError:
        log.execption("ERROR: Invalid db_type specified. Check valid database types in the docs.")
        return

    log.info("Connecting to database...")

    async with Database() as db:
        app = Application(db)
        db.app = app

        if not await db.is_initialized():
            log.info("Database not initialized, creating roles and Admin user...")

            roles = []
            roles.append(Role.partial(name="Admin", permissions=Permissions.all(), state=app))

            permissions = Permissions.default()
            permissions.manage_files = True
            permissions.manage_invites = True
            roles.append(Role.partial(name="Trusted", permissions=permissions, state=app))

            roles.append(Role.partial(name="User", permissions=Permissions.default(), state=app))

            available_chars = string.ascii_letters + string.digits
            password = "".join(random.choice(available_chars) for i in range(5))
            hashed_password = await User.hash_password(password)
            user = User.partial(username="******", hashed_password=hashed_password, role_id=None, state=app)

            await db.initialize(roles, user)

            log.info(f"Your new admin username is Admin and your password is {password}.")

        global http_server

        http_server = tornado.httpserver.HTTPServer(app)
        http_server.listen(options.port)

        log.info("Ready to go.")

        await shutdown_event.wait()
Example #41
0
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 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()
Example #43
0
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()
Example #44
0
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)
Example #45
0
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()
Example #46
0
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))
Example #47
0
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.")
Example #48
0
File: app.py Project: mqshen/MyTask
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()
Example #49
0
 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()
Example #50
0
File: main.py Project: CzBiX/ss-web
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')
Example #51
0
define('test_time', default=60, help='Time of test running in seconds')
define('clients_number', default=100, help='Number of clients for concurrent testing')
define('queries_number', default=60, help='Number of queries to database per client')
define('conf_file', default=None, help='Path to configuration file')
define('rw_ratio', default=0.2, help='Ratio read_req/write_req')
define('debug', default=False, help='Show debug messages')
define('log_suffix', default=None, help='Suffix for log file')
define('log_params', default=True, help='Add run params to log name [test_time, clients_number, queries_number]')
define('truncate', default=True, help='Remove all data from table before start')
define('init_records', default=10000, help='Initiate test table with number of records')


logger = logging.getLogger()
options.parse_command_line()
if options.conf_file is not None and os.path.exists(options.conf_file):
    options.parse_config_file(options.conf_file)

if options.debug:
    logger.setLevel(logging.DEBUG)

csv_file = None
chunc_start = 0


def log_func(func_tp):
    def innter(func_):
        def wrapper(*args, **kwargs):
            start_time = datetime.now()
            success = True
            try:
                func_(*args, **kwargs)
Example #52
0
from tornado.options import options
from tornado.testing import AsyncHTTPTestCase
from tornado.escape import json_encode, json_decode

from todotxt_web import server
from todotxt_web import todo_txt

SECRET_FILE = 'test/secret'
PASSWORD_FILE = 'test/password'
PASSWORD = "******"

server.update_password(PASSWORD_FILE, PASSWORD, server.get_secret(SECRET_FILE))

APP = server.make_app(secret_file=SECRET_FILE, password_file=PASSWORD_FILE)
options.parse_config_file(os.path.join('test', 'config.py'))


class TestHandlerBase(AsyncHTTPTestCase):
    """TestCase with initialized app"""

    def get_app(self):
        return APP      # this is the global app that we created above.


class TestTodoHandler(TestHandlerBase):

    def setUp(self):
        super(TestTodoHandler, self).setUp()
        self.todo = todo_txt.TodoTxt(options.todo_file)
        self.todo.add('The first task')
Example #53
0
def run():
    options.parse_command_line()

    if options.config:
        options.parse_config_file(options.config)

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

    if os.getuid() == 0 and options.user:
        pw = pwd.getpwnam(options.user)
        uid, gid = pw.pw_uid, pw.pw_gid
        log.info("Changind user to %s [%s:%s]", options.user, uid, gid)
        os.setgid(uid)
        os.setuid(uid)

    try:
        if not all(f(options.storage) for f in (os.path.exists, os.path.isdir)):
            log.info('Creating new package storage directory: "%s"', options.storage)
            os.makedirs(options.storage)

        def on_interrupt(*args):
            log.warning("Receiving interrupt signal. Application will be stopped.")
            exit(errno.EINTR)

        log.debug("Preparing signal handling")
        for sig in (signal.SIGINT, signal.SIGTERM, signal.SIGQUIT):
            signal.signal(sig, on_interrupt)

        def handle_pdb(sig, frame):
            import pdb
            pdb.Pdb().set_trace(frame)

        if options.debug:
            signal.signal(signal.SIGUSR2, handle_pdb)

        log.debug("Creating application instance")
        app = create_app(
            options.debug,
            options.secret,
            options.gzip,
        )

        log.debug("Creating IOLoop instance.")
        io_loop = IOLoop.current()

        io_loop.run_sync(lambda: init_db(options.database))

        if not (os.path.exists(options.cache_dir) and os.path.isdir(options.cache_dir)):
            os.makedirs(options.cache_dir)

        Cache.CACHE_DIR = options.cache_dir

        log.info("Init thread pool with %d threads", options.pool_size)
        handlers.base.BaseHandler.THREAD_POOL = futures.ThreadPoolExecutor(options.pool_size)

        AsyncHTTPClient.configure(None, max_clients=options.max_http_clients)

        PYPIClient.configure(
            options.pypi_server,
            handlers.base.BaseHandler.THREAD_POOL
        )

        pypi_updater = PeriodicCallback(PYPIClient.packages, HOUR * 1000, io_loop)

        io_loop.add_callback(PYPIClient.packages)
        io_loop.add_callback(pypi_updater.start)

        log.info("Starting server http://%s:%d/", options.address, options.port)
        http_server = HTTPServer(app, xheaders=options.proxy_mode)
        http_server.listen(options.port, address=options.address)

        log.debug('Setting "%s" as storage', options.storage)
        PackageFile.set_storage(options.storage)

        log.debug("Starting main loop")
        io_loop.start()
    except Exception as e:
        log.fatal("Exception on main loop:")
        log.exception(e)
        exit(1)
    else:
        exit(0)
Example #54
0
from config_center import make_app

from config_center.handler import IndexHandler,CreateHandler,ShowHandler,EditHandler,DeleteHandler

router = [
    (r'/', IndexHandler),
    (r'/create',CreateHandler),
    (r'/edit', EditHandler),
    (r'/show',ShowHandler),
    (r'/delete',DeleteHandler),
]


if __name__ == '__main__':
    if os.path.exists('/etc/confcenter-api.conf'):
        options.parse_config_file('/etc/confcenter-api.conf')
    if os.path.exists('./confcenter.conf'):
        options.parse_config_file('./confcenter.conf')
    options.parse_command_line()

    template_path = os.path.join(os.path.dirname(__file__), "templates")
    static_path = os.path.join(os.path.dirname(__file__), "static")
    app = make_app(router,template_path=template_path,static_path=static_path,debug=True)
    app.listen(options.port,address=options.bind)

    try:
        app.zk.start()
        IOLoop.current().start()
    except KeyboardInterrupt:
        app.zk.stop()
        IOLoop.current().stop()
Example #55
0
            login_url = "/auth/signin",
            cookie_secret = options.secret_key,
            xsrf_cookie = True
        )
        
        self.database = DatabaseManager(options.db_host, options.db_user, options.db_pass,
                options.db_dbbs, charset = "cp1250")

def validate_option(dict, key):
    try:
        value = dict[key]
        if value == None: return False
    except KeyError: return False
    return True

if __name__ == "__main__":
    options.parse_command_line()
    if options.config is not None: options.parse_config_file(options.config)

    # wymagana konfiguracja aplikacji
    opt = options.as_dict()
    assert validate_option(opt, "db_host")
    assert validate_option(opt, "db_user")
    assert validate_option(opt, "db_pass")
    assert validate_option(opt, "db_dbbs")

    app = ClassRegisterApplication()
    app.listen(options.port)
    IOLoop.instance().start()

Example #56
0
File: app.py Project: zhaosir/Demo
        setting = {
            'debug' : options.debug,
            'gzip' : True
        }

        tornado.web.Application.__init__(self,**setting)
        self.add_handlers(host,urls)
        

if __name__ == '__main__':
    define('port',default=8500)
    define('debug',default=False)
    define('t',default=1)
    define('db', default=0)
    define('host', multiple=True)
    options.parse_config_file('./setting.conf')
    options.parse_command_line()

    if options.t == 1:
        app = App()
        http_server = tornado.httpserver.HTTPServer(app)
        http_server.bind(options.port)
        http_server.start()
        tornado.ioloop.IOLoop.instance().start()
    elif options.t == 2:
        setting = {
            'debug' : options.debug
        }
        app = tornado.web.Application([
            ('/test',testHandler)    
            ],**setting)
Example #57
0
def main():
    options.parse_command_line()
    options.parse_config_file('settings.conf')
    http_server = tornado.httpserver.HTTPServer(Application(options))
    http_server.listen(options.port)
    tornado.ioloop.IOLoop.instance().start()
Example #58
0
                        pairs.insert(pairs.index(_pair), (period, graph_types_all))
                        pairs.remove(_pair)


define('server')
define('sites', default=[], type=list)
define('rrd_file', default=None, callback=None)
define('rrd_enabled', default=False, callback=None)
define('graphics', default={'S':(['6h'],[MON_GRAPH_CPU_MAX,
                                         MON_GRAPH_BYTES_MAX,
                                         MON_GRAPH_DURATION_MAX,
                                         MON_GRAPH_DESKTOP_MAX,
                                         MON_GRAPH_TRANS_MAX,
                                         MON_GRAPH_TRANS_UNIQUE_MAX,])}, callback=_verify_graph)

options.parse_config_file("mynotes.conf", final=False)
_server=options.server
_known_instances = options.sites
_instances = []


if _known_instances and options.server:
    for (_server, _port) in _known_instances:
        if _server == options.server and _port not in _instances:
            _instances.append(_port)

for _port in _instances:
    if not (options.rrd_enabled and RRD):
        break
    instance_conf = os.path.extsep.join(((os.path.join('instance', str(_port))),'conf'))
    if instance_conf and os.access(instance_conf, os.F_OK):
Example #59
0

define('port', default=8888, help="run on the given port", type=int)
define('address', default='192.168.X.X', help="run on the address", type=str)


class IndexHandler(RequestHandler):
    def get(self, room):
        self.render('index.html')


def make_app():
    sock_router = SockJSRouter(WebSocketHandler, '/websocket')
    return Application(
        sock_router.urls +
        [
            (r'/static/(.*)', StaticFileHandler, {'path': 'static'}),
            url(r'/(.*)', IndexHandler),
        ]
    )


def main():
    app = make_app()
    app.listen(options.port)  # , options.address)
    IOLoop.current().start()

if __name__ == '__main__':
    options.parse_config_file('server.conf')
    main()
Example #60
0
define('server', default='TornadoServer/{}'.format(tornado.version),
       help='The Server header returned with HTTP responses.')
define('port', type=int, default=8888,
       help='The port on which this app will listen.')
define('address', type=str, help='The address on which this app will listen')
define('login_url', default='/login', help='Path to login form')
define('template_path', help='Location of template files.')
define('static_path', help='Location of static files.')
define('cookie_secret', help='Cookie secret key')
define('xsrf_cookies', default=True)
define('x_frame_options', default='DENY')
define('x_xss_protection', default=1)
define('x_content_type_options', default='nosniff')
define('debug', default=True)
define('config', help='Path to config file',
       callback=lambda path: options.parse_config_file(path,
                                                       final=False))


class Application(tornado.web.Application):

    def __init__(self):
        self.init_handlers()
        self.init_signal_handlers()

        settings = self.init_settings()

        tornado.web.Application.__init__(self, self.handlers, **settings)

    def init_settings(self):
        settings = {
            'debug': options.debug,