예제 #1
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()))
예제 #2
0
파일: tworkd.py 프로젝트: bufferx/twork
def _log_options():
    if tornado.version_info < (3, 0, 0, 0):
        for key, option in options.iteritems():
            gen_logger.info('Options: (%s, %s)', key, option.value())
    else:
        for key, option in options.items():
            gen_logger.info('Options: (%s, %s)', key, option)
예제 #3
0
def main():
    try:
        tornado.options.parse_command_line()

        if (options.docker):
            # Translate the environment variables Docker creates
            # when containers are linked to a Python dictionary.
            from docker_links import parse_links
            links = parse_links(os.environ)

            logger.info("Docker mode (links):")
            logger.info("\n%s" % json.dumps(links, indent=4))

            # The user can specify another alias to look for.
            if options.docker_db_alias not in links:
                raise Exception('No Docker alias named "%s" found. Available:\n%s' \
                 % (options.docker_db_alias, "\n".join(links.keys())))

            db = links[options.docker_db_alias]

            options.rethinkdb_host = db["hostname"]

        logger.info("Options:\n%s" % "\n".join(map(lambda x: \
         "%25s: %s" % (x[0], x[1]), options.items())))

        http_server = tornado.httpserver.HTTPServer(Application())
        http_server.listen(options.http_port)
        tornado.ioloop.IOLoop.instance().start()
    except Exception as ex:
        logger.error("Error: %s" % ex)
        exit(-1)
예제 #4
0
    def connect(self, url=None, options=None, callback=None):
        if url is not None:
            self.url = url
        purl = urlparse(self.url)
        credentials = pika.PlainCredentials(purl.username, purl.password)
        virtual_host = purl.path[1:]
        host = purl.hostname
        port = purl.port

        options = options or {}
        options = dict([(k.lstrip('DEFAULT_').lower(), v) for k, v in options.items()])
        options.update(host=host, port=port, virtual_host=virtual_host,
                       credentials=credentials)

        params = pika.ConnectionParameters(**options)
        try:
            TornadoConnection(params, stop_ioloop_on_close=False,
                              on_open_callback=partial(self.on_connect, callback),
                              custom_ioloop=self.io_loop)
        except AMQPConnectionError:
            logging.info('Retrying to connect in 2 seconds')
            self.io_loop.add_timeout(
                    timedelta(seconds=2),
                    partial(self.connect, url=url,
                            options=options, callback=callback))
예제 #5
0
def _log_options():
    if tornado.version_info < (3, 0, 0, 0):
        for key, option in options.iteritems():
            gen_logger.info('Options: (%s, %s)', key, option.value())
    else:
        for key, option in options.items():
            gen_logger.info('Options: (%s, %s)', key, option)
예제 #6
0
    def connect(self, url=None, options=None, callback=None):
        if url is not None:
            self.url = url
        purl = urlparse(self.url)
        credentials = pika.PlainCredentials(purl.username, purl.password)
        virtual_host = purl.path[1:]
        host = purl.hostname
        port = purl.port

        options = options or {}
        options = dict([(k.lstrip('DEFAULT_').lower(), v)
                        for k, v in options.items()])
        options.update(host=host,
                       port=port,
                       virtual_host=virtual_host,
                       credentials=credentials)

        params = pika.ConnectionParameters(**options)
        try:
            TornadoConnection(params,
                              stop_ioloop_on_close=False,
                              on_open_callback=partial(self.on_connect,
                                                       callback),
                              custom_ioloop=self.io_loop)
        except AMQPConnectionError:
            logging.info('Retrying to connect in 2 seconds')
            self.io_loop.add_timeout(
                timedelta(seconds=2),
                partial(self.connect,
                        url=url,
                        options=options,
                        callback=callback))
예제 #7
0
    def start(self):

        def kill_server(sig, frame):

            LOG.warning( 'Catch SIG: %d' % sig )

            tornado.ioloop.IOLoop.instance().stop()


        # ignore Broken Pipe signal
        signal.signal(signal.SIGPIPE, signal.SIG_IGN);
                            
        # catch kill signal
        signal.signal(signal.SIGINT, kill_server)
        signal.signal(signal.SIGQUIT, kill_server)
        signal.signal(signal.SIGTERM, kill_server)
        signal.signal(signal.SIGHUP, kill_server)

        for log_name in self.log_list:
            mownfish.util.log.setup(log_name)

        LOG.info('START TORNADO WEB SERVER ...')

        for key, value in sorted(options.items(), key=lambda d:d[0]):
            if key not in ('help', 'log_file_prefix', 'log_to_stderr') \
                    and value.value() is None:
                sys.stderr.write('must specify %s\n' % key)
                options.print_help()
                sys.exit(0)
            LOG.info('Options: (%s, %s)', key, value.value())

        try:
            sockets = tornado.netutil.bind_sockets(options.port,
                    address=options.bind_ip,
                    backlog=128)

            if not options.multiports:
                task_id = tornado.process.fork_processes(options.num_process)
            
            http_server =  \
                tornado.httpserver.HTTPServer(xheaders=True,
                                            request_callback=self.application)
            http_server.add_sockets(sockets)

            self.prepare()

            tornado.ioloop.IOLoop.instance().start()

            http_server.stop()
            tornado.ioloop.IOLoop.instance().stop()

            LOG.info('STOP TORNADO WEB SERVER ...')
        except socket.error as e:
            LOG.warning('Socket Error: %s' % str(e))
        except KeyboardInterrupt as e:
            LOG.warning('Gently Quit')
        except Exception as e:
            LOG.error('UnCaught Exception: %s' % e, exc_info=True)
예제 #8
0
파일: app.py 프로젝트: isawnyu/vaytrou
def make_app(environ, argv1=None):
    parser = OptionParser()
    parser.add_option(
        "-c", "--config", dest="config_file", 
        help="Configuration file", metavar="FILE")
    parser.add_option(
        "-d", "--data", dest="data",
        help="Data directory", metavar="FILE")
    parser.add_option(
        "-l", "--logfile", dest="log_file_prefix",
        help="Log file", metavar="FILE")
    parser.add_option(
        "-L", "--log-level", dest="logging",
        help="Log level", metavar="info|warning|error|none")
    parser.add_option(
        "-p", "--port", dest="port",
        help="Port", default="0")

    opts, args = parser.parse_args(argv1)
    name = args[0]
    
    if opts.data.startswith('/'):
        instance_path = os.path.join(opts.data, name)
    else:
        instance_path = os.path.join(os.getcwd(), opts.data, name) 
    config_file = opts.config_file or os.path.join(os.path.abspath(instance_path), "etc", "vaytrou.conf")
    if config_file is not None:
        parse_config_file(config_file)    
    parse_command_line([])

    # Load command line options over Tornado options
    for k, v in options.items():
        optv = getattr(opts, k, None)
        if optv is not None:
            try:
                options[k].set(v.type(optv))
            except:
                import pdb; pdb.set_trace()
                raise

    finder = PersistentApplicationFinder(
        'file://%s/%s/var/Data.fs' % (options.data, name), appmaker)
    index = finder(environ)
    index.fwd = Rtree('%s/%s/var/vrt1' % (options.data, name))
    setattr(index, 'name', name)
    setattr(index, 'data', options.data)

    return Application(index, [
        (r'/', MainHandler),
        (r'/intersection/?', IntersectionHandler),
        (r'/nearest/?', NearestHandler),
        (r'/distance/?', DistanceHandler),
        (r'/within/?', WithinHandler),
        (r'/item/([-\w]+);([-0-9\.]+),([-0-9\.]+),([-0-9\.]+),([-0-9\.]+)', 
         SingleItemHandler),
        (r'/items/([-\w]+)', MultipleItemsHandler)
        ])
예제 #9
0
def options_to_settings(options):
    """
    Converts the given Tornado-style *options* to new-style settings.  Returns
    an :class:`RUDict` containing all the settings.
    """
    settings = RUDict({'*': {'gateone': {}, 'terminal': {}}})
    # In the new settings format some options have moved to the terminal app.
    # These settings are below and will be placed in the 'terminal' sub-dict.
    terminal_options = [
        'command', 'dtach', 'session_logging', 'session_logs_max_age',
        'syslog_session_logging'
    ]
    non_options = [
        # These are things that don't really belong in settings
        'new_api_key',
        'help',
        'kill',
        'config',
        'version',
        'configure'
    ]
    for key, value in options.items():
        if key in terminal_options:
            settings['*']['terminal'].update({key: value})
        elif key in non_options:
            continue
        else:
            if key == 'origins':
                #if value == '*':
                #continue
                # Convert to the new format (a list with no http://)
                origins = value.split(';')
                converted_origins = []
                for origin in origins:
                    if '://' in origin:
                        # The new format doesn't bother with http:// or https://
                        origin = origin.split('://')[1]
                        if origin not in converted_origins:
                            converted_origins.append(origin)
                    elif origin not in converted_origins:
                        converted_origins.append(origin)
                settings['*']['gateone'].update({key: converted_origins})
            elif key == 'api_keys':
                if not value:
                    continue
                # API keys/secrets are now a dict instead of a string
                settings['*']['gateone']['api_keys'] = {}
                for pair in value.split(','):
                    api_key, secret = pair.split(':', 1)
                    if bytes == str:  # Python 2
                        api_key = api_key.decode('UTF-8')
                        secret = secret.decode('UTF-8')
                    settings['*']['gateone']['api_keys'].update(
                        {api_key: secret})
            else:
                settings['*']['gateone'].update({key: value})
    return settings
예제 #10
0
파일: wsgi.py 프로젝트: xoxoj/mownfish
    def start(self):
        def kill_server(sig, frame):

            LOG.warning('Catch SIG: %d' % sig)

            tornado.ioloop.IOLoop.instance().stop()

        # ignore Broken Pipe signal
        signal.signal(signal.SIGPIPE, signal.SIG_IGN)

        # catch kill signal
        signal.signal(signal.SIGINT, kill_server)
        signal.signal(signal.SIGQUIT, kill_server)
        signal.signal(signal.SIGTERM, kill_server)
        signal.signal(signal.SIGHUP, kill_server)

        for log_name in self.log_list:
            mownfish.util.log.setup(log_name)

        LOG.info('START TORNADO WEB SERVER ...')

        for key, value in sorted(options.items(), key=lambda d: d[0]):
            if key not in ('help', 'log_file_prefix', 'log_to_stderr') \
                    and value.value() is None:
                sys.stderr.write('must specify %s\n' % key)
                options.print_help()
                sys.exit(0)
            LOG.info('Options: (%s, %s)', key, value.value())

        try:
            sockets = tornado.netutil.bind_sockets(options.port,
                                                   address=options.bind_ip,
                                                   backlog=128)

            if not options.multiports:
                task_id = tornado.process.fork_processes(options.num_process)

            http_server =  \
                tornado.httpserver.HTTPServer(xheaders=True,
                                            request_callback=self.application)
            http_server.add_sockets(sockets)

            self.prepare()

            tornado.ioloop.IOLoop.instance().start()

            http_server.stop()
            tornado.ioloop.IOLoop.instance().stop()

            LOG.info('STOP TORNADO WEB SERVER ...')
        except socket.error as e:
            LOG.warning('Socket Error: %s' % str(e))
        except KeyboardInterrupt as e:
            LOG.warning('Gently Quit')
        except Exception as e:
            LOG.error('UnCaught Exception: %s' % e, exc_info=True)
예제 #11
0
def options_to_settings(options):
    """
    Converts the given Tornado-style *options* to new-style settings.  Returns
    an :class:`RUDict` containing all the settings.
    """
    settings = RUDict({'*': {'gateone': {}, 'terminal': {}}})
    # In the new settings format some options have moved to the terminal app.
    # These settings are below and will be placed in the 'terminal' sub-dict.
    terminal_options = [
        'command', 'dtach', 'session_logging', 'session_logs_max_age',
        'syslog_session_logging'
    ]
    non_options = [
        # These are things that don't really belong in settings
        'new_api_key', 'help', 'kill', 'config'
    ]
    for key, value in options.items():
        if key in terminal_options:
            settings['*']['terminal'].update({key: value})
        elif key in non_options:
            continue
        else:
            if key == 'origins':
                #if value == '*':
                    #continue
                # Convert to the new format (a list with no http://)
                origins = value.split(';')
                converted_origins = []
                for origin in origins:
                    if '://' in origin:
                        # The new format doesn't bother with http:// or https://
                        origin = origin.split('://')[1]
                        if origin not in converted_origins:
                            converted_origins.append(origin)
                    elif origin not in converted_origins:
                        converted_origins.append(origin)
                settings['*']['gateone'].update({key: converted_origins})
            elif key == 'api_keys':
                if not value:
                    continue
                # API keys/secrets are now a dict instead of a string
                settings['*']['gateone']['api_keys'] = {}
                for pair in value.split(','):
                    api_key, secret = pair.split(':', 1)
                    if bytes == str: # Python 2
                        api_key = api_key.decode('UTF-8')
                        secret = secret.decode('UTF-8')
                    settings['*']['gateone']['api_keys'].update(
                        {api_key: secret})
            else:
                settings['*']['gateone'].update({key: value})
    return settings
예제 #12
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()))
예제 #13
0
def run(service, port):
    if not options.local_debug:
        logging.info('\n--\nRun ' + service)
        for k, v in options.items():
            logging.info('[Option] ' + k + ' = ' + str(v))
        logging.info('--\n')

    # Load specific app from module if available.
    app_cls = Application
    try:
        module = __import__(service + '.application', fromlist=['Application'])
        app_cls = getattr(module, 'Application')
    except:
        pass

    application = app_cls(service, port)
    return application
예제 #14
0
def app_options():
    original_settings = dict(options.items())
    yield options
    for key, value in original_settings.items():
        setattr(options, key, value)
예제 #15
0
파일: data.py 프로젝트: gabalese/py-clave
import os

from tornado.options import options
from tornado.options import define


dbname = os.path.join(os.path.dirname(__file__), os.pardir, "base.sql")
epub_path = os.path.join(os.path.dirname(__file__), os.pardir, "files")

define("DBNAME", default=dbname, help="Name of the local DB cache")
define("PORT", default=8080, help="Port to listen to")
define("DB_UPDATE_TIMEOUT", default=1000000, help="Interval to update DB")
define("EPUB_FILES_PATH", default=epub_path, help="Files storage directory")

options.parse_command_line()

for i in options.items():  # print the init parameters on boot
    print "{} = {}".format(i[0], i[1])

# map options to constants / too lazy to refactor in a elegant way
EPUB_FILES_PATH = options.EPUB_FILES_PATH
DBNAME = os.path.join(os.path.dirname(__file__), os.pardir, options.DBNAME)
PORT, DB_UPDATE_TIMEOUT = options.PORT, options.DB_UPDATE_TIMEOUT
예제 #16
0
        self.write(json.dumps(ret))


if __name__ == "__main__":
    SETTINGS = {
        "cookie_secret": "61oETzKXQAGaYdkL5gEmGeJJFuYh7EQnp2XdTP1o/Vo=",
        "debug": False,
    }
    APPLICATION = tornado.web.Application([
        (r"/api/dmp/taguser", GetUserHandler),
        (r"/api/dmp/usertag", GetLabelHandler),
    ], **SETTINGS)
    http_server = tornado.httpserver.HTTPServer(APPLICATION)
    '''
    Get the option(s) from the startup command line if ever.

    In this tutorial, we define own "port" option to change the
    port via the command line, and then we can run multiple tornado
    processes at different ports.
    '''
    tornado.options.parse_command_line()

    # This line should be after the parse_command_line()
    http_server.listen(8888)
    REDIS_HOST = options.redis_host
    REDIS_PORT = options.redis_port
    REDIS_AUTH = options.redis_auth
    VALID_SECONDS = options.valid_seconds
    logging.info(options.items())
    tornado.ioloop.IOLoop.instance().start()
예제 #17
0
파일: base.py 프로젝트: svrin/blueprint
    def __init__(self, *args, **kwargs):
        kwargs.update(options.items())
        kwargs.setdefault('handlers', []).extend(routes())

        super().__init__(*args, **kwargs)
예제 #18
0
def app_options():
    original_settings = dict(options.items())
    yield options
    for key, value in original_settings.items():
        setattr(options, key, value)
예제 #19
0
define('haze',default='http://api-howler.io.bittorrent.com', type=str)
define('datapath',default='/home/kyle/virtualbox-shared/ktorrent', type=str)
define('ktorrent_path',default='/home/kyle/ktorrent', type=str)
define('utserver_username',default='admin', type=str)
define('utserver_password',default='', type=str)
define('utserver_webui_port',default=8080, type=int)

tornado.options.parse_command_line()
try:
    import config_prod as config
    options.utserver_username = config.utserver_username
    options.utserver_password = config.utserver_password
except:
    logging.warn('no config.py found -- using default settings')

settings = dict( (k, v.value()) for k,v in options.items() )
ioloop = tornado.ioloop.IOLoop.instance()

from handlers import IndexHandler, TestHandler

routes = [
    ('/?', IndexHandler),
    ('/test?', TestHandler),

]
application = tornado.web.Application(routes, **settings)
frontend_application = tornado.web.Application(routes, **settings)
frontend_server = tornado.httpserver.HTTPServer(frontend_application, io_loop=ioloop)
frontend_server.bind(options.frontend_port, '')
frontend_server.start()
logging.info('ioloop starting')
예제 #20
0
def main():
    try:
        tornado.options.parse_command_line()

        if options.docker:
            # Translate the environment variables Docker creates
            # when containers are linked to a Python dictionary.
            from docker_links import parse_links

            links = parse_links(os.environ)

            logger.info("Docker mode (links):")
            logger.info("\n%s" % json.dumps(links, indent=4))

            # The user can specify another alias to look for.
            if options.docker_db_alias not in links:
                raise Exception(
                    'No Docker alias named "%s" found. Available:\n%s'
                    % (options.docker_db_alias, "\n".join(links.keys()))
                )

            db = links[options.docker_db_alias]

            options.rethinkdb_host = db["hostname"]

        logger.info("Options:\n%s" % "\n".join(map(lambda x: "%25s: %s" % (x[0], x[1]), options.items())))

        http_server = tornado.httpserver.HTTPServer(Application())
        http_server.listen(options.http_port)
        tornado.ioloop.IOLoop.instance().start()
    except Exception as ex:
        logger.error("Error: %s" % ex)
        exit(-1)