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
