def load_logger_config(self): """ 重定义tornado自带的logger,可重写 """ config = self.settings.LOG_CONFIG options.logging = config["level"] options.log_to_stderr = config["log_to_stderr"] options.log_file_max_size = config["filesize"] options.log_file_num_backups = config["backup_num"] #tornado把默认的根logger加了handler #把根logger的handler去除,然后重新绑定在tornado的logger下 logging.getLogger().handlers = [] tornado_logpath = os.path.join(options.log_prefix, 'tornado_access_log') if not os.path.exists(tornado_logpath): os.makedirs(tornado_logpath) file_name = "%s_access_log.%s.log" % ('tornado', str(options.port)) options.log_file_prefix = os.path.join(tornado_logpath, file_name) enable_pretty_logging(None, logging.getLogger('tornado')) if self.settings.LOG_RELATED_NAME: for k, log in self.settings.LOG_RELATED_NAME.items(): path = os.path.join(options.log_prefix, k) if not os.path.exists(path): os.makedirs(path) options.log_file_prefix = os.path.join(path, "%s_log.%s.log" % (log, str(options.port))) enable_pretty_logging(None, logging.getLogger(log)) return self
def config_logger(namespace=NETLOGGER_NAMESPACE, level = None, filename = None): tmpLog = nllog.get_logger(namespace) tmpLog.propagate = False nllog.PROJECT_NAMESPACE = namespace if filename: add_filehandler(tmpLog, filename) else: handler = logging.StreamHandler() handler.setFormatter(LogFormatter("%(message)s")) tmpLog.addHandler(handler) if level == "WARN": tmpLog.setLevel(logging.WARN) elif level == "TRACE": tmpLog.setLevel(nllog.TRACE) elif level == "DEBUG": tmpLog.setLevel(logging.DEBUG) if not filename: enable_pretty_logging() elif level == "CONSOLE": tmpLog.setLevel(25) else: tmpLog.setLevel(logging.INFO) return tmpLog
def start(): from tornado.log import enable_pretty_logging enable_pretty_logging() tornado.options.parse_command_line() import_object('devsniff.proxy') import_object('devsniff.admin') server_root = dirname(__file__) proxy_settings = dict( debug=tornado_options.debug, template_path=path_join(server_root, "templates"), static_path=path_join(server_root, "static"), ) proxy_app = TornadoWebApplication(route.get_routes(), **proxy_settings) proxy_bind = parse_bind_address(tornado_options.bind) if tornado_options.debug: proxy_app.listen(proxy_bind[1], proxy_bind[0]) else: server = tornado.httpserver.HTTPServer(proxy_app) server.bind(proxy_bind[1], proxy_bind[0]) server.start(0) io_loop = tornado.ioloop.IOLoop.instance() io_loop.add_callback(init_app) io_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 load_settings(): ''' Load settings from command line and config file. ''' # Parse command line options.logging = 'none' # To turn off logging settings options.log_to_stderr = True # Log to stderr parse_command_line() # Load settings from another config file if given if options.config: parse_config_file(options.config + '.conf') # Log file prefix options.log_file_prefix = ''.join(( 'log/', options.name, '-', str(options.port), '.log', )) # Logging settings if options.logging == 'none': # There are no logging settings before options.logging = 'debug' if options.debug else 'info' enable_pretty_logging(options=options) pretty_options_output()
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(urls): class BatchFetcher: n = 0 def __call__(self, title, fetcher): if isinstance(title, bytes): try: title = title.decode('gb18030') except UnicodeDecodeError: pass url = ' <- '.join(reversed(fetcher.url_visited)) logger.info('done: [%d] %s <- %s' % (fetcher.status_code, title, url)) self.n -= 1 if not self.n: tornado.ioloop.IOLoop.instance().stop() def add(self, url): TitleFetcher(url, self, url_finders=(GithubFinder,)) self.n += 1 from tornado.log import enable_pretty_logging enable_pretty_logging() f = BatchFetcher() for u in urls: f.add(u) tornado.ioloop.IOLoop.instance().start()
def main(): import getpass from tornado import options from tornado.log import enable_pretty_logging options.define("xmpp", default=None, help="XMPP Account", metavar="XMPP") options.define("qq", default=None, type=int, help="QQ Account", metavar="QQ") options.define("debug", type=bool, default=False, help="Show debug info") options.define("control", default=None, help="XMPP Control Account", metavar="CONTROL") options.parse_command_line() xmpp = options.options.xmpp qq = options.options.qq control = options.options.control debug = options.options.debug if not xmpp or not qq or not control: options.print_help() return xmpp_pwd = getpass.getpass(u"Enter XMPP Password: "******"Enter QQ Password: ") enable_pretty_logging() client = MagpieClient(qq, qq_pwd, xmpp, xmpp_pwd, control, debug) client.run()
def server_start(self): logging.info('server starting...') logger_module.logger.load_config() #tornado把默认的根logger加了handler #把根logger的handler去除,然后重新绑定在tornado的logger下 logging.getLogger().handlers = [] enable_pretty_logging(None, logging.getLogger('tornado')) #服务启动 from tornado.netutil import bind_sockets if self.settings.IPV4_ONLY: import socket sockets = bind_sockets(options.port, options.address, family=socket.AF_INET) else: sockets = bind_sockets(options.port, options.address) self.print_settings_info() http_server = tornado.httpserver.HTTPServer(self.application) http_server.add_sockets(sockets) logging.info('tornado server started. listen port: %s ,host address: %s' % (options.port, options.address)) tornado.ioloop.IOLoop.instance().start()
def setup_logger(): # tornado log.enable_pretty_logging() # the logger used in this daemon logger = logging.getLogger('tmacd') logger.propagate = False logger.setLevel(logging.DEBUG) # rotate on Sunday handler = logging.handlers.TimedRotatingFileHandler('/tmp/tmacd.log', when='w6', atTime=datetime.time()) handler.setLevel(logging.DEBUG) # align columns for my eyes formatter = logging.Formatter('{asctime}|{levelname:_<8}|{message}', style='{') handler.setFormatter(formatter) logger.addHandler(handler) # the logger used for acd_cli logger = logging.getLogger('acd') logger.propagate = False logger.setLevel(logging.DEBUG) # rotate on Sunday handler = logging.handlers.TimedRotatingFileHandler('/tmp/acd.log', when='w6', atTime=datetime.time()) handler.setLevel(logging.DEBUG) # the message already has timestamp formatter = logging.Formatter('%(message)s') handler.setFormatter(formatter) logger.addHandler(handler)
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 setup_logging(self): if options.debug and options.logging == 'info': options.logging = 'debug' enable_pretty_logging() else: logging.getLogger("tornado.access").addHandler(NullHandler()) logging.getLogger("tornado.access").propagate = False
def mitmweb(args=None): # pragma: nocover from . import web # 输出请求日志 from tornado.log import enable_pretty_logging enable_pretty_logging() check_versions() parser = cmdline.mitmweb() options = parser.parse_args(args) if options.quiet: options.verbose = 0 proxy_config = process_proxy_options(parser, options) web_options = web.Options(**cmdline.get_common_options(options)) web_options.intercept = options.intercept web_options.wdebug = options.wdebug web_options.wiface = options.wiface web_options.wport = options.wport server = get_server(web_options.no_server, proxy_config) m = web.WebMaster(server, web_options) try: m.run() except KeyboardInterrupt: pass
def main(): parse_command_line() settings = dict( pipeline_file=options.pipeline ) app = remotecontrol.app.Application(settings) options.logging = str('DEBUG') enable_pretty_logging(options) app_log.setLevel(logging.DEBUG) server = HTTPServer(app) server.listen(options.port, options.host) app_log.info("Version: %s from: %s" % (remotecontrol.VERSION, remotecontrol.VERSION_DATE)) app_log.info("Listen on http://%s:%d/" % ( options.host if options.host != "" else "localhost", options.port) ) # app.processor.start() second_tick = None try: tornado.autoreload.add_reload_hook(app.manager.stop) second_tick = tornado.ioloop.PeriodicCallback(lambda: app.second_tick(), 1000) second_tick.start() tornado.ioloop.IOLoop.instance().start() except KeyboardInterrupt: second_tick.stop() app_log.info("stop second tick") app.manager.stop() tornado.ioloop.IOLoop.instance().stop() app_log.debug("Server shutdown.")
def main(): log.enable_pretty_logging() # construct OAuth URLs from jupyterhub base URL hub_api = os.environ['JUPYTERHUB_URL'].rstrip('/') + '/hub/api' authorize_url = hub_api + '/oauth2/authorize' token_url = hub_api + '/oauth2/token' user_url = hub_api + '/user' app = web.Application( [('/oauth_callback', JupyterHubLoginHandler), ('/', WhoAmIHandler)], login_url='/oauth_callback', cookie_secret=os.urandom(32), api_token=os.environ['JUPYTERHUB_API_TOKEN'], client_id=os.environ['JUPYTERHUB_CLIENT_ID'], redirect_uri=os.environ['JUPYTERHUB_SERVICE_URL'].rstrip('/') + '/oauth_callback', authorize_url=authorize_url, token_url=token_url, user_url=user_url, ) url = urlparse(os.environ['JUPYTERHUB_SERVICE_URL']) log.app_log.info( "Running basic whoami service on %s", os.environ['JUPYTERHUB_SERVICE_URL'] ) app.listen(url.port, url.hostname) IOLoop.current().start()
def parse_options(args, err_func): define('ports', multiple=True, type=int, help='listen ports (one or more)', metavar='PORT[,PORT,...]', default=[8001]) define('config', type=str, help='zaglushka config path') define('watch', type=bool, help='watch config and stubs for changes', default=True) from tornado.options import options options.logging = 'debug' enable_pretty_logging(options) script_name = args[0] simple_args = list(takewhile(lambda i: not i.startswith('--'), args[1:])) other_args = args[len(simple_args) + 1:] other_args.insert(0, script_name) if simple_args: if len(simple_args) > 2: err_func('More than two simple args') return None elif len(simple_args) == 2: config, ports = simple_args else: config = simple_args[0] ports = None options.config = config if ports: ports = (i.strip() for i in ports.split(',')) try: ports = map(int, ports) except (TypeError, ValueError): err_func('Wrong port value') return None options.ports = ports options.logging = 'debug' options.parse_command_line(args=other_args) return options
def run(filedict, port=None, debug=False): # print args # Set logging level options.logging = 'INFO' if debug: print 'Enter debug mode' options.logging = 'DEBUG' enable_pretty_logging(options) application = Application( [ (r'/', IndexHandler), ], static_path=os.path.join(root_path, 'static'), template_path=os.path.join(root_path, 'template'), debug=debug, ) for host, rules in application.handlers: for i in rules: logging.debug('URL rule %s', i.regex.pattern) application.yaml_filedict = filedict http_server = httpserver.HTTPServer(application) http_server.listen(port) print 'Colordesk server started: http://127.0.0.1:%s' % port try: ioloop.IOLoop.instance().start() except KeyboardInterrupt: print 'Stop colordesk server.'
def main(): """Entry point for bitsd.""" enable_pretty_logging() try: parse_config_file('/etc/bitsd.conf') except IOError: LOG.warning('Config file not found, using defaults and command line.') try: parse_command_line() except tornado.options.Error as error: sys.stderr.write('{}\n'.format(error)) sys.exit(0) persistence.start() server.start() listener.start() # Add signal handlers... signal.signal(signal.SIGTERM, sig_handler) signal.signal(signal.SIGINT, sig_handler) if not options.log_requests: logging.getLogger("tornado.access").setLevel(logging.WARNING) tornado.ioloop.IOLoop.instance().start()
def load_application(self, default_host='', transforms=None, wsgi=False): #加载app,进行初始化配置,如无ap参数,则使用内置app初始化 logger_module.logger.load_config() tornado.options.parse_command_line() #tornado把默认的根logger加了handler #把根logger的handler去除,然后重新绑定在tornado的logger下 logging.getLogger().handlers = [] enable_pretty_logging(None, logging.getLogger('tornado')) #加载本地化配置 if self.settings.TRANSLATIONS: try: tornado.locale.load_translations(self.settings.TRANSLATIONS_CONF.translations_dir) except: warnings.warn('locale dir load failure,maybe your config file is not set correctly.') #初始化app if not self.application: self.application = application_module.AppApplication(handlers=self.urls, default_host=default_host, transforms=transforms, wsgi=wsgi, **self.settings.get_settings('TORNADO_CONF')) self.application.project_path = self.proj_path if self.proj_path.endswith('/') else self.proj_path + '/' self.application.tmpl = import_object(self.settings.TEMPLATE_ENGINE) if self.settings.TEMPLATE_ENGINE else None return self.application
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: logger.error('url_prefix option is not supported anymore') 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 main(): tornado.web.Application(debug=env) http_server = HTTPServer(WSGIContainer(app)) enable_pretty_logging() options.parse_command_line() http_server.listen(options.port) IOLoop.instance().start() print('Quit the server with CONTROL-C')
def setup_logging(self): 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
def wac(group_dir, debug, timeout): define('debug', default=debug) define('timeout', default=timeout) define('group-dir', default=group_dir) if debug: options.logging = 'debug' enable_pretty_logging()
def configure_logging(self): enable_pretty_logging() self.root_logger = logging.getLogger('') if self.config.DEBUG: self.root_logger.setLevel(logging.DEBUG) logging.debug('Enable DEBUG logging')
def get_logger(self): """ Override this method to designate the logger for the application :return: a :py:class:`logging.Logger` instance """ enable_pretty_logging() return logging.getLogger("tornado.application")
def run(self): if not self.fPrepareWasCalled: self.fPrepareWasCalled = True self.fApplication.listen(PORT, address="0.0.0.0") enable_pretty_logging() self.running.emit() IOLoop.instance().start()
def run(self): if not self.fPrepareWasCalled: self.fPrepareWasCalled = True self.fApplication.listen(PORT, address="0.0.0.0") if int(os.getenv("MOD_LOG", "0")): enable_pretty_logging() self.running.emit() IOLoop.instance().start()
def make_app(): from tornado.log import enable_pretty_logging enable_pretty_logging() from handlers import StaticHandler, TemplateHandler, ApiHandler, main from build import build build("templates_jade", "templates") from common import mongodb from conf import config yield mongodb.init(config.MONGODB) settings = { "template_path": "templates", "autoreload": True, "debug": False, } ApiHandler.update_url_handlers({ "/api/200": main.do_return_ok, "/api/500": main.do_return_error, "/api/get_sequence_name": main.do_return_sequence_name, }) app = tornado.web.Application( [ (r"/main", main.MainHandler), # (.*) will pass the `request path` into the handler's get/post function, as an argument # ? why don't they just use `self.request.path` # Tornado use mimetypes.guess_type to obtain Content-Type so you'd better name them properly (r"/css/(.*)", StaticHandler, { "path": "static/css" }), (r"/js/(.*)", StaticHandler, { "path": "static/js" }), (r"/img/(.*)", StaticHandler, { "path": "static/img" }), (r"/api/.*", ApiHandler), # {"root": "templates"} will pass into the handler's initialize function (r"/(.*)", TemplateHandler, { "root": "templates", "default_filename": "index" }), ], **settings) app.listen(config.SYSTEM["listening_port"]) print("listening %s" % config.SYSTEM["listening_port"])
def server_start(): app = tornado.web.Application(urls, debug=options.debug) enable_pretty_logging() parse_command_line() server = tornado.httpserver.HTTPServer(app) server.bind(options.port) server.start(2) tcelery.setup_nonblocking_producer(limit=2) tonado.ioloop.IOLoop.current().start()
def start(self): """Start the API by loading the WebApplication object and creating an IO loop.""" log.enable_pretty_logging() application = WebApplication(self.handlers_initializer, None, debug=self.get('debug')) application.listen(self.port) # _logger.info('Gandalf %sAPI running on port %s', self.env + ' ' if self.env else '', self.port) ioloop.IOLoop.current().start()
def _set_log(): enable_pretty_logging() fmt = LogFormatter() for logger_name in ['tornado.access', 'tornado.application', 'tornado.general']: logger = logging.getLogger(logger_name) log_file_path = os.path.join(BASE_LOG_PATH, logger_name + '.log') log_handler = logging.FileHandler(log_file_path) log_handler.setFormatter(fmt) logger.addHandler(log_handler)
def main(): from tornado.log import enable_pretty_logging enable_pretty_logging() setupDb() initIpaddr() app = make_app() app.listen(8888) signal.signal(signal.SIGINT,stop_serv) IOLoop.current().start()
def logging(file_name): import logging FORMAT = '%(asctime)s - %(name)s - %(levelname)s - %(message)s' logging.basicConfig(filename=file_name, filemode='w', format=FORMAT, level=logging.DEBUG) enable_pretty_logging()
def main(): app = Application(sys.argv[1]) http_server = httpserver.HTTPServer(app) address, port = app.config["server"]["listen"].split(":") http_server.listen(int(port), address) http_server.start() print("Start server on {}".format(app.config["server"]["listen"])) log.enable_pretty_logging() ioloop.IOLoop.current().start()
def __init__(self, url, host="", method="get", params=None, data=None): self.host = host or DEFAULT_HOST self.port = host or DEFAULT_PORT self.url = url self.method = method self.params = params self.data = data # enable log enable_pretty_logging()
def init(): if not settings.LOGGER_LEVEL: settings.LOGGER_LEVEL = logging.NOTSET rt = RotatingFileHandler(filename=C_LOG_NAME, maxBytes=C_LOG_SIZE, backupCount=C_LOG_FILES) rt.setLevel(settings.LOGGER_LEVEL) rt.setFormatter(logging.Formatter('[%(asctime)s] %(message)s')) log = logging.getLogger() enable_pretty_logging() log.addHandler(rt) Logger.is_inited = True
def func(path, listener, port, target=None): # (based directly on the cli command code that ships with livereload) from tornado import log log.enable_pretty_logging() from livereload.server import Server server = Server() server.watcher.watch((target or path), delay=None) server.serve(host=None, port=port, root=path, open_url_delay=None)
def create_webapp(): enable_pretty_logging() application = tornado.web.Application( [ (r"/", IndexHandler), (r"/hooks/github", GithubHandler), ], debug=True, ) return application
def main(args=None): if args is None: args = sys.argv log.enable_pretty_logging() main_loop = ioloop.IOLoop.instance() main_loop.run_sync(alpha) return 0
def __init__(self, project_path=None, application=None): self.application = application self.settings = settings_module.settings self.proj_path = project_path logger_module.logger.load_config() tornado.options.parse_command_line() #tornado把默认的根logger加了handler #把根logger的handler去除,然后重新绑定在tornado的logger下 logging.getLogger().handlers = [] enable_pretty_logging(None, logging.getLogger('tornado'))
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() # 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 listen_and_serve(addr: Union[str, int], handler: Union[tornado.web.Application, list], debug: Optional[bool] = None, root_dir: str = ".", xheaders: bool = False, ioloop_start: bool = True): """ Listen and serve Usage example: listen_and_serve(":5000", [ (r"/", MainHandler), (r"/simple", SimpleHandler), ]) """ if isinstance(addr, int): port = addr else: host, port = addr.split(":", 1) port = int(port) if debug is None: debug = (os.getenv("DEBUG") == "true") #if _is_port_listening(port): # sys.exit("[simple_tornado] Warning, localhost:{} is already listening".format(port)) settings = { 'static_path': os.path.join(root_dir, 'static'), 'template_path': os.path.join(root_dir, 'templates'), 'debug': debug, } if isinstance(handler, list): handler = tornado.web.Application(handler, debug=debug) if xheaders: http_server = tornado.httpserver.HTTPServer(handler, xheaders=True) http_server.listen(port) else: handler.listen(port) if debug: enable_pretty_logging() #if sys.platform == 'win32' and sys.version_info[:2] == (3, 8): # import asyncio # asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy()) if ioloop_start: try: print("[simple_tornado] Listening on {}".format(addr)) IOLoop.instance().start() except KeyboardInterrupt: IOLoop.instance().stop()
def __init__(self, main, opts): self.main = main self.opts = opts self.main_dir = main.main_dir self.web_dir = os.path.join(self.main_dir, 'web') self.ssl_dir = os.path.join(self.web_dir, 'ssl') self.static_dir = os.path.join(self.web_dir, 'static') self.template_dir = os.path.join(self.web_dir, 'template') self.component_dir = os.path.join(self.template_dir, 'component') enable_pretty_logging() self.application = web.Application( [ (r'/', IndexHandler, dict(main=self.main)), (r'/login/?', LoginHandler, dict(main=self.main)), (r'/logout/?', LogoutHandler, dict(main=self.main)), (r"/confirm/?", ConfirmHandler, dict(main=self.main)), (r'/authorize/?', AuthorizeHandler, dict(main=self.main)), (r'/check_session/?', SessionHandler, dict(main=self.main)), (r'/static/(.*)', web.StaticFileHandler, dict(path=self.static_dir)), (r'/(favicon.ico)', web.StaticFileHandler, dict(path=self.static_dir)), (r'/api/db((/(.*))?)', apiDBHandler, dict(main=self.main)), (r'/api/role((/(.*))?)', apiRoleHandler, dict(main=self.main)), (r'/api/group((/(.*))?)', apiGroupHandler, dict(main=self.main)), (r'/api/user/aam((/(.*))?)', apiAAMUserHandler, dict(main=self.main)), (r'/api/user/local((/(.*))?)', apiLocalUserHandler, dict(main=self.main)), (r'/api/session((/(.*))?)', apiSessionHandler, dict(main=self.main)), (r'/admin', AdminHandler, dict(main=self.main)), (r'/agent', AgentHandler, dict(main=self.main)), # Not finished yet (r'/session_info', SessionInfoHandler, dict(main=self.main)), ], static_path=self.static_dir, template_path=self.template_dir, cookie_secret="61oETzKXQAGaYdkL5gEmGeJJFuYh7EQnp2XdTP1o/Vo=", login_url="/login", autoreload=self.opts['autoreload'], debug=True, xsrf_cookies=False, ) if opts['ssl']: ssl_options = { 'certfile': os.path.join(self.ssl_dir, opts['certfile']), 'keyfile': os.path.join(self.ssl_dir, opts['keyfile']), } self.http_server = HTTPServer(self.application, ssl_options=ssl_options) else: self.http_server = HTTPServer(self.application)
def parse_callback(): global settings settings.load(settings_package, options.settings) if pull_options: # let's pull options from the settings and vice versa for option_name in options: src, dst = (settings, options) if option_name in settings else (options, settings) setattr(dst, option_name, src[option_name]) # resets logging configuration enable_pretty_logging()
def get_app(): enable_pretty_logging() application = Application([ (r'/', HomeHandler), (r'/get', GetHandler), (r'/post', PostHandler), (r'/post/json', PostJsonHandler), (r'/raw', RawHandler), (r'/raw/json', RawJsonHandler), ]) return application
def run_server(): from tornado.log import enable_pretty_logging enable_pretty_logging() application = tornado.web.Application([ (r"/", MainHandler), ]) application.listen(8888) logging.info('starting server at 8888') tornado.ioloop.IOLoop.instance().start()
def main(): enable_pretty_logging() parser = argparse.ArgumentParser() parser.add_argument('-p', '--port', type=int, default=8000) parser.add_argument('-a', '--address', default='127.0.0.1') args = parser.parse_args() http_server = HTTPServer(application) http_server.listen(args.port, address=args.address) IOLoop.instance().start()
def run(port=2221, bind="0.0.0.0"): from libs.ftpserver import FTPServer from tornado.ioloop import IOLoop from tornado import autoreload autoreload.start() from tornado.log import enable_pretty_logging enable_pretty_logging() server = FTPServer(connect_cls=XunleiFTPConnection, debug=True) server.listen(port, bind) print 'listening on %s:%s' % (bind, port) IOLoop.instance().start()
def main(): http_server = tornado.httpserver.HTTPServer(app) """ http_server.listen("8000") enable_pretty_logging() tornado.ioloop.IOLoop.current().start() """ http_server.bind("8000") enable_pretty_logging() http_server.start(10) loop = tornado.ioloop.IOLoop.instance() loop.start()
def run(port=8886, bind='0.0.0.0'): from tornado.log import enable_pretty_logging enable_pretty_logging() application = tornado.web.Application([ (r"/(\d+)?", XunleiHandler), (r"/proxy/([^/]*)(?:/.*)?", ProxyHandler), ], debug=True) application.listen(port, bind) print 'listening on %s:%s' % (bind, port) tornado.ioloop.IOLoop.instance().start()
def create() -> Application: enable_pretty_logging() _handlers = [ (r"/orgs", OrgHandler), ] return Application( _handlers, cookie_secret=config.COOKIE_SECRET, debug=config.DEBUG, )
def main(): enable_pretty_logging() config = hermes.get_config('config.json', {}) debug = config.get('debug', False) app = Application(( url('/', IndexHandler), url('/version_check', VersionCheckHandler), ), debug=debug) app.listen(80) IOLoop.instance().start()
def run_from_argv(self, prog_name, argv=None, **_kwargs): 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 != 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() if options.auth: 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'), } if options.certfile and options.keyfile: settings['ssl_options'] = dict(certfile=abs_path(options.certfile), keyfile=abs_path(options.keyfile)) # 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 init_webapp(self): """Initializes Tornado web application with uri handlers. Adds the various managers and web-front configuration values to the Tornado settings for reference by the handlers. """ # Enable the same pretty logging the notebook uses enable_pretty_logging() # Configure the tornado logging level too logging.getLogger().setLevel(self.log_level) handlers = self.personality.create_request_handlers() self.web_app = web.Application( handlers=handlers, kernel_manager=self.kernel_manager, session_manager=self.session_manager, contents_manager=self.contents_manager, kernel_spec_manager=self.kernel_spec_manager, kg_auth_token=self.auth_token, kg_allow_credentials=self.allow_credentials, kg_allow_headers=self.allow_headers, kg_allow_methods=self.allow_methods, kg_allow_origin=self.allow_origin, kg_expose_headers=self.expose_headers, kg_max_age=self.max_age, kg_max_kernels=self.max_kernels, kg_env_process_whitelist=self.env_process_whitelist, kg_api=self.api, kg_personality=self.personality, # Also set the allow_origin setting used by notebook so that the # check_origin method used everywhere respects the value allow_origin=self.allow_origin, # Set base_url for use in request handlers base_url=self.base_url, # Always allow remote access (has been limited to localhost >= notebook 5.6) allow_remote_access=True) # promote the current personality's "config" tagged traitlet values to webapp settings for trait_name, trait_value in self.personality.class_traits( config=True).items(): kg_name = 'kg_' + trait_name # a personality's traitlets may not overwrite the kernel gateway's if kg_name not in self.web_app.settings: self.web_app.settings[kg_name] = trait_value.get( obj=self.personality) else: self.log.warning( 'The personality trait name, %s, conflicts with a kernel gateway trait.', trait_name)
def run(address, port): settings = { 'static_path': path.join(path.dirname(\ path.abspath(__file__)), 'static'), 'debug': DEBUG, 'autoload': AUTOLOAD, } app = tornado.web.Application(handlers=handlers, **settings) http_server = tornado.httpserver.HTTPServer(app, xheaders=True) tlog.enable_pretty_logging() http_server.listen(port) logger.info("server start at %s:%s"%(address, port)) tornado.ioloop.IOLoop.current().start()
def main(): if settings.DEBUG: from tornado.log import enable_pretty_logging enable_pretty_logging() application = tornado.web.Application([ (r'/greet', GreetHandler), ], ) # Spawn multiple process as necessary server = tornado.httpserver.HTTPServer(application) server.bind(settings.TORNADO_PORT_API) server.start(settings.TORNADO_PROCESSES) # Forks multiple sub-processes tornado.ioloop.IOLoop().current().start()
def set_logging(self): # TODO: This is not logging to a file correctly if self.settings and self.settings.LOG_PATH: # Create directory if not exists if not os.path.exists(self.settings.LOG_PATH): os.makedirs(self.settings.LOG_PATH) import logging # Create file handler log_file = os.path.join(self.settings.LOG_PATH, 'tornado.log') file_handler = logging.FileHandler(log_file) torando_logger = logging.getLogger("tornado.application") file_handler.setLevel(logging.INFO) torando_logger.setLevel(logging.INFO) torando_logger.addHandler(file_handler) tornado_log.enable_pretty_logging()
def main(port: int = 9100, debug: bool = False) -> None: enable_pretty_logging() app = make_app(debug=debug) app.listen(port) logger.info(f"Listening on port {port}") loop = asyncio.get_event_loop() def shutdown(): logger.info("Shutting down...") loop.stop for signal in (SIGTERM, SIGINT): loop.add_signal_handler(signal, loop.stop) loop.run_forever()