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 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 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()
