def inner_run() -> None:
from django.conf import settings
from django.utils import translation
translation.activate(settings.LANGUAGE_CODE)
print("Validating Django models.py...")
self.check(display_num_errors=True)
print("\nDjango version %s" % (django.get_version()))
print("Tornado server is running at http://%s:%s/" % (addr, port))
print("Quit the server with %s." % (quit_command,))
if settings.USING_RABBITMQ:
queue_client = get_queue_client()
# Process notifications received via RabbitMQ
queue_client.register_json_consumer(notify_tornado_queue_name(int(port)),
process_notification)
queue_client.register_json_consumer(tornado_return_queue_name(int(port)),
respond_send_message)
try:
# Application is an instance of Django's standard wsgi handler.
application = create_tornado_application(int(port))
if settings.AUTORELOAD:
zulip_autoreload_start()
# start tornado web server in single-threaded mode
http_server = httpserver.HTTPServer(application,
xheaders=xheaders,
no_keep_alive=no_keep_alive)
http_server.listen(int(port), address=addr)
setup_event_queue(int(port))
add_client_gc_hook(missedmessage_hook)
setup_tornado_rabbitmq()
instance = ioloop.IOLoop.instance()
if django.conf.settings.DEBUG:
instance.set_blocking_log_threshold(5)
instance.handle_callback_exception = handle_callback_exception
instance.start()
except KeyboardInterrupt:
sys.exit(0)
def serve(self):
''' Start server listening on port, launch browser if requested,
and start the ioloop.
'''
self.http_server = httpserver.HTTPServer(self.app)
for retry in range(3):
try:
if self.options.external:
self.http_server.listen(self.options.port)
else:
self.http_server.listen(self.options.port,
address='localhost')
except socket.error:
# Possibly 'Address already in use', try finding another port.
if self.options.orig_port < 1 and retry < 2:
self.options.port = get_unused_ip_port()
else:
raise
else:
break
if not self.options.serveronly:
launch_browser(self.options.port, self.options.browser)
if self.options.external:
print '***********************************************************'
print '** WARNING: You have exposed the server to the external **'
print '** network. THIS IS NOT SAFE!! Clients will **'
print '** have access to a command prompt on the host **'
print '** computer with the identity and privileges of **'
print '** the userid under which the server was run. **'
print '** **'
print '** This is very dangerous and you should NOT do it. **'
print '** You exercise this option at your own risk!!! **'
print '** (Ctrl-C to terminate server) **'
print '***********************************************************'
DEBUG('Serving on port %d' % self.options.port)
try:
ioloop.IOLoop.instance().start()
except KeyboardInterrupt:
DEBUG('interrupt received, shutting down.')
def main():
args = parse_arg()
config = Config()
if args.template != default_template:
app_log.info("Using custom template: %s", args.template)
config.HTMLExporter.template_file = args.template
config.NbconvertApp.fileext = 'html'
# config.CSSHTMLHeaderTransformer.enabled = False
template_path = pjoin(here, 'templates')
static_path = pjoin(here, 'static')
document_path = current_path
exporter = HTMLExporter(config=config, log=app_log)
env = Environment(loader=FileSystemLoader(template_path))
env.filters['markdown'] = markdown.markdown
# notebook
notebook_manager = FileNotebookManager(notebook_dir=current_path,
log=app_log)
settings = dict(
jinja2_env=env,
static_path=static_path,
exporter=exporter,
config=config,
pool=ThreadPoolExecutor(threads),
gzip=True,
log=app_log,
render_timeout=20,
document_path=document_path,
notebook_manager=notebook_manager,
)
app = web.Application(handlers, debug=True, **settings)
http_server = httpserver.HTTPServer(app, xheaders=True)
app_log.info("Listening on port %i", args.port)
http_server.listen(args.port)
instance = ioloop.IOLoop.instance()
tornado.autoreload.start(instance)
instance.start()
def init_webapp(self):
"""initialize tornado webapp and httpserver"""
self.web_app = NotebookWebApplication(self, self.kernel_manager,
self.notebook_manager,
self.cluster_manager, self.log,
self.base_project_url,
self.webapp_settings)
if self.certfile:
ssl_options = dict(certfile=self.certfile)
if self.keyfile:
ssl_options['keyfile'] = self.keyfile
else:
ssl_options = None
self.web_app.password = self.password
self.http_server = httpserver.HTTPServer(self.web_app,
ssl_options=ssl_options)
if ssl_options is None and not self.ip and not (self.read_only
and not self.password):
self.log.critical(
'WARNING: the notebook server is listening on all IP addresses '
'but not using any encryption or authentication. This is highly '
'insecure and not recommended.')
success = None
for port in random_ports(self.port, self.port_retries + 1):
try:
self.http_server.listen(port, self.ip)
except socket.error as e:
if e.errno != errno.EADDRINUSE:
raise
self.log.info(
'The port %i is already in use, trying another random port.'
% port)
else:
self.port = port
success = True
break
if not success:
self.log.critical(
'ERROR: the notebook server could not be started because '
'no available port could be found.')
self.exit(1)
def __init__(self, ioloop=None, aioloop=None, mosquittoClient=None):
self.ioloop = ioloop
self.aioloop = aioloop
self.mosquittoClient = mosquittoClient
if self.ioloop == None:
raise TypeError('ioloop error')
if self.aioloop == None:
raise TypeError('aioloop error')
self.clientObjectSet = set()
self.urlpatterns = [
(r'/', WebsocketClient, {
'server': self
}),
# 提供静态资源,调试时使用
# (r'/(.*)', StaticFileHandler,{'path': os.path.join(os.path.dirname(__file__), 'static/html'), 'default_filename': 'index.html'})
]
# self.ioloop.add_timeout(self.ioloop.time()+1,self.checkWebsocketClientHeart)
ssl_options = {
'certfile': '/ssl_file/websocket.pem',
'keyfile': '/ssl_file/websocket.key'
}
app = web.Application(
self.urlpatterns,
debug=DEBUG,
# autoreload=True,
# compiled_template_cache=False,
# static_hash_cache=False,
# serve_traceback=True,
static_path=os.path.join(os.path.dirname(__file__), 'static'),
template_path=os.path.join(os.path.dirname(__file__), 'template'),
autoescape=None, # 全局关闭模板转义功能
)
# if DEBUG:
wsServer = httpserver.HTTPServer(app)
# else:
# wsServer = httpserver.HTTPServer(app, ssl_options=ssl_options)
wsServer.listen(options.websocket_service_port)
self.ioloop.add_timeout(self.ioloop.time() + 10,
self.checkWebsocketClientHeart)
def postprocess(self, input):
"""Serve the build directory with a webserver."""
dirname, filename = os.path.split(input)
handlers = [(r"/(.+)", web.StaticFileHandler, {
'path': dirname
}), (r"/", web.RedirectHandler, {
"url": "/%s" % filename
})]
if ('://' in self.reveal_prefix
or self.reveal_prefix.startswith("//")):
# reveal specifically from CDN, nothing to do
pass
elif os.path.isdir(os.path.join(dirname, self.reveal_prefix)):
# reveal prefix exists
self.log.info("Serving local %s", self.reveal_prefix)
else:
self.log.info("Redirecting %s requests to %s", self.reveal_prefix,
self.reveal_cdn)
handlers.insert(0,
(r"/(%s)/(.*)" % self.reveal_prefix, ProxyHandler))
app = web.Application(
handlers,
cdn=self.reveal_cdn,
client=AsyncHTTPClient(),
)
# hook up tornado logging to our logger
log.app_log = self.log
http_server = httpserver.HTTPServer(app)
http_server.listen(self.port, address=self.ip)
url = "http://%s:%i/%s" % (self.ip, self.port, filename)
print("Serving your slides at %s" % url)
print("Use Control-C to stop this server")
if self.open_in_browser:
webbrowser.open(url, new=2)
try:
ioloop.IOLoop.instance().start()
except KeyboardInterrupt:
print("\nInterrupted")
def main():
parse_command_line()
app = tornado.web.Application([
(r"/api/get_domain", DomainListHandler),
(r"/api/get_record", RecordListHandler),
(r"/api/create_record", RecordCreateHandler),
(r"/api/remove_record", RecordRemoveHandler),
(r"/api/update_record", RecordIPUpdateHandler),
],
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,
)
server = httpserver.HTTPServer(app)
server.bind(options.port)
server.start(1)
print('%s Godaddy server start listening at: %s' % (Tool.current_time(), options.port))
ioloop.IOLoop.current().start()
def main(argv=None):
init_options()
tornado.options.parse_command_line(argv)
# create and start the app
app = make_app()
# load ssl options
ssl_options = None
if options.sslcert:
ssl_options = {
'certfile' : options.sslcert,
'keyfile' : options.sslkey,
}
http_server = httpserver.HTTPServer(app, xheaders=True, ssl_options=ssl_options)
log.app_log.info("Listening on %s:%i, path %s", options.host, options.port,
app.settings['base_url'])
http_server.listen(options.port, options.host)
ioloop.IOLoop.current().start()
def main():
port = int(sys.argv[1])
work_dir = sys.argv[2]
kernel_manager = MultiKernelManager(connection_dir=work_dir)
# we are only using one kernel:
kernel_id = '1'
kernel_manager.start_kernel(kernel_id=kernel_id)
logging.basicConfig(level=logging.INFO)
app = WebApp(kernel_manager)
server = httpserver.HTTPServer(app)
server.listen(port, '127.0.0.1')
app_log.info("Serving at http://127.0.0.1:%s" % port)
try:
ioloop.IOLoop.instance().start()
except KeyboardInterrupt:
app_log.info("Interrupted...")
finally:
kernel_manager.shutdown_all()
def main():
if not options.remote_url or not validators.url(options.remote_url):
parser.print_help()
return
app = tornado.web.Application([
(r'.*', ProxyHandler),
])
global PARSED_REMOTE_URL
PARSED_REMOTE_URL = urlparse.urlparse(options.remote_url)
logger.info('reverse proxy is running...')
logger.info('%s:%s <---> %s' % (options.host, options.port, options.remote_url))
signal.signal(signal.SIGINT, signal_handler)
server = httpserver.HTTPServer(app, xheaders=True)
server.listen(options.port, options.host)
# 支持 CTRL+C 退出程序
ioloop.PeriodicCallback(try_exit, 100).start()
tornado.ioloop.IOLoop.instance().start()
def main():
''' run the web server
'''
print '<<<' + str(os.getpid()) + '>>> main'
settings = {
'template_path': os.path.dirname(os.path.abspath(__file__)),
'debug': True,
}
application = web.Application([
web.url(r'/', IndexHandler),
web.url(r'/floats/?', FloatHandler),
web.url(r'/server/?', ServerHandler),
web.url(r'/(.*)', SamplesFileHandler),
], **settings)
print 'running web server on port:', WEB_SERVER_PORT
print "(that's your cue to point your Chrome browser at http://localhost:%d)" % WEB_SERVER_PORT
http_server = httpserver.HTTPServer(application)
http_server.listen(WEB_SERVER_PORT)
ioloop.IOLoop.instance().start()
def _bootstrap_web_server(self):
self._bootstrap_action('config')
self._bootstrap_action('log')
tornado_application = tornado.web.Application(
handlers=[
(r"/alarm_status", alarm.AlarmStatusHandler,
dict(registry=self.registry)),
(r"/text_to_speech", text_to_speech.TextToSpeechHandler,
dict(registry=self.registry)),
],
template_path=os.path.join(self.registry['project_path'], "templates"),
static_path=os.path.join(self.registry['project_path'], "static"),
ui_modules={}
)
http_server = httpserver.HTTPServer(tornado_application, xheaders=True)
http_server.listen(self.registry['config'].get('webserver.port'))
self.registry['log'].info('HAL startup')
ioloop.IOLoop.instance().start()
def main():
"""main"""
parser = configargparse.ArgParser(default_config_files=[
os.path.join(CURRENT_DIR, "server.conf"), "server.conf",
"/etc/skynet/server.conf"
])
parser.add("--debug", dest="debug", default=False, action="store_true")
parser.add("--no-debug", dest="debug", action="store_false")
parser.add("--log", dest="log", default="")
parser.add("--host",
dest="host",
default=os.environ.get("BIND", "127.0.0.1"))
parser.add("--port",
dest="port",
type=int,
default=int(os.environ.get("PORT", 80)))
parser.add("--model", dest="model", required=True)
parser.add("--gpu", dest="gpu", default=True, action="store_true")
parser.add("--no-gpu", dest="gpu", action="store_false")
parser.add("--gpu-memory-fraction",
type=float,
default=0.40,
dest="gpu_memory_fraction")
config = vars(parser.parse_args())
setup_log(config["log"])
logging.info("config: %s", config)
app = App(config)
server = httpserver.HTTPServer(app.http_app())
server.bind(config["port"], address=config["host"])
server.start()
logging.info("Server Start! Listen: %s",
[x.getsockname() for x in server._sockets.values()]) # pylint: disable=protected-access
tornado.ioloop.IOLoop.current().start()
def main():
# 重新设置一下日志级别，默认情况下，tornado 是 info
# py2 下 options.logging 不能是 Unicode
options.logging = native_str(settings.LOGGING_LEVEL)
# parse_command_line 的时候将 logging 的根级别设置为 info
options.parse_command_line()
# 如果是在 gitlab-ci 环境下运行，redis 的主机需要设置为 redis，同时没有密码
if options.gitlab_ci is not None:
settings.REDIS_HOST = 'redis'
settings.REDIS_PASSWORD = None
# 启动 tornado 之前，先测试 redis 是否能正常工作
RedisHelper.ping_redis()
global server
app = Application()
server = httpserver.HTTPServer(app, xheaders=True)
server.listen(options.port, options.host)
logger.info('fomalhaut is running on %s:%s' % (options.host, options.port))
signal.signal(signal.SIGTERM, sig_handler)
signal.signal(signal.SIGINT, sig_handler)
# ioloop.IOLoop.instance().start()
if sys.version_info >= (3, 5) and not PYPY:
# python 3.5 以上版本，可以使用 uvloop 来加速
# https://github.com/MagicStack/uvloop/issues/35
from tornado.platform.asyncio import AsyncIOMainLoop
import asyncio
try:
import uvloop
logger.info('use uvloop as ioloop')
asyncio.set_event_loop_policy(uvloop.EventLoopPolicy())
AsyncIOMainLoop().install()
asyncio.get_event_loop().run_forever()
except:
ioloop.IOLoop.instance().start()
else:
ioloop.IOLoop.instance().start()
def start_server(self, port_number, number_of_procs=0):
"""
Create a HTTP server and start it.
:param int port_number: the port number to bind the server to
:param int number_of_procs: number of processes to pass to
Tornado's ``httpserver.HTTPServer.start``.
If the application's ``debug`` setting is ``True``, then we are
going to run in a single-process mode; otherwise, we'll let
tornado decide how many sub-processes to spawn.
The following additional configuration parameters can be set on the
``httpserver.HTTPServer`` instance by setting them in the application
settings: ``xheaders``, ``max_body_size``, ``max_buffer_size``.
"""
signal.signal(signal.SIGTERM, self._on_signal)
signal.signal(signal.SIGINT, self._on_signal)
xheaders = self.application.settings.get('xheaders', False)
max_body_size = self.application.settings.get('max_body_size', None)
max_buffer_size = self.application.settings.get(
'max_buffer_size', None)
self.server = httpserver.HTTPServer(
self.application.tornado_application,
xheaders=xheaders,
max_body_size=max_body_size,
max_buffer_size=max_buffer_size)
if self.application.settings.get('debug', False):
self.logger.info('starting 1 process on port %d', port_number)
self.server.listen(port_number)
else:
self.logger.info('starting processes on port %d', port_number)
if tornado.version_info >= (4, 4):
self.server.bind(port_number, reuse_port=True)
else:
self.logger.warning('port reuse disabled, please upgrade to'
'at least Tornado 4.4')
self.server.bind(port_number)
self.server.start(number_of_procs)
def main(args, ws_args, server_type, *url_fmt_args):
import webbrowser
url = 'visualisation/{}.html?' + url_quote(
'ws_port={}&server_type={}&min_angle={}&max_angle={}&model_length={}'.
format(args.ws_port, server_type, *url_fmt_args))
default_url = url.format(args.type)
type_redirects = [('/' + t, web.RedirectHandler, {
'url': url.format(t),
'permanent': False
}) for t in PLOT_TYPES]
app = web.Application(
type_redirects + [('/', web.RedirectHandler, {
'url': default_url,
'permanent': False
}), ('/ws', ) + ws_args,
('/(.*)', web.StaticFileHandler, {
'path': os.path.dirname(__file__)
})],
# static_hash_cache=False allows changes to be seen on page reload; see
# http://www.tornadoweb.org/en/stable/web.html#tornado.web.Application
static_hash_cache=args.cache,
)
app.listen(args.ws_port, address=args.host)
http_server = httpserver.HTTPServer(app)
http_server.listen(args.http_port, address=args.host)
webbrowser.register('dwb', None, webbrowser.BackgroundBrowser('dwb'))
webbrowser.register('rekonq', None, webbrowser.BackgroundBrowser('rekonq'))
if not args.no_browser:
browser = webbrowser.get(args.browser)
browser.open('http://{}:{}/{}'.format(
(args.host if args.host else 'localhost'), args.http_port,
default_url))
ioloop.IOLoop.current().start()
def main(argv=sys.argv):
parser, opts = parseopts()
if not opts.config and not opts.files:
parser.print_help()
print(
'\nError: must specify files on the command line or through a config file'
)
sys.exit(1)
if opts.debug:
log.setLevel(logging.DEBUG)
applog.setLevel(logging.DEBUG)
weblog.setLevel(logging.DEBUG)
try:
template_dir = pkg_resources.resource_filename('tailon',
'../templates')
assets_dir = pkg_resources.resource_filename('tailon', '../assets')
except ImportError:
template_dir, assets_dir = None, None
config = main_config(opts)
application = Application(config, {}, template_dir, assets_dir)
server = httpserver.HTTPServer(application)
server.listen(config['port'], config['addr'])
lines = []
for group, files in config['files'].items():
group = group if group != '__ungrouped__' else 'ungrouped'
lines.append('%s:' % group)
for fn in files:
lines.append(fn)
log.debug('Config:\n%s', pprint.pformat(config))
log.debug('Files:\n%s', '\n - '.join(lines))
loop = ioloop.IOLoop.instance()
msg = 'Listening on %s:%s' % (config['addr'], config['port'])
loop.add_callback(log.info, msg)
loop.start()
def listen(self):
"""
Starts a website to listen on a port
"""
# TODO: Actually kill the server instead of sending 500
# See https://gist.github.com/mywaiting/4643396 mainly server.stop
# and ioloop.kill for this instance
application = web.Application([
(r"/", SiteHandler,
dict(variables=self.data_manager.variable_map,
index=self.id,
status=self.get_status()))
])
http_server = httpserver.HTTPServer(application)
http_server.add_sockets(
netutil.bind_sockets(self.BASE_PORT + 20 * self.id))
log.debug("Site %d listening on %d" %
(self.id, self.BASE_PORT + 20 * self.id))
self.set_status(SiteStatus.UP)
def main():
pprint.pprint(dict(os.environ), stream=sys.stderr)
if os.getenv('JUPYTERHUB_SERVICE_URL'):
url = urlparse(os.environ['JUPYTERHUB_SERVICE_URL'])
app = web.Application([
(r'.*/env', EnvHandler),
(r'.*/api/(.*)', APIHandler),
(r'.*/whoami/?', WhoAmIHandler),
(r'.*/owhoami/?', OWhoAmIHandler),
(r'.*/oauth_callback', HubOAuthCallbackHandler),
(r'.*', EchoHandler),
],
cookie_secret=os.urandom(32))
server = httpserver.HTTPServer(app)
server.listen(url.port, url.hostname)
try:
ioloop.IOLoop.instance().start()
except KeyboardInterrupt:
print('\nInterrupted')
def main():
init_options()
tornado.options.parse_command_line()
# create and start the app
app = make_app()
# load ssl options
ssl_options = None
if options.sslcert:
ssl_options = {
'certfile': options.sslcert,
'keyfile': options.sslkey,
}
http_server = httpserver.HTTPServer(app,
xheaders=True,
ssl_options=ssl_options)
log.app_log.info("Listening on port %i", options.port)
http_server.listen(options.port)
ioloop.IOLoop.instance().start()
def launch_server():
state = State(get_client(options.hdfs_host, options.use_kerberos))
application = tornado.web.Application([
(r"/v1/completetions", GetCompletetionsHandler, dict(state=state)),
(r"/v1/list", ListHandler, dict(state=state)),
])
if options.unix_socket:
sockets = [netutil.bind_unix_socket(options.unix_socket)]
elif options.port_file:
sockets = netutil.bind_sockets(0, address=options.local_host)
port = sockets[0].getsockname()[1]
with open(options.port_file, "w+") as port_file:
port_file.write(str(port))
else:
sys.stderr.write("Use either --unix_socket or --port_file\n")
return
server = httpserver.HTTPServer(application)
server.add_sockets(sockets)
tornado.ioloop.IOLoop.current().start()
def __init__(self, bot: Life):
self.bot = bot
self.endpoints = [main, dashboard, metrics, websocket]
self.application = web.Application(
[
endpoint for endpoints in
[endpoint.setup(bot=self.bot) for endpoint in self.endpoints]
for endpoint in endpoints
],
static_path=os.path.join(os.path.dirname(__file__), 'static/'),
template_path=os.path.join(os.path.dirname(__file__),
'templates/'),
cookie_secret=self.bot.config.cookie_secret,
default_host='0.0.0.0',
debug=True)
self.bot.http_server = httpserver.HTTPServer(self.application,
xheaders=True)
self.bot.http_client = http.HTTPClient(bot=self.bot)
def __init__(self, host='127.0.0.1', port=8080, **options):
## Generic Variables ##
super(CustomTornado, self).__init__(host=host, port=port, **options)
## Extras ##
self.handlers = []
# Web Socket Handlers #
self.handlers.append((r'/status', WebsocketHandler, {
'ws_manager': self.options['ws_manager0']
}))
self.handlers.append((r'/traps', WebsocketHandler, {
'ws_manager': self.options['ws_manager1']
}))
# HTML Handler #
self.handlers.append((r".*", web.FallbackHandler, {
'fallback':
wsgi.WSGIContainer(self.options['web_app'])
}))
# Server Instances #
self.tornado_app = web.Application(self.handlers)
self.server = httpserver.HTTPServer(self.tornado_app)
self.ioloop = ioloop.IOLoop.instance()
def run_from_argv(self, prog_name, argv=None):
argv = list(filter(self.tornado_option, argv))
parse_command_line([prog_name] + argv)
logging.info("Starting http server on port %s..." % options.port)
application = Application(celery_app=self.app)
http_server = httpserver.HTTPServer(application)
http_server.listen(options.port, options.address)
bloader = BaseLoader(self.app)
bloader.import_default_modules()
logging.info("Registered tasks:")
logging.info(pformat(list(self.app.tasks.keys())))
logging.info("Setting up non-blocking producer...")
setup_nonblocking_producer()
loop = asyncio.get_event_loop()
application.init_with_loop(loop)
loop.run_forever()
def init_app(on_port=None, closable=False, **params):
_logger.debug('Using params: %s', params)
params.update({'closable': closable})
port = params.pop('port', 0)
ip = params.pop('ip', '127.0.0.1')
app = make_app(**params)
#pin remote access
app.settings['allow_remote_access'] = True
if port != 0:
server = app.listen(port, address=ip)
_logger.info('Listening on %s, port %d', ip, port)
else:
sockets = netutil.bind_sockets(0, ip)
server = httpserver.HTTPServer(app)
server.add_sockets(sockets)
for s in sockets:
_logger.info('Listening on %s, port %d', *s.getsockname()[:2])
port = s.getsockname()[1]
if on_port is not None:
on_port(port)
return app, server
def main():
log.enable_pretty_logging()
username = os.environ['SHARDER_DB_USERNAME']
password = os.environ['SHARDER_DB_PASSWORD']
dbname = os.environ['SHARDER_DB_NAME']
consumers = {os.environ['LTI_KEY']: os.environ['LTI_SECRET']}
# Stringify each line so we can use it as keys
sharder_buckets = [
l for l in json.loads(os.environ['SHARDER_BUCKETS']).split('\n')
if l.strip()
]
sharder = Sharder('localhost', username, password, dbname, 'hub',
sharder_buckets, log.app_log)
dbpool = psycopg2.pool.ThreadedConnectionPool(1,
4,
user=username,
host='localhost',
password=password,
dbname=dbname)
with dbpool.getconn() as conn:
try:
with conn.cursor() as cur:
cur.execute(SCHEMA)
conn.commit()
log.app_log.info('Finished running schema creation SQL')
finally:
dbpool.putconn(conn)
application = web.Application([
(r"/hub/lti/launch", ShardHandler),
],
sharder=sharder,
consumers=consumers,
debug=True,
dbpool=dbpool)
http_server = httpserver.HTTPServer(application)
http_server.listen(8888)
ioloop.IOLoop.current().start()
def init_webapp(self):
"""initialize tornado webapp and httpserver"""
self.web_app = NotebookWebApplication(self, self.kernel_manager,
self.notebook_manager,
self.cluster_manager, self.log,
self.base_project_url,
self.webapp_settings)
if self.certfile:
ssl_options = dict(certfile=self.certfile)
if self.keyfile:
ssl_options['keyfile'] = self.keyfile
else:
ssl_options = None
self.web_app.password = self.password
self.http_server = httpserver.HTTPServer(self.web_app,
ssl_options=ssl_options)
if ssl_options is None and not self.ip and not (self.read_only
and not self.password):
self.log.critical(
'WARNING: the notebook server is listening on all IP addresses '
'but not using any encryption or authentication. This is highly '
'insecure and not recommended.')
# Try random ports centered around the default.
from random import randint
n = 50 # Max number of attempts, keep reasonably large.
for port in range(self.port, self.port + 5) + [
self.port + randint(-2 * n, 2 * n) for i in range(n - 5)
]:
try:
self.http_server.listen(port, self.ip)
except socket.error, e:
if e.errno != errno.EADDRINUSE:
raise
self.log.info(
'The port %i is already in use, trying another random port.'
% port)
else:
self.port = port
break
def main():
"""Esign DB program main function."""
handlers = [
(r'/', IndexHandler),
(r'/text', TextHandler),
(r'/back/api/explain', TextHandler),
(r'/test(?P<path>.*)?', TestHandler),
(r'/service-worker.js', ServiceWorkerHandler),
]
handlers += [(f'/middle{handler[0]}', handler[1])
for handler in HANDLER_LIST]
# handlers += PAY_URLS
tornado_app = web.Application(
handlers=handlers,
template_path=os.path.join(os.path.dirname(__file__), 'templates'),
static_path=os.path.join(os.path.dirname(__file__), 'static'),
cookie_secret='QiNDQXm6ReOfl1VOGhdLoZ0f3ZucyEg6psGNLu1tWZE=',
)
tornado_server = httpserver.HTTPServer(
tornado_app,
xheaders=True,
)
# if options.port == 0:
# options.port = config.server.port
# else:
# config.server.port = options.port
tornado_server.listen(config.server.port)
print('start listen...')
sys.stdout.write('\nconfig:\n')
json.dump(config.traverse(), sys.stdout, indent=4, sort_keys=True)
sys.stdout.write('\n\n\n')
sys.stdout.flush()
ioloop.IOLoop.instance().start()
def start_server(self):
logging.basicConfig(
level=self.config['log']['level'], # Set to 10 for debug.
filename=self.config['log']['file'],
format=
'%(asctime)s (%(filename)s:%(lineno)s)- %(levelname)s - %(message)s',
)
logging.Formatter.converter = time.gmtime
logging.getLogger('requests').setLevel(logging.WARNING)
logging.getLogger('tornado').setLevel(logging.WARNING)
logging.info('=' * 80)
port = self.get_port() # We need to have a fixed port in both forks.
logging.info('Listening on port {}'.format(port))
if os.fork():
server = httpserver.HTTPServer(self)
server.bind(self.get_port(),
address=self.config.get('ip', '0.0.0.0'))
server.start(self.config['threads_nb'])
ioloop.IOLoop.current().start()
elif os.fork():
time.sleep(
2) # We sleep for a few seconds to let the registry start.
# Send a heartbeat callback
cb = Callback(self, '/heartbeat', sleep_duration=0)
cb()
else:
time.sleep(
2) # We sleep for a few seconds to let the registry start.
if self.config.get('callbacks', None) is not None:
for key, val in self.config['callbacks'].items():
if os.fork():
if val['threads']:
process.fork_processes(val['threads'])
ioloop.PeriodicCallback(
Callback(self,
val['uri'],
sleep_duration=val.get('sleep', 0)),
val['period'] * 1000).start()
ioloop.IOLoop.instance().start()
def init_webapp(self):
"""initialize tornado webapp and httpserver"""
self.web_app = NotebookWebApplication(self, self.kernel_manager,
self.notebook_manager,
self.cluster_manager, self.log,
self.base_project_url,
self.webapp_settings)
if self.certfile:
ssl_options = dict(certfile=self.certfile)
if self.keyfile:
ssl_options['keyfile'] = self.keyfile
else:
ssl_options = None
self.web_app.password = self.password
self.http_server = httpserver.HTTPServer(self.web_app,
ssl_options=ssl_options)
if not self.ip:
warning = "WARNING: The notebook server is listening on all IP addresses"
if ssl_options is None:
self.log.critical(warning + " and not using encryption. This"
"is not recommended.")
if not self.password and not self.read_only:
self.log.critical(
warning + "and not using authentication."
"This is highly insecure and not recommended.")
success = None
for port in random_ports(self.port, self.port_retries + 1):
try:
self.http_server.listen(port, self.ip)
except socket.error, e:
if e.errno != errno.EADDRINUSE:
raise
self.log.info(
'The port %i is already in use, trying another random port.'
% port)
else:
self.port = port
success = True
break
