def main(): parse_command_line() if options.reset: logging.info("History reset") else: try: history.load() logging.info("History loaded") except: logging.warning("Error loading history, starting from initial word") app = tornado.web.Application( [ (r"/", MainHandler), (r"/next", NextWordHandler), (r"/update", UpdateHandler), (r"/history", HistoryHandler), (r"/rules", RulesHandler), (r"/save", SaveHandler), (r"/load", LoadHandler), ], template_path=os.path.join(os.path.dirname(__file__), "templates"), static_path=os.path.join(os.path.dirname(__file__), "static"), xsrf_cookies=True, debug=options.debug, ) app.listen(options.port) try: tornado.ioloop.IOLoop.instance().start() except: pass finally: history.save() logging.info("History saved")
def __init__(self, predictors, batch_size=5): """ Args: predictors (list): a list of OnlinePredictor available to use. batch_size (int): the maximum of an internal batch. """ assert len(predictors) self._need_default_sess = False for k in predictors: assert isinstance(k, OnlinePredictor), type(k) if k.sess is None: self._need_default_sess = True # TODO support predictors.return_input here assert not k.return_input self.input_queue = queue.Queue(maxsize=len(predictors) * 100) self.threads = [ PredictorWorkerThread( self.input_queue, f, id, batch_size=batch_size) for id, f in enumerate(predictors)] if six.PY2: # TODO XXX set logging here to avoid affecting TF logging import tornado.options as options options.parse_command_line(['--logging=debug']) logger.warn("MultiThreadAsyncPredictor is inefficient in Python 2! Switch to Python 3 instead.")
def main(): options.parse_command_line() _port = options.options.port _process_num = options.options.process _debug_level = options.options.debug * 10 process.fork_processes(_process_num, max_restarts=3) process_port = _port + process.task_id() process_debug = _process_num <= 1 and _debug_level < 30 print('Service Running on %d ...' % process_port) app = web.Application(( (r'/', views.base.IndexHandler), (r'/home', views.base.HomeHandler), (r'/auth/redirect', views.auth.OAuth2RedirectHandler), (r'/auth/revoke', views.auth.OAuth2RevokeHandler), (r'/auth/authorize', views.auth.OAuth2AuthorizeHandler), (r'/auth/info', views.auth.OAuth2InfoHandler), (r'/user/info', views.rest.UserInfoHandler), (r'/user/option', views.rest.UserOptionHandler), (r'/weibo/public', views.rest.WeiboPublicHandler), (r'/weibo/sync', views.rest.WeiboSyncHandler), (r'/weibo/query', views.rest.WeiboQueryHandler), (r'/weibo/redirect', views.rest.WeiboRedirectHandler), (r'/emotion/query', views.rest.EmotionQueryHandler), ), debug=process_debug, cookie_secret=setting.COOKIE_SECRET) app.listen(process_port, xheaders=True) loop = ioloop.IOLoop.instance() loop.start()
def main(args=None): if args is None: args = sys.argv options.define('root', default='.', help='document root') options.define('proxy', default='', help='http proxy') options.parse_command_line() log.enable_pretty_logging() main_loop = ioloop.IOLoop.instance() pool = cf.ThreadPoolExecutor(max_workers=4) application = web.Application([ (r'/(.*)', IndexHandler, { 'root': options.options.root, 'pool': pool, 'proxy': options.options.proxy, }), ], debug=True) application.listen(8000) main_loop.start() pool.shutdown() main_loop.close() return 0
def main(): parse_command_line() app = tornado.web.Application( [ (r"/", MainHandler), (r"/control/action/on_off" , control_action_on_off ), (r"/control/action/all" , control_action_all ), (r"/control/action/roll" , control_action_roll ), (r"/control/action/pitch" , control_action_pitch ), (r"/control/action/throttle" , control_action_throttle ), (r"/control/action/yaw" , control_action_yaw ), (r"/control/action/fly_mode" , control_action_fly_mode ), (r"/control/action/accessory_0" , control_action_accessory_0 ), (r"/control/action/interrumpir" , control_action_interrumpir ), (r"/control/action/reiniciar" , control_action_reiniciar ), (r"/control/action/resetear_valores" , control_action_resetear_valores ), (r"/websocket" , control_drone_socket ) ], cookie_secret="__TODO:_GENERATE_YOUR_OWN_RANDOM_VALUE_HERE__", template_path=os.path.join(os.path.dirname(__file__), "templates"), static_path=os.path.join(os.path.dirname(__file__), "static"), xsrf_cookies=False, debug=options.debug, ) app.listen(options.port) tornado.ioloop.IOLoop.current().start() tornado.autoreload.wait()
def validate_options(): parse_command_line() required_options = ['mapping', 'source_dir', 'destination_dir'] opts = [option for option in required_options if getattr(options, option) is None] if len(opts): print >> sys.stderr, ( "Can't continue the process.\n\n" " The following options are required: " + ', '.join(opts) ) sys.exit(1) if not os.path.exists(options.source_dir): print >> sys.stderr, ( "Can't continue the process.\n\n" " The source directory doesn't exist." ) sys.exit(1) if options.force and not os.path.exists(options.destination_dir): os.makedirs(options.destination_dir) elif not os.path.exists(options.destination_dir): print >> sys.stderr, ( "Can't continue the process.\n\n" " The destination directory doesn't exist." ) sys.exit(1)
def main(): """ Main. """ logging_level = logging.INFO if hermes_constants.DEBUG: logging_level = logging.DEBUG logging.getLogger().setLevel(logging_level) signal.signal(signal.SIGTERM, signal_handler) signal.signal(signal.SIGINT, signal_handler) parse_command_line() app = tornado.web.Application([ (MainHandler.PATH, MainHandler), (TaskHandler.PATH, TaskHandler), ], debug=False) try: app.listen(options.port) except socket.error: logging.error("ERROR on Hermes initialization: Port {0} already in use.". format(options.port)) shutdown() return logging.info("Hermes is up and listening on port: {0}.". format(options.port)) # Start loop for accepting http requests. IOLoop.instance().start()
def main(): global http_server try: signal(SIGTERM, on_signal) parse_command_line() if options.config != None: parse_config_file(options.config) path = join(dirname(__file__), "templates") application = Application( [(r"/", IndexHandler), (r"/stock", StockHandler)], template_path=path, static_path=join(dirname(__file__), "static"), ) application.db = motor.MotorClient(options.db_host, options.db_port).open_sync()[options.db_name] http_server = HTTPServer(application) http_server.listen(options.port, options.address) log().info("server listening on port %s:%d" % (options.address, options.port)) if log().isEnabledFor(DEBUG): log().debug("autoreload enabled") tornado.autoreload.start() IOLoop.instance().start() except KeyboardInterrupt: log().info("exiting...") except BaseException as ex: log().error("exiting due: [%s][%s]" % (str(ex), str(format_exc().splitlines()))) exit(1)
def parse_configs(config_files): """Reads command line options / config file and bootstraps logging. """ parse_command_line(final=False) if options.config: configs_to_read = options.config else: configs_to_read = config_files configs_to_read = filter( None, [configs_to_read] if not isinstance(configs_to_read, (list, tuple)) else configs_to_read ) for config in configs_to_read: parse_config_file(config, final=False) # override options from config with command line options parse_command_line(final=False) bootstrap_core_logging() for config in configs_to_read: log.debug('using config: %s', config) if options.autoreload: tornado.autoreload.watch(config)
def main(): options.parse_command_line() assert options.options.user_id is not None opener = otp.GetAdminOpener(options.options.api_host) log_urls = FetchLogs(opener, options.options.api_host) if options.options.merge_logs: MergeLogs(log_urls)
def run_tornado(addr, port, reload=False): # Don't try to read the command line args from openslides parse_command_line(args=[]) # Print listening address and port to command line if addr == '0.0.0.0': url_string = _("the machine's local ip address") else: url_string = 'http://%s:%s' % (addr, port) print _("Starting OpenSlides' tornado webserver listening to %(url_string)s") % {'url_string': url_string} socket_js_router = SockJSRouter(ProjectorSocketHandler, '/projector/socket') # Start the application app = WSGIContainer(Django_WSGIHandler()) tornado_app = Application(socket_js_router.urls + [ (r"%s(.*)" % settings.STATIC_URL, DjangoStaticFileHandler), (r'%s(.*)' % settings.MEDIA_URL, StaticFileHandler, {'path': settings.MEDIA_ROOT}), ('.*', FallbackHandler, dict(fallback=app)) ], debug=reload) server = HTTPServer(tornado_app) server.listen(port=port, address=addr) IOLoop.instance().start()
def main(): parse_command_line() app=tornado.web.Application( [(r'/',SearchPage),(r'/s',SearchResult)], ) app.listen(options.port) tornado.ioloop.IOLoop.instance().start()
def main(): options.logging = None parse_command_line() options.subpath = options.subpath.strip('/') if options.subpath: options.subpath = '/' + options.subpath # Connect to mongodb io_loop = ioloop.IOLoop.instance() connect(config.DB_NAME, host=config.DB_HOST, port=config.DB_PORT, io_loop=io_loop) # username=config.DB_USER, password=config.DB_PWD) # Star application from application import app if options.unix_socket: server = tornado.httpserver.HTTPServer(app) socket = tornado.netutil.bind_unix_socket(options.unix_socket, 0o666) server.add_socket(socket) print('Server is running at %s' % options.unix_socket) print('Quit the server with Control-C') else: http_server = tornado.httpserver.HTTPServer(app) http_server.listen(options.port) print('Server is running at http://127.0.0.1:%s%s' % (options.port, options.subpath)) print('Quit the server with Control-C') io_loop.start()
def run_tornado(addr, port, *args, **kwargs): """ Starts the tornado webserver as wsgi server for OpenSlides. It runs in one thread. """ # Save the port and the addr in a global var global RUNNING_HOST, RUNNING_PORT RUNNING_HOST = addr RUNNING_PORT = port # Don't try to read the command line args from openslides parse_command_line(args=[]) # Setup WSGIContainer app = WSGIContainer(get_wsgi_application()) # Collect urls sock_js_router = SockJSRouter(OpenSlidesSockJSConnection, '/sockjs') other_urls = [ (r'%s(.*)' % settings.STATIC_URL, DjangoStaticFileHandler), (r'%s(.*)' % settings.MEDIA_URL, StaticFileHandler, {'path': settings.MEDIA_ROOT}), ('.*', FallbackHandler, dict(fallback=app))] # Start the application debug = settings.DEBUG tornado_app = Application(sock_js_router.urls + other_urls, autoreload=debug, debug=debug) server = HTTPServer(tornado_app) server.listen(port=port, address=addr) IOLoop.instance().start() # Reset the global vars RUNNING_HOST = None RUNNING_PORT = None
def main(): options.logging = "warning" parse_command_line() for version in options.versions: elapsed = yield benchmark(int(version)) print_result(version, elapsed)
def run_from_argv(self, prog_name, argv=None): app_settings = settings.APP_SETTINGS argv = filter(self.flower_option, argv) parse_command_line([prog_name] + argv) auth = map(str.strip, options.auth.split(',')) if options.auth else [] app_settings['debug'] = options.debug if options.url_prefix: prefix = options.url_prefix.strip('/') app_settings['static_url_prefix'] = '/{0}/static/'.format(prefix) app_settings['login_url'] = '/{0}/login'.format(prefix) settings.URL_PREFIX = prefix settings.CELERY_INSPECT_TIMEOUT = options.inspect_timeout flower = Flower(celery_app=self.app, auth=auth, **app_settings) logging.info('Visit me at http://%s:%s' % (options.address or 'localhost', options.port)) logging.info('Broker: %s', self.app.connection().as_uri()) logging.debug('Settings: %s' % pformat(app_settings)) try: flower.start(options.port, address=options.address, inspect=options.inspect) except (KeyboardInterrupt, SystemExit): pass
def main(): """"" Start up the server and register the necessary handlers and web socket interfaces. """ # Register the handlers and web socket interfaces server = tornado.web.Application( [ (r"/", HomeHandler), (r"/java/", JavaHandler), (r"/python/", PythonHandler), (r"/javafuntime", JavaWebsocket), (r"/pythonfuntime", PythonWebSocket) ], title="LaHacks Server", template_path=os.path.join(os.path.dirname(__file__), "templates"), static_path=os.path.join(os.path.dirname(__file__), "static"), login_url="/", cookie_secret="sooper secure, obviously", debug=True ) # Starts the tornado server parse_command_line() server.listen(options.port) tornado.ioloop.IOLoop.instance().start()
def run_from_argv(self, prog_name, argv=None, **_kwargs): app_settings = settings.APP_SETTINGS argv = list(filter(self.flower_option, argv)) # parse the command line to get --conf option parse_command_line([prog_name] + argv) try: parse_config_file(options.conf, final=False) parse_command_line([prog_name] + argv) except IOError: if options.conf != settings.CONFIG_FILE: raise app_settings["debug"] = options.debug if options.cookie_secret: app_settings["cookie_secret"] = options.cookie_secret if options.url_prefix: prefix = options.url_prefix.strip("/") app_settings["static_url_prefix"] = "/{0}/static/".format(prefix) app_settings["login_url"] = "/{0}/login".format(prefix) settings.URL_PREFIX = prefix settings.CELERY_INSPECT_TIMEOUT = options.inspect_timeout settings.AUTO_REFRESH = options.auto_refresh if options.debug and options.logging == "info": options.logging = "debug" enable_pretty_logging() if options.auth: app_settings[GoogleOAuth2Mixin._OAUTH_SETTINGS_KEY] = { "key": options.oauth2_key or os.environ.get("GOOGLE_OAUTH2_KEY"), "secret": options.oauth2_secret or os.environ.get("GOOGLE_OAUTH2_SECRET"), "redirect_uri": options.oauth2_redirect_uri or os.environ.get("GOOGLE_OAUTH2_REDIRECT_URI"), } # Monkey-patch to support Celery 2.5.5 self.app.connection = self.app.broker_connection self.app.loader.import_default_modules() flower = Flower(celery_app=self.app, options=options, **app_settings) atexit.register(flower.stop) # graceful shutdown on SIGTERM def signal_handler(signal, frame): logger.info("SIGTERM detected, shutting down") sys.exit(0) signal.signal(signal.SIGTERM, signal_handler) logger.info( "Visit me at http%s://%s:%s", "s" if flower.ssl else "", options.address or "localhost", options.port ) logger.info("Broker: %s", self.app.connection().as_uri()) logger.debug("Registered tasks: \n%s", pformat(sorted(self.app.tasks.keys()))) logger.debug("Settings: %s", pformat(app_settings)) try: flower.start() except (KeyboardInterrupt, SystemExit): pass
def run_from_argv(self, prog_name, argv=None, **_kwargs): app_settings = settings.APP_SETTINGS argv = filter(self.flower_option, argv) parse_command_line([prog_name] + argv) app_settings['debug'] = options.debug if options.url_prefix: prefix = options.url_prefix.strip('/') app_settings['static_url_prefix'] = '/{0}/static/'.format(prefix) app_settings['login_url'] = '/{0}/login'.format(prefix) settings.URL_PREFIX = prefix settings.CELERY_INSPECT_TIMEOUT = options.inspect_timeout if options.debug: logging.getLogger().setLevel(logging.DEBUG) # Monkey-patch to support Celery 2.5.5 self.app.connection = self.app.broker_connection flower = Flower(celery_app=self.app, options=options, **app_settings) atexit.register(flower.stop) logging.info('Visit me at http%s://%s:%s' % ('s' if flower.ssl else '', options.address or 'localhost', options.port)) logging.info('Broker: %s', self.app.connection().as_uri()) logging.debug('Settings: %s' % pformat(app_settings)) try: flower.start() except (KeyboardInterrupt, SystemExit): pass
def main(): options.parse_command_line() http_server = httpserver.HTTPServer(application) http_server.listen(options.port) print 'Development server is running at http://127.0.0.1:%s/' % options.port print 'Quit the server with Control-C' ioloop.IOLoop.instance().start()
def application(argv=None): print "start" parse_command_line() if argv == None: argv = sys.argv # Create the server SocketRouter = tornadio2.router.TornadioRouter(IOConnection, dict(websocket_check=True)) # configure the Tornado application # currently only allow one command-line argument, the port to run on. port = int(argv[1]) if (len(argv) > 1) else settings.SOCKET_IO_PORT application = tornado.web.Application( SocketRouter.apply_routes([ (r"/", IndexHandler), (r"/game/", GameHandler), (r"/start/", StartGameHandler), (r"/socket.io.js", SocketIOHandler), (r"/resources/(.*)", tornado.web.StaticFileHandler, {"path": settings.RESOURCES_ROOT}), (r"/WebSocketMain.swf", WebSocketFileHandler) ]), flash_policy_port=8043, flash_policy_file=settings.DOCUMENT_ROOT + '/flashpolicy.xml', socket_io_port=port, ) print("LocationMapper Server running on %s:%d" % (settings.SOCKET_IO_REMOTE_ADDR, port)) return server.SocketServer(application)
def main(): # options parse_command_line() # Locale load_gettext_translations(settings.I18N_PATH, "luoyun") set_default_locale('zh_CN') logging.info("starting torando web server") if settings.IPV4_ONLY: import socket sockets = bind_sockets(options.port, family=socket.AF_INET) else: sockets = bind_sockets(options.port) if not settings.DEBUG: import tornado.process tornado.process.fork_processes(0) application = Application() server = HTTPServer(application, xheaders=True) server.add_sockets(sockets) IOLoop.instance().start()
def main(): """Test/Exercise ServerEnvironment on EC2 instance. Initializes AMI Metadata and initializes ServerEnvironment object followed by output of results. """ query_ip = Metadata._QUERY_IP options.parse_command_line() def _OnInitSecrets(): ServerEnvironment.InitServerEnvironment() if ServerEnvironment.IsDevBox(): print "IsDevBox environment" if ServerEnvironment.IsStaging(): print "IsStaging environment" else: print "IsProduction environment" ioloop.IOLoop.current().stop() def _MetadataCallback(metadata): SetAMIMetadata(metadata) InitSecrets(_OnInitSecrets, False) Metadata(callback=_MetadataCallback, query_ip=query_ip) ioloop.IOLoop.current().start() return 0
def run(start_callback, stop_callback=None, **kwargs): options.parse_command_line() io_loop = ioloop.IOLoop.current() def _on_signal(signum, frame): try: stop_callback() except: io_loop.stop() signal.signal(signal.SIGHUP, _on_signal) signal.signal(signal.SIGINT, _on_signal) signal.signal(signal.SIGQUIT, _on_signal) signal.signal(signal.SIGTERM, _on_signal) @gen.coroutine def _invoke_callback(wrapped_callback, **stts): yield gen.Task(wrapped_callback, **stts) shutdown_by_exception = False try: level = logging.DEBUG if options.options.debug else logging.INFO logging.getLogger().setLevel(level) logging.getLogger().handlers[0].setLevel(level) io_loop.run_sync(partial(_initializer, **kwargs)) io_loop.run_sync(partial(_invoke_callback, start_callback)) if stop_callback is not None: func = partial(_invoke_callback, stop_callback) io_loop.run_sync(func) except ioloop.TimeoutError: pass except Exception, e: shutdown_by_exception = True logging.error('Unhandled exception in %s' % sys.argv[0]) logging.error('Error: %s' % e)
def main(): parse_command_line() application.listen(options.port) try: tornado.ioloop.IOLoop.instance().start() except KeyboardInterrupt: print "bye!"
def main(): options.define('port', default=9005, help="Port for the REST API" ) options.define('ip', default='127.0.0.1', help="IP address for the REST API" ) options.define('host_mount', default='', help='Path where the host root is mounted in this container' ) options.define('pool_prefix', default='', help='Prefix assigned by tmpnb to its pooled containers' ) options.define('registration_key', default='', help='Registration key required to create new volumes' ) options.parse_command_line() opts = options.options # regex from docker volume create api_handlers = [ (r'/api/mounts(/([a-zA-Z0-9][a-zA-Z0-9_.-])+)?', MountsHandler), (r'/api/volumes', VolumesHander), ] api_app = web.Application(api_handlers) api_app.listen(opts.port, opts.ip, xheaders=True) app_log.info("Listening on {}:{}".format(opts.ip, opts.port)) ioloop.IOLoop.instance().start()
def main(): parse_command_line() enable_pretty_logging() wsgi_app = wsgi.WSGIContainer(django.core.handlers.wsgi.WSGIHandler()) staticpath = [ _HERE + "/static/", _HERE + "/deb/", "/usr/local/lib/python2.7/dist-packages/django/contrib/admin/static/", "/usr/local/lib/python2.7/dist-packages/django_admin_bootstrapped/static/", "/usr/local/lib/python2.7/dist-packages/bootstrap_markdown/static/", ] mapping = [ (r"/(favicon.ico)", web.StaticFileHandler, {"path": _HERE + "/static"}), (r"/static/(.*)", MultiStaticFileHandler, {"paths": staticpath}), (r"/deb/(.*)", MultiStaticFileHandler, {"paths": staticpath}), (".*", web.FallbackHandler, dict(fallback=wsgi_app)), ] tornado_app = web.Application(mapping, debug=True) server = httpserver.HTTPServer(tornado_app) server.listen(options.port) print "http://{}:{}".format(LOCALIP, options.port) try: ioloop.IOLoop.instance().start() except KeyboardInterrupt: ioloop.IOLoop.instance().stop() print "Finished"
def main(): parse_command_line() http_server = tornado.httpserver.HTTPServer(Application()) http_server.listen(options.port) ioloop = tornado.ioloop.IOLoop().instance() autoreload.start(ioloop) ioloop.start()
def main(): parse_command_line() loop = tornado.ioloop.IOLoop.current() app = make_app(make_handlers(loop, options), get_app_settings(options)) app.listen(options.port, options.address) logging.info('Listening on {}:{}'.format(options.address, options.port)) loop.start()
def run_tornado(addr, port): # Don't try to read the command line args from openslides parse_command_line(args=[]) # Print listening address and port to command line if addr == '0.0.0.0': url_string = "the machine's local ip address" else: url_string = 'http://%s:%s' % (addr, port) # TODO: don't use print, use django logging print("Starting OpenSlides' tornado webserver listening to %(url_string)s" % {'url_string': url_string}) # Setup WSGIContainer app = WSGIContainer(get_wsgi_application()) # Collect urls projectpr_socket_js_router = SockJSRouter(ProjectorSocketHandler, '/projector/socket') from openslides.core.chatbox import ChatboxSocketHandler chatbox_socket_js_router = SockJSRouter(ChatboxSocketHandler, '/core/chatbox') other_urls = [ (r"%s(.*)" % settings.STATIC_URL, DjangoStaticFileHandler), (r'%s(.*)' % settings.MEDIA_URL, StaticFileHandler, {'path': settings.MEDIA_ROOT}), ('.*', FallbackHandler, dict(fallback=app))] # Start the application debug = settings.DEBUG tornado_app = Application(projectpr_socket_js_router.urls + chatbox_socket_js_router.urls + other_urls, debug=debug) server = HTTPServer(tornado_app) server.listen(port=port, address=addr) IOLoop.instance().start()
def main(): parse_command_line() app = Application() app.listen(options.port) print("Run server on port: {}".format(options.port)) tornado.ioloop.IOLoop.current().start()
) define( 'cull_users', default=False, help="""Cull users in addition to servers. This is for use in temporary-user cases such as tmpnb.""", ) define('concurrency', default=10, help="""Limit the number of concurrent requests made to the Hub. Deleting a lot of users at the same time can slow down the Hub, so limit the number of API requests we have outstanding at any given time. """) parse_command_line() if not options.cull_every: options.cull_every = options.timeout // 2 api_token = os.environ['JUPYTERHUB_API_TOKEN'] try: AsyncHTTPClient.configure( "tornado.curl_httpclient.CurlAsyncHTTPClient") except ImportError as e: app_log.warning( "Could not load pycurl: %s\n" "pycurl is recommended if you have a large number of users.", e) loop = IOLoop.current() cull = partial( cull_idle,
def main(): parse_command_line() client = Elasticsearch(options.target_host) # create index datestring = ''.join(str(item) for item in datetime.now().timetuple()[:-1]) index_name = INDEX_PREFIX + datestring _ = client.indices.create(index_name, { "settings": { "query": { "default_field": "all" }, "default_pipeline": "resources-common", "analysis": { "normalizer": { "keyword_lowercase_normalizer": { "filter": [ "lowercase" ], "type": "custom", "char_filter": [] } }, "analyzer": { "string_lowercase": { "filter": "lowercase", "tokenizer": "keyword" }, "whitespace_lowercase": { "filter": "lowercase", "tokenizer": "whitespace" } } } }, "mappings": { "_doc": { "properties": requests.get(MAPPING_URL).json(), "dynamic": False } } }) logging.debug(_) for doc in Dataset.search().scan(): dic = doc.to_json() if dic.get('@type') == 'outbreak:Dataset': dic['@type'] = 'Dataset' try: client.index(index_name, dic, id=doc.meta.id) except RequestError as err: logging.error(err.info) # switch index alias _ = client.indices.update_aliases({ "actions": [ { "remove": { "index": INDEX_PREFIX + '*', "alias": INDEX_ALIAS } }, { "add": { "index": index_name, "alias": INDEX_ALIAS, } } ] }) logging.debug(_) # delete old index indices = list(client.indices.get(INDEX_PREFIX + '*').keys()) indices.remove(index_name) indices = ','.join(indices) _ = client.indices.delete(indices) logging.info(_)
if __name__ == "__main__": timez = pytz.timezone('Asia/Shanghai') scheduler = BackgroundScheduler(timezone=timez) scheduler.add_job(OtherMongoResource().reset_top, 'cron', hour=0, minute=0, day=1) scheduler.add_job(sync_douban, 'cron', hour=0, minute=0, day=1) scheduler.add_job(entry_dump, 'cron', hour=0, minute=0, day_of_week=6) scheduler.add_job(ResourceLatestMongoResource().refresh_latest_resource, 'interval', hours=1) scheduler.start() options.define("p", default=8888, help="running port", type=int) options.define("h", default='127.0.0.1', help="listen address", type=str) options.parse_command_line() p = options.options.p h = options.options.h banner = """ ▌ ▌ ▌ ▌ ▀▛▘ ▝▞ ▝▞ ▞▀▖ ▌ ▞▀▘ ▌ ▌ ▛▀ ▌ ▝▀▖ ▘ ▘ ▝▀▘ ▘ ▀▀ Lazarus came back from the dead. By @Bennythink """ print(banner) RunServer.run_server(port=p, host=h)
def main(): options.define('port', default=config.RestServer.PORT, type=int, help="The server's port. ") options.define('debug', default=config.RestServer.DEBUG, type=bool, help='Start the server with debug options.') options.parse_command_line() manager = Manager() manager.start()
# SCRIPT # ============================================================================= if __name__ == "__main__": p = ArgumentParser(add_help=True, description="Virtual Printer Server.") p.add_argument('-d', '--debug', action='store_true', help="turns on debug mode.") p.add_argument('-c', '--config', default='.mkctf.yml', help="mkctf configuration file.") args = p.parse_args() options.logging = 'info' parse_command_line(args=[]) enable_pretty_logging() with open(args.config, 'r') as f: conf = yaml.safe_load(f) parameters = conf['parameters'] AsyncIOMainLoop().install() app = make_app(conf['flag'], args.debug) app.listen(parameters['port']) asyncio.get_event_loop().run_forever()
def main(): parse_command_line() app = make_app() http_server = tornado.httpserver.HTTPServer(app) http_server.listen(options.port) tornado.ioloop.IOLoop.instance().start()
def main(**kwargs): """A simple test runner. This test runner is essentially equivalent to `unittest.main` from the standard library, but adds support for tornado-style option parsing and log formatting. The easiest way to run a test is via the command line:: python -m tornado.testing tornado.test.stack_context_test See the standard library unittest module for ways in which tests can be specified. Projects with many tests may wish to define a test script like ``tornado/test/runtests.py``. This script should define a method ``all()`` which returns a test suite and then call `tornado.testing.main()`. Note that even when a test script is used, the ``all()`` test suite may be overridden by naming a single test on the command line:: # Runs all tests python -m tornado.test.runtests # Runs one test python -m tornado.test.runtests tornado.test.stack_context_test Additional keyword arguments passed through to ``unittest.main()``. For example, use ``tornado.testing.main(verbosity=2)`` to show many test details as they are run. See http://docs.python.org/library/unittest.html#unittest.main for full argument list. """ from tornado.options import define, options, parse_command_line define('exception_on_interrupt', type=bool, default=True, help=("If true (default), ctrl-c raises a KeyboardInterrupt " "exception. This prints a stack trace but cannot interrupt " "certain operations. If false, the process is more reliably " "killed, but does not print a stack trace.")) # support the same options as unittest's command-line interface define('verbose', type=bool) define('quiet', type=bool) define('failfast', type=bool) define('catch', type=bool) define('buffer', type=bool) argv = [sys.argv[0]] + parse_command_line(sys.argv) if not options.exception_on_interrupt: signal.signal(signal.SIGINT, signal.SIG_DFL) if options.verbose is not None: kwargs['verbosity'] = 2 if options.quiet is not None: kwargs['verbosity'] = 0 if options.failfast is not None: kwargs['failfast'] = True if options.catch is not None: kwargs['catchbreak'] = True if options.buffer is not None: kwargs['buffer'] = True if __name__ == '__main__' and len(argv) == 1: print("No tests specified", file=sys.stderr) sys.exit(1) try: # In order to be able to run tests by their fully-qualified name # on the command line without importing all tests here, # module must be set to None. Python 3.2's unittest.main ignores # defaultTest if no module is given (it tries to do its own # test discovery, which is incompatible with auto2to3), so don't # set module if we're not asking for a specific test. if len(argv) > 1: unittest.main(module=None, argv=argv, **kwargs) else: unittest.main(defaultTest="all", argv=argv, **kwargs) except SystemExit as e: if e.code == 0: gen_log.info('PASS') else: gen_log.error('FAIL') raise
def _parse_options(cls): # it's igly but I don't want to define tornado options in global space from tornado.options import options as tornado_options parse_command_line() return tornado_options
def main(): parse_command_line() for i in xrange(options.num_runs): run()
def main(): sleep(1) parse_command_line() kg_host = os.getenv('GATEWAY_HOST', '192.168.99.100:80') client = AsyncHTTPClient() kernel_id = options.kernel_id if not kernel_id: response = yield client.fetch('http://{}/api/kernels'.format(kg_host), method='POST', body=json_encode({'name': options.lang})) kernel = json_decode(response.body) kernel_id = kernel['id'] print( '''Created kernel {0}. Connect other clients with the following command: docker-compose run client --kernel-id={0} '''.format(kernel_id)) ws_url = 'ws://{}/api/kernels/{}/channels'.format(kg_host, url_escape(kernel_id)) ws = yield websocket_connect(ws_url) print('Connected to kernel websocket') for x in range(0, options.times): print('Sending message {} of {}'.format(x + 1, options.times)) msg_id = uuid4().hex # Send an execute request ws.write_message( json_encode({ 'header': { 'username': '', 'version': '5.0', 'session': '', 'msg_id': msg_id, 'msg_type': 'execute_request' }, 'parent_header': {}, 'channel': 'shell', 'content': { 'code': options.code, 'silent': False, 'store_history': False, 'user_expressions': {}, 'allow_stdin': False }, 'metadata': {}, 'buffers': {} })) # Look for stream output for the print in the execute while 1: msg = yield ws.read_message() msg = json_decode(msg) msg_type = msg['msg_type'] print('Received message type:', msg_type) if msg_type == 'error': print('ERROR') print(msg) break parent_msg_id = msg['parent_header']['msg_id'] if msg_type == 'stream' and parent_msg_id == msg_id: print(' Content:', msg['content']['text']) break ws.close()
def parse(): define("port", type=int, default=settings.TORNADO_PORT, help="a number to bind port for tornado") parse_command_line()
# coding: utf-8 __author__ = 'baocaixiong' import logging from tornado import ioloop from tornado.options import parse_command_line from .tmcclient import TmcClient if __name__ == '__main__': cli = parse_command_line() logging.basicConfig(level=logging.DEBUG) ws = TmcClient('ws://mc.api.taobao.com/', 'app_key', 'app_secret', 'default', query_message_interval=50) def print1(): print('on_open') ws.on("on_open", print1) try: ioloop.IOLoop.current().run_sync(ws.start) except KeyboardInterrupt: pass finally: ioloop.IOLoop.current().run_sync(ws.close)
def main(**kwargs: Any) -> None: """A simple test runner. This test runner is essentially equivalent to `unittest.main` from the standard library, but adds support for Tornado-style option parsing and log formatting. It is *not* necessary to use this `main` function to run tests using `AsyncTestCase`; these tests are self-contained and can run with any test runner. The easiest way to run a test is via the command line:: python -m tornado.testing tornado.test.web_test See the standard library ``unittest`` module for ways in which tests can be specified. Projects with many tests may wish to define a test script like ``tornado/test/runtests.py``. This script should define a method ``all()`` which returns a test suite and then call `tornado.testing.main()`. Note that even when a test script is used, the ``all()`` test suite may be overridden by naming a single test on the command line:: # Runs all tests python -m tornado.test.runtests # Runs one test python -m tornado.test.runtests tornado.test.web_test Additional keyword arguments passed through to ``unittest.main()``. For example, use ``tornado.testing.main(verbosity=2)`` to show many test details as they are run. See http://docs.python.org/library/unittest.html#unittest.main for full argument list. .. versionchanged:: 5.0 This function produces no output of its own; only that produced by the `unittest` module (previously it would add a PASS or FAIL log message). """ from tornado.options import define, options, parse_command_line define( "exception_on_interrupt", type=bool, default=True, help=("If true (default), ctrl-c raises a KeyboardInterrupt " "exception. This prints a stack trace but cannot interrupt " "certain operations. If false, the process is more reliably " "killed, but does not print a stack trace."), ) # support the same options as unittest's command-line interface define("verbose", type=bool) define("quiet", type=bool) define("failfast", type=bool) define("catch", type=bool) define("buffer", type=bool) argv = [sys.argv[0]] + parse_command_line(sys.argv) if not options.exception_on_interrupt: signal.signal(signal.SIGINT, signal.SIG_DFL) if options.verbose is not None: kwargs["verbosity"] = 2 if options.quiet is not None: kwargs["verbosity"] = 0 if options.failfast is not None: kwargs["failfast"] = True if options.catch is not None: kwargs["catchbreak"] = True if options.buffer is not None: kwargs["buffer"] = True if __name__ == "__main__" and len(argv) == 1: print("No tests specified", file=sys.stderr) sys.exit(1) # In order to be able to run tests by their fully-qualified name # on the command line without importing all tests here, # module must be set to None. Python 3.2's unittest.main ignores # defaultTest if no module is given (it tries to do its own # test discovery, which is incompatible with auto2to3), so don't # set module if we're not asking for a specific test. if len(argv) > 1: unittest.main(module=None, argv=argv, **kwargs) # type: ignore else: unittest.main(defaultTest="all", argv=argv, **kwargs)
def main(): parse_command_line() if options.ioloop: IOLoop.configure(options.ioloop) for i in xrange(options.num_runs): run()
def run_from_argv(self, prog_name, argv=None, **_kwargs): env_options = filter(lambda x: x.startswith(self.ENV_VAR_PREFIX), os.environ) for env_var_name in env_options: name = env_var_name.replace(self.ENV_VAR_PREFIX, '', 1).lower() value = os.environ[env_var_name] option = options._options[name] if option.multiple: value = map(option.type, value.split(',')) else: value = option.type(value) setattr(options, name, value) argv = list(filter(self.is_flower_option, argv)) # parse the command line to get --conf option parse_command_line([prog_name] + argv) try: parse_config_file(options.conf, final=False) parse_command_line([prog_name] + argv) except IOError: if options.conf != DEFAULT_CONFIG_FILE: raise settings['debug'] = options.debug if options.cookie_secret: settings['cookie_secret'] = options.cookie_secret if options.url_prefix: logger.error('url_prefix option is not supported anymore') if options.debug and options.logging == 'info': options.logging = 'debug' enable_pretty_logging() else: logging.getLogger("tornado.access").addHandler(logging.NullHandler()) logging.getLogger("tornado.access").propagate = False if options.auth: settings['oauth'] = { 'key': options.oauth2_key or os.environ.get('FLOWER_OAUTH2_KEY'), 'secret': options.oauth2_secret or os.environ.get('FLOWER_OAUTH2_SECRET'), 'redirect_uri': options.oauth2_redirect_uri or os.environ.get('FLOWER_AUTH2_REDIRECT_URI'), } if options.certfile and options.keyfile: settings['ssl_options'] = dict(certfile=abs_path(options.certfile), keyfile=abs_path(options.keyfile)) if options.ca_certs: settings['ssl_options']['ca_certs'] = abs_path(options.ca_certs) # Monkey-patch to support Celery 2.5.5 self.app.connection = self.app.broker_connection self.app.loader.import_default_modules() flower = Flower(capp=self.app, options=options, **settings) atexit.register(flower.stop) def sigterm_handler(signal, frame): logger.info('SIGTERM detected, shutting down') sys.exit(0) signal.signal(signal.SIGTERM, sigterm_handler) self.print_banner('ssl_options' in settings) try: flower.start() except (KeyboardInterrupt, SystemExit): pass
def ready(MainApp, port, addr=None, family=None, backlog=1048576, reuse_port=True, debug=False, mmfile=None, **kwargs): #import pymysql #pymysql.install_as_MySQLdb() global DEBUG import sys sys.argv.extend([ '--%s=%s' % (k, v) for k, v in { 'logging': 'debug' if DEBUG else 'error', 'log_rotate_mode': 'time', 'log_file_prefix': 'logs/server.%s.log' % port, 'log_file_num_backups': 30, 'log_rotate_interval': 1, 'log_file_max_size': 100 * 1000 * 1000, 'log_to_stderr': False }.items() ]) from tornado import options, locale, log import finup_model, handlers # options.parse_config_file("server.conf") options.define("port", default=finup_model.PORT, help="port to listen on") remain_args = options.parse_command_line() locale.get() settings = { 'gzip': True, 'static_url_prefix': "/yihao01-face-recognize/static/", 'template_path': os.path.join((os.path.dirname(__file__)), 'template'), 'static_path': os.path.join((os.path.dirname(__file__)), 'static'), 'websocket_ping_interval': 1, 'websocket_ping_timeout': 5, 'max_message_size': 16 * 1024 * 1024, 'cookie_secret': 'abaelhe.0easy.com', 'cookie_domain': '.0easy.com', 'token': True, 'debug': debug, 'autoreload': debug, } log.app_log.info( 'Listen:%s:%s\nConfigs:\n%s\nRunning.\n' % (addr, finup_model.PORTS, ''.join([ ' %s = %s\n' % (k, v) for k, v in reversed( sorted(options.options.items(), key=lambda i: i[0])) if k != 'help' ]))) web_handlers = [ (r'/finup', handlers.FinupHandler), (r'/sys', handlers.SysHandler), # (r'/sock', handlers.SockHandler), # (r'/yihao01-face-recognize/target', receiver.TargetHandler), ] sock_handlers = [] app = MainApp(handlers=web_handlers + sock_handlers, **settings) port = int(port) app.listen(port, addr=finup_model.ADDR, debug=debug, reuse_port=reuse_port, **kwargs)
def main(): parse_command_line() http_server = tornado.httpserver.HTTPServer(Application()) http_server.listen(options.port) tornado.ioloop.IOLoop.instance().start()
def setup_options(): parse_command_line() config_path = options.config config = parseParams(config_path) pass
class RequestHandler(tornado.web.RequestHandler): def get(self): self.write('<h1>武汉的秋天最多一个星期</h1>') out_time = datetime.now() + timedelta(days=1) self.set_cookie('token', 'asfasdfsdaf', expires=out_time) self.clear_cookie('token') #这是清除指定的cookie # self.clear_all_cookies() #清除所有的cookie # self.set_status(404) # self.redirect('/') def make_app(): return tornado.web.Application(handlers=[ (r'/', IndexHandler), (r'/req/', RequestHandler), ], autoreload=True, debug=True) #自动重启 开启debug模式 检测到代码修改重启服务 #python tornado2.py --port=8081 if __name__ == "__main__": #解析命令行 parse_command_line() #读取命令行 获取其中的参数 app = make_app() app.listen(options.port) tornado.ioloop.IOLoop.current().start()
def runserver(): parse_command_line() app = tornado.web.Application(handlers=get_routes(), debug=settings.DEBUG) app.listen(address=options.host, port=options.port) tornado.ioloop.IOLoop.current().start()
def main(): parse_command_line() rest_app = tornado.web.Application( [ # Users (USER_AUTH_URL, UserAuthHandler), (USER_CHECK_URL, UserCheckHandler), (USER_LOGOUT_URL, UserLogoutHandler), (USER_DETAIL_URL, UserDetailHandler), (USER_LIST_URL, UserListHandler), # Patients (PATIENT_STUDIES_URL, PatientStudiesHandler), (PATIENT_DETAIL_URL, PatientDetailHandler), (PATIENT_LIST_URL, PatientListHandler), # Studies (STUDY_SERIES_URL, StudySeriesHandler), (STUDY_DETAIL_URL, StudyDetailHandler), (STUDY_LIST_URL, StudyListHandler), # Series (SERIES_INSTANCES_URL, SeriesInstancesHandler), (SERIES_DETAIL_URL, SeriesDetailHandler), (SERIES_LIST_URL, SeriesListHandler), # Instances (INSTANCE_PROCESS_URL, InstanceProcessHandler), (INSTANCE_TAGS_URL, InstanceTagsHandler), (INSTANCE_IMAGE_URL, InstanceImageHandler), (INSTANCE_RAW_URL, InstanceRawHandler), (INSTANCE_DETAIL_URL, InstanceDetailHandler), (INSTANCE_LIST_URL, InstanceListHandler), (INSTANCE_UPLOAD_URL, InstanceUploadHandler), # Dicom Nodes (DICOM_NODE_DETAIL_URL, DicomNodeDetailHandler), (DICOM_NODE_LIST_URL, DicomNodeListHandler), # (DICOM_NODE_ECHO_URL, DicomNodeEchoHandler), (DICOM_NODE_INSTANCES_URL, DicomNodeInstancesLoadHandler), # Plugins (PLUGIN_DETAIL_URL, PluginDetailHandler), (PLUGIN_LIST_URL, PluginListHandler), (PLUGIN_INSTALL_URL, InstallPluginHandler), # Media download (MEDIA_URL, tornado.web.StaticFileHandler, {'path': 'media'}) ], cookie_secret=settings.SECRET_KEY) rest_port = options.rest_port or settings.DICOMWEB_SERVER['port'] if settings.RUN_DICOM: new_pid = os.fork() if new_pid == 0: try: logging.info('DICOM server starting at port = %d' % settings.DICOM_SERVER['port']) dicom_server = DICOMServer(ae_title=settings.DICOM_SERVER['aet'], port=settings.DICOM_SERVER['port'], scp_sop_class=StorageSOPClassList + [VerificationSOPClass], transfer_syntax=UncompressedPixelTransferSyntaxes) dicom_server.start() except (KeyboardInterrupt, SystemExit): logging.info('DICOM server finishing...') logging.info('Child process exiting...') sys.exit(0) elif new_pid > 0: try: rest_server = tornado.httpserver.HTTPServer(rest_app) rest_server.bind(rest_port) rest_server.start() logging.info('Rest server starting at port = %d' % settings.DICOMWEB_SERVER['port']) tornado.ioloop.IOLoop.current().start() except (KeyboardInterrupt, SystemExit): logging.info('Rest server finishing...') os.kill(new_pid, signal.SIGINT) logging.info('Parent process exiting...') sys.exit(0) else: logging.error('Can not fork any processes') else: try: rest_server = tornado.httpserver.HTTPServer(rest_app) rest_server.bind(rest_port) rest_server.start() logging.info('Rest server starting at port = %d' % rest_port) tornado.ioloop.IOLoop.current().start() except (KeyboardInterrupt, SystemExit): logging.info('Rest server finishing...') logging.info('Parent process exiting...') sys.exit(0)
resp_data['msg'] = '用户不存在' self.write(resp_data) self.set_header('Content-Type', 'application/json') else: self.write('upload data 必须是Json格式') self.write('login---get') def put(self): pass def delete(self): pass def make_app(): return Application([('/user', LoginHandler)], default_host=options.h) if __name__ == '__main__': define('p', default=7000, type=int, help='绑定端口') define('h', default='localhost', type=str, help='主机地址') parse_command_line() # 解析命令行 app = make_app() app.listen(options.p) print('Running http://%s:%s' % (options.h, options.p)) IOLoop.current().start()
def __init__(self, commons): self.commons = commons self.commons['safe_mode'] = False parse_command_line()
def main(): define( "url", default=os.environ.get("JUPYTERHUB_API_URL"), help=dedent( """ The JupyterHub API URL. """ ).strip(), ) define( "timeout", type=int, default=600, help=dedent( """ The idle timeout (in seconds). """ ).strip(), ) define( "cull_every", type=int, default=0, help=dedent( """ The interval (in seconds) for checking for idle servers to cull. """ ).strip(), ) define( "max_age", type=int, default=0, help=dedent( """ The maximum age (in seconds) of servers that should be culled even if they are active. """ ).strip(), ) define( "cull_users", type=bool, default=False, help=dedent( """ Cull users in addition to servers. This is for use in temporary-user cases such as tmpnb. """ ).strip(), ) define( "remove_named_servers", default=False, type=bool, help=dedent( """ Remove named servers in addition to stopping them. This is useful for a BinderHub that uses authentication and named servers. """ ).strip(), ) define( "concurrency", type=int, default=10, help=dedent( """ Limit the number of concurrent requests made to the Hub. Deleting a lot of users at the same time can slow down the Hub, so limit the number of API requests we have outstanding at any given time. """ ).strip(), ) define( "ssl_enabled", type=bool, default=False, help=dedent( """ Whether the Jupyter API endpoint has TLS enabled. """ ).strip(), ) define( "internal_certs_location", type=str, default="internal-ssl", help=dedent( """ The location of generated internal-ssl certificates (only needed with --ssl-enabled=true). """ ).strip(), ) define( "cull_admin_users", type=bool, default=True, help=dedent( """ Whether admin users should be culled (only if --cull-users=true). """ ).strip(), ) parse_command_line() if not options.cull_every: options.cull_every = options.timeout // 2 api_token = os.environ["JUPYTERHUB_API_TOKEN"] try: AsyncHTTPClient.configure("tornado.curl_httpclient.CurlAsyncHTTPClient") except ImportError as e: app_log.warning( "Could not load pycurl: %s\n" "pycurl is recommended if you have a large number of users.", e, ) loop = IOLoop.current() cull = partial( cull_idle, url=options.url, api_token=api_token, inactive_limit=options.timeout, cull_users=options.cull_users, remove_named_servers=options.remove_named_servers, max_age=options.max_age, concurrency=options.concurrency, ssl_enabled=options.ssl_enabled, internal_certs_location=options.internal_certs_location, cull_admin_users=options.cull_admin_users, ) # schedule first cull immediately # because PeriodicCallback doesn't start until the end of the first interval loop.add_callback(cull) # schedule periodic cull pc = PeriodicCallback(cull, 1e3 * options.cull_every) pc.start() try: loop.start() except KeyboardInterrupt: pass
def main(): define( 'url', default=os.environ.get('JUPYTERHUB_API_URL'), help="The JupyterHub API URL", ) define('timeout', type=int, default=600, help="The idle timeout (in seconds)") define( 'cull_every', type=int, default=0, help="The interval (in seconds) for checking for idle servers to cull", ) define( 'max_age', type=int, default=0, help= "The maximum age (in seconds) of servers that should be culled even if they are active", ) define( 'cull_users', type=bool, default=False, help="""Cull users in addition to servers. This is for use in temporary-user cases such as tmpnb.""", ) define( 'remove_named_servers', default=False, type=bool, help="""Remove named servers in addition to stopping them. This is useful for a BinderHub that uses authentication and named servers.""", ) define( 'concurrency', type=int, default=10, help="""Limit the number of concurrent requests made to the Hub. Deleting a lot of users at the same time can slow down the Hub, so limit the number of API requests we have outstanding at any given time. """, ) parse_command_line() if not options.cull_every: options.cull_every = options.timeout // 2 api_token = os.environ['JUPYTERHUB_API_TOKEN'] try: AsyncHTTPClient.configure( "tornado.curl_httpclient.CurlAsyncHTTPClient") except ImportError as e: app_log.warning( "Could not load pycurl: %s\n" "pycurl is recommended if you have a large number of users.", e, ) loop = IOLoop.current() cull = partial( cull_idle, url=options.url, api_token=api_token, inactive_limit=options.timeout, cull_users=options.cull_users, remove_named_servers=options.remove_named_servers, max_age=options.max_age, concurrency=options.concurrency, ) # schedule first cull immediately # because PeriodicCallback doesn't start until the end of the first interval loop.add_callback(cull) # schedule periodic cull pc = PeriodicCallback(cull, 1e3 * options.cull_every) pc.start() try: loop.start() except KeyboardInterrupt: pass
def main(): parse_command_line() application = tornado.web.Application([(r"/movie", FileHandler)], debug=options.debug) application.listen(options.port) tornado.ioloop.IOLoop.instance().start()
def main(): parse_command_line() app = MakeApp() print("search 127.0.0.1:8888/AD") app.listen(options.port, address="0.0.0.0") tornado.ioloop.IOLoop.instance().start()
from tornado import options as tnd_options from tornado.options import define, options from message_queue.log_consumer import LogConsumer from message_queue.render_consumer import RenderConsumer from settings import settings from urls import url_patterns LOG_FORMAT = ('%(levelname) -10s %(asctime)s %(name) -30s %(funcName) ' '-35s %(lineno) -5d: %(message)s') define("port", default=8000, help="run on the given port", type=int) if __name__ == "__main__": logging.basicConfig(level=logging.INFO, format=LOG_FORMAT) tnd_options.parse_command_line() app = tornado.web.Application(handlers=url_patterns, **settings) http_server = httpserver.HTTPServer(app) http_server.listen(options.port) io_loop = ioloop.IOLoop.instance() render_consumer = RenderConsumer(io_loop) app.rc = render_consumer app.rc.connect() log_consumer = LogConsumer(io_loop) app.lc = log_consumer app.lc.connect() try: io_loop.start() except KeyboardInterrupt:
import tornado.ioloop from tornado.options import define, options, parse_command_line # 如果命令行中带有port同名参数则会称为全局tornado.options的属性,若没有则使用define定义。 define('port', default=8011, help='run on this port', type=int) define('debug', default=True, help='enable debug mode') options.parse_command_line() # 方法一 # parse_command_line() # 方法二 # 两个parse_command_line() 是一样的方法,两种不同的使用方式 # 作用是:转换命令行参数,并将转换后的值对应的设置到全局 options 对象相关的属性上 # 比如:nohup /home/work/.pyenv/versions/3.6/bin/python app.py -port=9520 > nohup.out & # 此时的 -port=9520 就会覆盖掉指定 define('port', default..) 端口 # 如果使用 -debug=xxx 就会覆盖掉指定 define('debug', default..) """ 除了 parse_command_line() 之外,还有 parse_config_file。 第二种是通过配置 config 文件来以其作用。如 port = 8000. 实际中大都不使用此方法 详情参见"http://www.python88.cn/book/tornado24/" 当我们在代码中调用parse_command_line()或者parse_config_file()的方法时, tornado会默认为我们配置标准logging模块,即默认开启了日志功能,并向标准输出(屏幕)打印日志信息。 如果想关闭tornado默认的日志功能,可以在命令行中添加--logging=none 或者在代码中执行如下操作: options.logging = None parse_command_line() """ import app