def _open(self, host, port, **kwargs):
# Note: does not get called if host is False. That way we can
# run Flexx in e.g. JLab's application.
# Hook Tornado up with asyncio. Flexx' BaseServer makes sure
# that the correct asyncio event loop is current (for this thread).
# http://www.tornadoweb.org/en/stable/asyncio.html
# todo: Since Tornado v5.0 asyncio is autom used, deprecating AsyncIOMainLoop
self._io_loop = AsyncIOMainLoop()
# I am sorry for this hack, but Tornado wont work otherwise :(
# I wonder how long it will take before this will bite me back. I guess
# we will be alright as long as there is no other Tornado stuff going on.
IOLoop._current.instance = None
self._io_loop.make_current()
# handle ssl, wether from configuration or given args
if config.ssl_certfile:
if 'ssl_options' not in kwargs:
kwargs['ssl_options'] = {}
if 'certfile' not in kwargs['ssl_options']:
kwargs['ssl_options']['certfile'] = config.ssl_certfile
if config.ssl_keyfile:
if 'ssl_options' not in kwargs:
kwargs['ssl_options'] = {}
if 'keyfile' not in kwargs['ssl_options']:
kwargs['ssl_options']['keyfile'] = config.ssl_keyfile
if config.tornado_debug:
app_kwargs = dict(debug=True)
else:
app_kwargs = dict()
# Create tornado application
self._app = Application([(r"/flexx/ws/(.*)", WSHandler),
(r"/flexx/(.*)", MainHandler),
(r"/(.*)", AppHandler), ], **app_kwargs)
self._app._io_loop = self._io_loop
# Create tornado server, bound to our own ioloop
if tornado.version_info < (5, ):
kwargs['io_loop'] = self._io_loop
self._server = HTTPServer(self._app, **kwargs)
# Start server (find free port number if port not given)
if port:
# Turn port into int, use hashed port number if a string was given
try:
port = int(port)
except ValueError:
port = port_hash(port)
self._server.listen(port, host)
else:
# Try N ports in a repeatable range (easier, browser history, etc.)
prefered_port = port_hash('Flexx')
for i in range(8):
port = prefered_port + i
try:
self._server.listen(port, host)
break
except (OSError, IOError):
pass # address already in use
else:
# Ok, let Tornado figure out a port
[sock] = netutil.bind_sockets(None, host, family=socket.AF_INET)
self._server.add_sockets([sock])
port = sock.getsockname()[1]
# Notify address, so its easy to e.g. copy and paste in the browser
self._serving = self._app._flexx_serving = host, port
proto = 'http'
if 'ssl_options' in kwargs:
proto = 'https'
logger.info('Serving apps at %s://%s:%i/' % (proto, host, port))
def main(argv=None): # pragma: no cover
'Main function'
parser = argparse.ArgumentParser(
description='ngshare, a REST API nbgrader exchange')
parser.add_argument(
'--vngshare',
help='Use vngshare (stand-alone mode)',
action='store_true',
)
parser.add_argument('--jupyterhub_api_url',
help='override $JUPYTERHUB_API_URL')
parser.add_argument(
'--prefix',
help='URL prefix (default: $JUPYTERHUB_SERVICE_PREFIX or "/api/")',
)
parser.add_argument('--debug', action='store_true', help='enable debug')
parser.add_argument(
'--database',
help='database url',
default='sqlite:////srv/ngshare/ngshare.db',
)
parser.add_argument('--storage',
help='path to store files',
default='/srv/ngshare/files/')
parser.add_argument('--admins',
help='admin user ids (comma splitted)',
default='')
parser.add_argument('--host',
help='bind hostname (vngshare only)',
default='127.0.0.1')
parser.add_argument('--port',
help='bind port (vngshare only)',
type=int,
default=12121)
parser.add_argument(
'--no-upgrade-db',
action='store_true',
help='do not automatically upgrade database',
)
args = parser.parse_args(argv)
if args.jupyterhub_api_url is not None:
os.environ['JUPYTERHUB_API_URL'] = args.jupyterhub_api_url
prefix = args.prefix or os.environ.get('JUPYTERHUB_SERVICE_PREFIX',
'/api/')
if not prefix.startswith('/') or not prefix.endswith('/'):
raise ValueError('API prefix should start and end with /')
if prefix.startswith('/healthz/'):
raise ValueError("API prefix may not start with /healthz/")
if not args.no_upgrade_db:
CmdOpts = namedtuple('CmdOpts', ['x'])
cmd_opts = CmdOpts(['data=true', 'storage=' + args.storage])
dbutil.upgrade(args.database, cmd_opts=cmd_opts)
if args.vngshare:
MyRequestHandler.__bases__ = (MockAuth, RequestHandler, MyHelpers)
app = MyApplication(
prefix,
args.database,
args.storage,
admin=args.admins.split(','),
debug=args.debug,
)
http_server = HTTPServer(app)
if args.vngshare:
http_server.listen(args.port, args.host)
app.vngshare = True
print()
print('Starting vngshare (Vserver-like Notebook Grader Share)')
print('DO NOT USE IN PRODUCTION')
print('Database file is %s' % repr(args.database))
print('Storage directory is %s' % repr(args.storage))
print('admin users are %s' % repr(app.admin))
print('Please go to http://%s:%d/api/' % (args.host, args.port))
else:
url = urlparse(os.environ['JUPYTERHUB_SERVICE_URL'])
# Must listen on all interfaces for proxy
http_server.listen(url.port, '0.0.0.0')
IOLoop.current().start()
while True:
diskused = 0
disktotal = 0
for i in psutil.disk_partitions():
try:
x = psutil.disk_usage(i.mountpoint)
diskused += x.used
disktotal += x.total
except OSError:
pass
stats['uptime'] = time.time() - psutil.boot_time()
stats['fqdn'] = socket.gethostname()
stats['cpuusage'] = psutil.cpu_percent(0)
stats['ramusage'] = psutil.virtual_memory()
stats['diskio'] = psutil.disk_io_counters()
stats['diskusage'] = [diskused, disktotal]
stats['netio'] = psutil.net_io_counters()
stats['swapusage'] = psutil.swap_memory()
time.sleep(1)
if __name__ == '__main__':
stats = Manager().dict()
Process(target=update, args=(stats, )).start()
if len(sys.argv) > 1:
PORT = sys.argv[1]
server = HTTPServer(WSGIContainer(app))
print 'Now listening on port ' + str(PORT)
server.listen(PORT)
IOLoop.instance().start()
class IndexHandler(RequestHandler):
def get(self, *args, **kwargs):
# self.set_secure_cookie("aa", "bb")
# self.write("ok")
# 1.xsrf防跨站在模板中使用
self.render("xsrftest.html")
def post(self, *args, **kwargs):
print self.get_argument("uname")
self.write(self.get_argument("uname"))
class AjaxHandler(RequestHandler):
def post(self, *args, **kwargs):
uname = self.get_argument("uname")
self.write(uname)
if __name__ == "__main__":
options.parse_config_file("./config.py")
app = Application([
(r'/', IndexHandler),
(r'/form/(.*)', StaticFileHandler,
dict(path=os.path.join(os.path.dirname(__file__), "statics/html"))),
(r'/new', AjaxHandler),
],
xsrf_cookies=True,
**options.conf)
cur_server = HTTPServer(app)
app.listen(options.port)
IOLoop.current().start()
from tornado.ioloop import IOLoop
from tornado import gen, web
from tornado.httpclient import AsyncHTTPClient
from tornado.httpserver import HTTPServer
url = 'http://hq.sinajs.cn/list=sz000001'
class GetPageHandler(web.RequestHandler):
@gen.coroutine
def get(self):
client = AsyncHTTPClient()
response = yield client.fetch(url, method='GET')
self.write(response.body.decode('gbk'))
self.finish()
application = web.Application([
(r"/getpage", GetPageHandler),
],
autoreload=True)
# application.listen(8765)
server = HTTPServer(application)
server.bind(8765)
server.start()
IOLoop.current().start()
page_data['url'] = url
page_data['detail'] = detail
self.render('result.html', **page_data)
return
settings = dict(
debug=True,
cookie_domain=SAE_DOMAIN,
login_url='/',
template_path='tmpl',
)
urls = [
('/upload', UploadHdl),
('/result', ResultHdl),
('/token', TokenHdl),
('/upload2', Upload2Hdl),
('/result2', Result2Hdl),
]
if on_sae:
app = tornado.wsgi.WSGIApplication(urls, **settings)
application = sae.create_wsgi_app(app)
else:
app = tornado.web.Application(urls, **settings)
server = HTTPServer(app, xheaders=True)
server.bind(PORT)
server.start()
tornado.ioloop.IOLoop.instance().start()
backlog = Configuration.getBacklog()
file_handler = RotatingFileHandler(logfile,
maxBytes=maxLogSize,
backupCount=backlog)
file_handler.setLevel(logging.ERROR)
formatter = logging.Formatter(
"%(asctime)s - %(name)s - %(levelname)s - %(message)s")
file_handler.setFormatter(formatter)
app.logger.addHandler(file_handler)
if flaskDebug:
# start debug flask server
app.run(host=flaskHost, port=flaskPort, debug=flaskDebug)
else:
# start asynchronous server using tornado wrapper for flask
# ssl connection
print("Server starting...")
if Configuration.useSSL():
cert = os.path.join(_runPath, "../", Configuration.getSSLCert())
key = os.path.join(_runPath, "../", Configuration.getSSLKey())
ssl_options = {"certfile": cert, "keyfile": key}
else:
ssl_options = None
signal.signal(signal.SIGTERM, sig_handler)
signal.signal(signal.SIGINT, sig_handler)
global http_server
http_server = HTTPServer(WSGIContainer(app), ssl_options=ssl_options)
http_server.bind(flaskPort, address=flaskHost)
http_server.start(0) # Forks multiple sub-processes
IOLoop.instance().start()
def get_http_server(self):
return HTTPServer(self._app,
io_loop=self.io_loop,
**self.get_httpserver_options())
def run_server(port: int,
address: str = "",
jobs: int = 1,
user: str = None,
workers: int = 0) -> None:
""" Run the server
:param port: port number
:param address: interface address to bind to (default to any)
:param jobs: Number of jobs to fork (default to 1: i.e no fork)
:user: User to setuid after opening ports (default no setuid)
"""
import traceback
from tornado.netutil import bind_sockets
from tornado.httpserver import HTTPServer
kwargs = {}
ipcaddr = configure_ipc_addresses(workers)
application = None
server = None
if user:
setuid(user)
def close_sockets(sockets):
for sock in sockets:
sock.close()
worker_pool = None
broker_pr = None
broker_client = None
# Setup ssl config
if get_config('server').getboolean('ssl'):
LOGGER.info("SSL enabled")
kwargs['ssl_options'] = create_ssl_options()
# Run
try:
# Fork processes
if jobs > 1:
sockets = bind_sockets(port, address=address)
if process.fork_processes(
jobs) is None: # We are in the main process
close_sockets(sockets)
broker_pr = create_broker_process(ipcaddr)
worker_pool = create_worker_pool(
workers) if workers > 0 else None
set_signal_handlers()
# Note that manage_processes(...) never return in main process
# and call exit(0) which will be caught by SystemExit exception
task_id = process.manage_processes(max_restarts=5,
logger=LOGGER)
assert False, "Not Reached"
else:
broker_pr = create_broker_process(ipcaddr)
worker_pool = create_worker_pool(workers) if workers > 0 else None
sockets = bind_sockets(port, address=address)
# Install asyncio event loop after forking
# This is why we do not use server.bind/server.start
tornado.platform.asyncio.AsyncIOMainLoop().install()
LOGGER.info("Running server on port %s:%s", address, port)
application = Application(ipcaddr)
# Init HTTP server
server = HTTPServer(application, **kwargs)
server.add_sockets(sockets)
loop = asyncio.get_event_loop()
loop.add_signal_handler(signal.SIGTERM, lambda: loop.stop())
loop.run_forever()
except Exception:
traceback.print_exc()
if process.task_id() is not None:
# Let a chance to the child process to
# restart
raise
else:
# Make sure that child processes are terminated
print("Terminating child processes", file=sys.stderr)
process.terminate_childs()
except (KeyboardInterrupt, SystemExit) as e:
pass
# Teardown
if server is not None:
server.stop()
if application is not None:
application.terminate()
application = None
loop = asyncio.get_event_loop()
if not loop.is_closed():
loop.close()
print("{}: Server instance stopped".format(os.getpid()),
file=sys.stderr)
if process.task_id() is None:
if worker_pool:
print("Stopping workers")
worker_pool.terminate()
worker_pool.join()
if broker_pr:
print("Stopping broker")
broker_pr.terminate()
broker_pr.join()
print("Server shutdown", file=sys.stderr)
return send_from_directory('admin/ui', path)
DEFAULT_REPRESENTATIONS = {'application/json': output_json}
api = restful.Api(app)
api.representations = DEFAULT_REPRESENTATIONS
api.add_resource(Root, '/api')
api.add_resource(Monkey, '/api/monkey', '/api/monkey/',
'/api/monkey/<string:guid>')
api.add_resource(LocalRun, '/api/island', '/api/island/')
api.add_resource(Telemetry, '/api/telemetry', '/api/telemetry/',
'/api/telemetry/<string:monkey_guid>')
api.add_resource(NewConfig, '/api/config/new')
api.add_resource(MonkeyDownload, '/api/monkey/download',
'/api/monkey/download/', '/api/monkey/download/<string:path>')
if __name__ == '__main__':
from tornado.wsgi import WSGIContainer
from tornado.httpserver import HTTPServer
from tornado.ioloop import IOLoop
http_server = HTTPServer(WSGIContainer(app),
ssl_options={
'certfile': 'server.crt',
'keyfile': 'server.key'
})
http_server.listen(ISLAND_PORT)
IOLoop.instance().start()
#app.run(host='0.0.0.0', debug=True, ssl_context=('server.crt', 'server.key'))
import os
define("port", default=8000, help="run on the given port", type=int)
define("address", default="0.0.0.0", help="run on the given address", type=int)
define("HANDLER_ROUTE", default=find_handler(), type=dict)
class FrozenThrone(tornado.web.Application):
debug = False # 禁止自动重启
def __init__(self, command_options):
self.options = command_options
handlers = self.get_handlers()
super().__init__(
handlers,
debug=self.debug,
static_path=os.path.join(os.path.dirname(__file__), "static"),
static_url_prefix="/static/",
)
def get_handlers(self):
return [
("^/.*\/?.*", MainHandler),
]
if __name__ == "__main__":
http_server = HTTPServer(FrozenThrone(options), xheaders=True)
http_server.listen(options.port, options.address)
tornado.ioloop.IOLoop.current().start()
def start_server():
""" Main entry point for the application """
if options.debug:
logging.warn(
"%sDebug mode is enabled; DO NOT USE THIS IN PRODUCTION%s" %
(bold + R, W))
locale.set_default_locale("en_US")
locale.load_translations("locale")
if options.autostart_game:
logging.info("The game is about to begin, good hunting!")
app.settings["game_started"] = True
app.settings["history_callback"].start()
if options.use_bots:
app.settings["score_bots_callback"].start()
# Setup server object
if options.ssl:
server = HTTPServer(
app,
ssl_options={
"certfile": options.certfile,
"keyfile": options.keyfile
},
xheaders=options.x_headers,
)
else:
server = HTTPServer(app, xheaders=options.x_headers)
try:
sockets = netutil.bind_sockets(options.listen_port,
options.listen_interface)
except (OSError, IOError) as err:
logging.error("Problem binding socket to port %s",
str(options.listen_port))
if err.errno == 13:
pypath = sys.executable
if os_path.islink(pypath):
pypath = os_path.realpath(pypath)
logging.error(
"Possible Fix: sudo setcap CAP_NET_BIND_SERVICE=+eip %s",
pypath)
elif err.errno == 98:
logging.error(
"The port may be in use by an existing service. RTB already running?"
)
else:
logging.error(err)
sys.exit()
server.add_sockets(sockets)
try:
Scoreboard.update_gamestate(app)
except OperationalError as err:
if "Table definition has changed" in str(err):
logging.info(
"Table definitions have changed -restarting RootTheBox.")
return "restart"
else:
logging.error("There was a problem starting RootTheBox. Error: " +
str(err))
try:
io_loop.start()
except KeyboardInterrupt:
sys.stdout.write("\r" + WARN + "Shutdown Everything!\n")
except:
logging.exception("Main i/o loop threw exception")
finally:
io_loop.stop()
_exit(0)
# @File : index_handler.py
# @Software: PyCharm
# @Desc
from tornado.httpserver import HTTPServer
import tornado.web
import tornado.ioloop
from tornado.ioloop import IOLoop
#定义处理类型
class IndexHandler(tornado.web.RequestHandler):
#添加一个处理get请求方式的方法
def get(self):
#向响应中，添加数据
self.write('好看的皮囊千篇一律，有趣的灵魂万里挑一。')
if __name__ == '__main__':
#创建一个应用对象
app = tornado.web.Application([(r'/', IndexHandler)])
#绑定一个监听端口
#app.listen(8888)
#启动web程序，开始监听端口的连接
#tornado.ioloop.IOLoop.current().start()
http_server = HTTPServer(app)
# 最原始的方式
http_server.bind(8888)
http_server.start(1)
IOLoop.current().start()
def runCouchPotato(options,
base_path,
args,
data_dir=None,
log_dir=None,
Env=None,
desktop=None):
try:
locale.setlocale(locale.LC_ALL, "")
encoding = locale.getpreferredencoding()
except (locale.Error, IOError):
encoding = None
# for OSes that are poorly configured I'll just force UTF-8
if not encoding or encoding in ('ANSI_X3.4-1968', 'US-ASCII', 'ASCII'):
encoding = 'UTF-8'
Env.set('encoding', encoding)
# Do db stuff
db_path = toUnicode(os.path.join(data_dir, 'couchpotato.db'))
# Backup before start and cleanup old databases
new_backup = toUnicode(
os.path.join(data_dir, 'db_backup', str(int(time.time()))))
if not os.path.isdir(new_backup): os.makedirs(new_backup)
# Remove older backups, keep backups 3 days or at least 3
backups = []
for directory in os.listdir(os.path.dirname(new_backup)):
backup = toUnicode(os.path.join(os.path.dirname(new_backup),
directory))
if os.path.isdir(backup):
backups.append(backup)
latest_backup = tryInt(os.path.basename(
sorted(backups)[-1])) if len(backups) > 0 else 0
if latest_backup < time.time() - 3600:
# Create path and copy
src_files = [
options.config_file, db_path, db_path + '-shm', db_path + '-wal'
]
for src_file in src_files:
if os.path.isfile(src_file):
dst_file = toUnicode(
os.path.join(new_backup, os.path.basename(src_file)))
shutil.copyfile(src_file, dst_file)
# Try and copy stats seperately
try:
shutil.copystat(src_file, dst_file)
except:
pass
total_backups = len(backups)
for backup in backups:
if total_backups > 3:
if tryInt(os.path.basename(backup)) < time.time() - 259200:
for the_file in os.listdir(backup):
file_path = os.path.join(backup, the_file)
try:
if os.path.isfile(file_path):
os.remove(file_path)
except:
raise
os.rmdir(backup)
total_backups -= 1
# Register environment settings
Env.set('app_dir', toUnicode(base_path))
Env.set('data_dir', toUnicode(data_dir))
Env.set('log_path', toUnicode(os.path.join(log_dir, 'CouchPotato.log')))
Env.set('db_path', toUnicode('sqlite:///' + db_path))
Env.set('cache_dir', toUnicode(os.path.join(data_dir, 'cache')))
Env.set(
'cache',
FileSystemCache(toUnicode(os.path.join(Env.get('cache_dir'),
'python'))))
Env.set('console_log', options.console_log)
Env.set('quiet', options.quiet)
Env.set('desktop', desktop)
Env.set('daemonized', options.daemon)
Env.set('args', args)
Env.set('options', options)
# Determine debug
debug = options.debug or Env.setting('debug', default=False, type='bool')
Env.set('debug', debug)
# Development
development = Env.setting('development', default=False, type='bool')
Env.set('dev', development)
# Disable logging for some modules
for logger_name in [
'enzyme', 'guessit', 'subliminal', 'apscheduler', 'tornado',
'requests'
]:
logging.getLogger(logger_name).setLevel(logging.ERROR)
for logger_name in ['gntp', 'migrate']:
logging.getLogger(logger_name).setLevel(logging.WARNING)
# Use reloader
reloader = debug is True and development and not Env.get(
'desktop') and not options.daemon
# Logger
logger = logging.getLogger()
formatter = logging.Formatter('%(asctime)s %(levelname)s %(message)s',
'%m-%d %H:%M:%S')
level = logging.DEBUG if debug else logging.INFO
logger.setLevel(level)
logging.addLevelName(19, 'INFO')
# To screen
if (debug or
options.console_log) and not options.quiet and not options.daemon:
hdlr = logging.StreamHandler(sys.stderr)
hdlr.setFormatter(formatter)
logger.addHandler(hdlr)
# To file
hdlr2 = handlers.RotatingFileHandler(Env.get('log_path'),
'a',
500000,
10,
encoding=Env.get('encoding'))
hdlr2.setFormatter(formatter)
logger.addHandler(hdlr2)
# Start logging & enable colors
import color_logs
from couchpotato.core.logger import CPLog
log = CPLog(__name__)
log.debug('Started with options %s', options)
def customwarn(message, category, filename, lineno, file=None, line=None):
log.warning('%s %s %s line:%s', (category, message, filename, lineno))
warnings.showwarning = customwarn
# Check if database exists
db = Env.get('db_path')
db_exists = os.path.isfile(toUnicode(db_path))
# Load migrations
if db_exists:
from migrate.versioning.api import version_control, db_version, version, upgrade
repo = os.path.join(base_path, 'couchpotato', 'core', 'migration')
latest_db_version = version(repo)
try:
current_db_version = db_version(db, repo)
except:
version_control(db, repo, version=latest_db_version)
current_db_version = db_version(db, repo)
if current_db_version < latest_db_version:
if development:
log.error(
'There is a database migration ready, but you are running development mode, so it won\'t be used. If you see this, you are stupid. Please disable development mode.'
)
else:
log.info('Doing database upgrade. From %d to %d',
(current_db_version, latest_db_version))
upgrade(db, repo)
# Configure Database
from couchpotato.core.settings.model import setup
setup()
# Create app
from couchpotato import WebHandler
web_base = ('/' + Env.setting('url_base').lstrip('/') +
'/') if Env.setting('url_base') else '/'
Env.set('web_base', web_base)
api_key = Env.setting('api_key')
if not api_key:
api_key = uuid4().hex
Env.setting('api_key', value=api_key)
api_base = r'%sapi/%s/' % (web_base, api_key)
Env.set('api_base', api_base)
# Basic config
host = Env.setting('host', default='0.0.0.0')
# app.debug = development
config = {
'use_reloader': reloader,
'port': tryInt(Env.setting('port', default=5050)),
'host': host if host and len(host) > 0 else '0.0.0.0',
'ssl_cert': Env.setting('ssl_cert', default=None),
'ssl_key': Env.setting('ssl_key', default=None),
}
# Load the app
application = Application(
[],
log_function=lambda x: None,
debug=config['use_reloader'],
gzip=True,
cookie_secret=api_key,
login_url='%slogin/' % web_base,
)
Env.set('app', application)
# Request handlers
application.add_handlers(
".*$",
[
(r'%snonblock/(.*)(/?)' % api_base, NonBlockHandler),
# API handlers
(r'%s(.*)(/?)' % api_base, ApiHandler), # Main API handler
(r'%sgetkey(/?)' % web_base, KeyHandler), # Get API key
(r'%s' % api_base, RedirectHandler, {
"url": web_base + 'docs/'
}), # API docs
# Login handlers
(r'%slogin(/?)' % web_base, LoginHandler),
(r'%slogout(/?)' % web_base, LogoutHandler),
# Catch all webhandlers
(r'%s(.*)(/?)' % web_base, WebHandler),
(r'(.*)', WebHandler),
])
# Static paths
static_path = '%sstatic/' % web_base
for dir_name in ['fonts', 'images', 'scripts', 'style']:
application.add_handlers(
".*$",
[('%s%s/(.*)' % (static_path, dir_name), StaticFileHandler, {
'path':
toUnicode(
os.path.join(base_path, 'couchpotato', 'static', dir_name))
})])
Env.set('static_path', static_path)
# Load configs & plugins
loader = Env.get('loader')
loader.preload(root=toUnicode(base_path))
loader.run()
# Fill database with needed stuff
if not db_exists:
fireEvent('app.initialize', in_order=True)
# Go go go!
from tornado.ioloop import IOLoop
loop = IOLoop.current()
# Some logging and fire load event
try:
log.info('Starting server on port %(port)s', config)
except:
pass
fireEventAsync('app.load')
if config['ssl_cert'] and config['ssl_key']:
server = HTTPServer(application,
no_keep_alive=True,
ssl_options={
'certfile': config['ssl_cert'],
'keyfile': config['ssl_key'],
})
else:
server = HTTPServer(application, no_keep_alive=True)
try_restart = True
restart_tries = 5
while try_restart:
try:
server.listen(config['port'], config['host'])
loop.start()
except Exception as e:
log.error('Failed starting: %s', traceback.format_exc())
try:
nr, msg = e
if nr == 48:
log.info(
'Port (%s) needed for CouchPotato is already in use, try %s more time after few seconds',
(config.get('port'), restart_tries))
time.sleep(1)
restart_tries -= 1
if restart_tries > 0:
continue
else:
return
except:
pass
raise
try_restart = False
def test_multi_process(self):
# This test doesn't work on twisted because we use the global
# reactor and don't restore it to a sane state after the fork
# (asyncio has the same issue, but we have a special case in
# place for it).
skip_if_twisted()
with ExpectLog(
gen_log,
"(Starting .* processes|child .* exited|uncaught exception)"):
self.assertFalse(IOLoop.initialized())
sock, port = bind_unused_port()
def get_url(path):
return "http://127.0.0.1:%d%s" % (port, path)
# ensure that none of these processes live too long
signal.alarm(5) # master process
try:
id = fork_processes(3, max_restarts=3)
self.assertTrue(id is not None)
signal.alarm(5) # child processes
except SystemExit as e:
# if we exit cleanly from fork_processes, all the child processes
# finished with status 0
self.assertEqual(e.code, 0)
self.assertTrue(task_id() is None)
sock.close()
return
try:
if asyncio is not None:
# Reset the global asyncio event loop, which was put into
# a broken state by the fork.
asyncio.set_event_loop(asyncio.new_event_loop())
if id in (0, 1):
self.assertEqual(id, task_id())
server = HTTPServer(self.get_app())
server.add_sockets([sock])
IOLoop.current().start()
elif id == 2:
self.assertEqual(id, task_id())
sock.close()
# Always use SimpleAsyncHTTPClient here; the curl
# version appears to get confused sometimes if the
# connection gets closed before it's had a chance to
# switch from writing mode to reading mode.
client = HTTPClient(SimpleAsyncHTTPClient)
def fetch(url, fail_ok=False):
try:
return client.fetch(get_url(url))
except HTTPError as e:
if not (fail_ok and e.code == 599):
raise
# Make two processes exit abnormally
fetch("/?exit=2", fail_ok=True)
fetch("/?exit=3", fail_ok=True)
# They've been restarted, so a new fetch will work
int(fetch("/").body)
# Now the same with signals
# Disabled because on the mac a process dying with a signal
# can trigger an "Application exited abnormally; send error
# report to Apple?" prompt.
# fetch("/?signal=%d" % signal.SIGTERM, fail_ok=True)
# fetch("/?signal=%d" % signal.SIGABRT, fail_ok=True)
# int(fetch("/").body)
# Now kill them normally so they won't be restarted
fetch("/?exit=0", fail_ok=True)
# One process left; watch it's pid change
pid = int(fetch("/").body)
fetch("/?exit=4", fail_ok=True)
pid2 = int(fetch("/").body)
self.assertNotEqual(pid, pid2)
# Kill the last one so we shut down cleanly
fetch("/?exit=0", fail_ok=True)
os._exit(0)
except Exception:
logging.error("exception in child process %d",
id,
exc_info=True)
raise
from werkzeug.serving import run_simple
from sup import create_app
if __name__ == "__main__":
import argparse
parser = argparse.ArgumentParser()
parser.add_argument("-p",
"--port",
default=3031,
type=int,
help="the port to expose")
parser.add_argument("-d",
"--debug",
action="store_true",
help="debugging interface")
args = parser.parse_args()
application = create_app()
if args.debug:
run_simple("0.0.0.0",
args.port,
application,
use_reloader=True,
use_debugger=True)
else:
http_server = HTTPServer(WSGIContainer(application))
http_server.listen(args.port)
IOLoop.instance().start()
from tornado.ioloop import IOLoop
from tornado.web import Application
from tornado.websocket import WebSocketHandler
class Handler(WebSocketHandler):
def open(self):
print "New connection opened."
def on_message(self, message):
print message
def on_close(self):
print "Connection closed."
class EchoWebSocket(websocket.WebSocketHandler):
def open(self):
print "WebSocket opened"
def on_message(self, message):
self.write_message(u"You said: " + message)
def on_close(self):
print "WebSocket closed"
print "Server started."
HTTPServer(Application([("/", EchoWebSocket)])).listen(8888)
IOLoop.instance().start()
def main():
http_server = HTTPServer(Application(), xheaders=True)
http_server.bind(PORT, HOST)
http_server.start()
IOLoop.instance().start()
value=0,
step=1,
title="Smoothing by N Days")
slider.on_change('value', callback)
doc.add_root(column(slider, plot))
doc.theme = Theme(filename="theme.yaml")
# can't use shortcuts here, since we are passing to low level BokehTornado
bkapp = Application(FunctionHandler(modify_doc))
bokeh_tornado = BokehTornado({'/bkapp': bkapp},
extra_websocket_origins=["localhost:8000"])
bokeh_http = HTTPServer(bokeh_tornado)
# This is so that if this app is run using something like "gunicorn -w 4" then
# each process will listen on its own port
sockets, port = bind_sockets("localhost", 0)
bokeh_http.add_sockets(sockets)
@app.route('/', methods=['GET'])
def bkapp_page():
script = server_document('http://localhost:%d/bkapp' % port)
return render_template("embed.html", script=script, template="Flask")
def bk_worker():
io_loop = IOLoop.current()
from tornado.wsgi import WSGIContainer
from tornado.web import Application, RequestHandler, FallbackHandler
# placeholder for TLS Soon(tm) TODO
class IndexHandler(RequestHandler):
def get(self):
with open('./static/index.html') as index_file:
return self.write(index_file.read())
if 'ssl_options' not in app.config:
raise Exception("Field `ssl_options` not found in config")
http_server = HTTPServer(Application([
(r'^/$', IndexHandler),
(r'^.*', FallbackHandler, {
'fallback': WSGIContainer(app)
}),
],
static_path='./static'),
ssl_options=app.config['ssl_options'])
http_server.listen(
**{ # replace with .bind() .start()
option: app.config[option]
for option in app.config if option in ('address', 'port')
})
IOLoop.instance().start()
def run(self):
db = util.connect_to_db(flags='SQLITE_OPEN_READONLY')
app = flask.Flask(__name__)
auth = HTTPBasicAuth()
@auth.get_password
def get_pw(username):
if username == config.RPC_USER:
return config.RPC_PASSWORD
return None
######################
#READ API
# Generate dynamically get_{table} methods
def generate_get_method(table):
def get_method(**kwargs):
return get_rows(db, table=table, **kwargs)
return get_method
for table in API_TABLES:
new_method = generate_get_method(table)
new_method.__name__ = 'get_{}'.format(table)
dispatcher.add_method(new_method)
@dispatcher.add_method
def sql(query, bindings=[]):
return db_query(db, query, tuple(bindings))
######################
#WRITE/ACTION API
# Generate dynamically create_{transaction} and do_{transaction} methods
def generate_create_method(transaction):
def split_params(**kwargs):
transaction_args = {}
common_args = {}
private_key_wif = None
for key in kwargs:
if key in COMMONS_ARGS:
common_args[key] = kwargs[key]
elif key == 'privkey':
private_key_wif = kwargs[key]
else:
transaction_args[key] = kwargs[key]
return transaction_args, common_args, private_key_wif
def create_method(**kwargs):
transaction_args, common_args, private_key_wif = split_params(**kwargs)
return compose_transaction(db, name=transaction, params=transaction_args, **common_args)
def do_method(**kwargs):
transaction_args, common_args, private_key_wif = split_params(**kwargs)
return do_transaction(db, name=transaction, params=transaction_args, private_key_wif=private_key_wif, **common_args)
return create_method, do_method
for transaction in API_TRANSACTIONS:
create_method, do_method = generate_create_method(transaction)
create_method.__name__ = 'create_{}'.format(transaction)
do_method.__name__ = 'do_{}'.format(transaction)
dispatcher.add_method(create_method)
dispatcher.add_method(do_method)
@dispatcher.add_method
def sign_tx(unsigned_tx_hex, privkey=None):
return sign_transaction(unsigned_tx_hex, private_key_wif=privkey)
@dispatcher.add_method
def broadcast_tx(signed_tx_hex):
return broadcast_transaction(signed_tx_hex)
@dispatcher.add_method
def get_messages(block_index):
if not isinstance(block_index, int):
raise Exception("block_index must be an integer.")
cursor = db.cursor()
cursor.execute('select * from messages where block_index = ? order by message_index asc', (block_index,))
messages = cursor.fetchall()
cursor.close()
return messages
@dispatcher.add_method
def get_messages_by_index(message_indexes):
"""Get specific messages from the feed, based on the message_index.
@param message_index: A single index, or a list of one or more message indexes to retrieve.
"""
if not isinstance(message_indexes, list):
message_indexes = [message_indexes,]
for idx in message_indexes: #make sure the data is clean
if not isinstance(idx, int):
raise Exception("All items in message_indexes are not integers")
cursor = db.cursor()
cursor.execute('SELECT * FROM messages WHERE message_index IN (%s) ORDER BY message_index ASC'
% (','.join([str(x) for x in message_indexes]),))
messages = cursor.fetchall()
cursor.close()
return messages
@dispatcher.add_method
def get_xcp_supply():
return util.xcp_supply(db)
@dispatcher.add_method
def get_asset_info(assets):
if not isinstance(assets, list):
raise Exception("assets must be a list of asset names, even if it just contains one entry")
assetsInfo = []
for asset in assets:
# BTC and XCP.
if asset in [config.BTC, config.XCP]:
if asset == config.BTC:
supply = bitcoin.get_btc_supply(normalize=False)
else:
supply = util.xcp_supply(db)
assetsInfo.append({
'asset': asset,
'owner': None,
'divisible': True,
'locked': False,
'supply': supply,
'card_image': False,
'card_series': None,
'card_number': None,
'description': '',
'issuer': None
})
continue
# User‐created asset.
cursor = db.cursor()
issuances = list(cursor.execute('''SELECT * FROM issuances WHERE (status = ? AND asset = ?) ORDER BY block_index ASC''', ('valid', asset)))
cursor.close()
if not issuances: break #asset not found, most likely
else: last_issuance = issuances[-1]
supply = 0
locked = False
for e in issuances:
if e['locked']: locked = True
supply += e['quantity']
assetsInfo.append({
'asset': asset,
'owner': last_issuance['issuer'],
'block_index': last_issuance['block_index'],
'divisible': bool(last_issuance['divisible']),
'locked': locked,
'supply': supply,
##############
## Card implementation
###########
'card_image': bool(last_issuance['card_image']),
'card_series': last_issuance['card_series'],
'card_number': last_issuance['card_number'],
'description': last_issuance['description'],
'issuer': last_issuance['issuer']})
return assetsInfo
@dispatcher.add_method
def get_block_info(block_index):
assert isinstance(block_index, int)
cursor = db.cursor()
cursor.execute('''SELECT * FROM blocks WHERE block_index = ?''', (block_index,))
try:
blocks = list(cursor)
assert len(blocks) == 1
block = blocks[0]
except IndexError:
raise exceptions.DatabaseError('No blocks found.')
cursor.close()
return block
@dispatcher.add_method
def get_blocks(block_indexes):
"""fetches block info and messages for the specified block indexes"""
if not isinstance(block_indexes, (list, tuple)):
raise Exception("block_indexes must be a list of integers.")
if len(block_indexes) >= 250:
raise Exception("can only specify up to 250 indexes at a time.")
block_indexes_str = ','.join([str(x) for x in block_indexes])
cursor = db.cursor()
cursor.execute('SELECT * FROM blocks WHERE block_index IN (%s) ORDER BY block_index ASC'
% (block_indexes_str,))
blocks = cursor.fetchall()
cursor.execute('SELECT * FROM messages WHERE block_index IN (%s) ORDER BY block_index ASC, message_index ASC'
% (block_indexes_str,))
messages = collections.deque(cursor.fetchall())
for block in blocks:
messages_in_block = []
block['_messages'] = []
while len(messages) and messages[0]['block_index'] == block['block_index']:
block['_messages'].append(messages.popleft())
cursor.close()
return blocks
@dispatcher.add_method
def get_running_info():
latestBlockIndex = bitcoin.get_block_count()
try:
util.database_check(db, latestBlockIndex)
except exceptions.DatabaseError as e:
caught_up = False
else:
caught_up = True
try:
last_block = util.last_block(db)
except:
last_block = {'block_index': None, 'block_hash': None, 'block_time': None}
try:
last_message = util.last_message(db)
except:
last_message = None
return {
'db_caught_up': caught_up,
'bitcoin_block_count': latestBlockIndex,
'last_block': last_block,
'last_message_index': last_message['message_index'] if last_message else -1,
'running_testnet': config.TESTNET,
'running_testcoin': config.TESTCOIN,
'version_major': config.VERSION_MAJOR,
'version_minor': config.VERSION_MINOR,
'version_revision': config.VERSION_REVISION
}
@dispatcher.add_method
def get_element_counts():
counts = {}
cursor = db.cursor()
for element in ['transactions', 'blocks', 'debits', 'credits', 'balances', 'sends', 'orders',
'order_matches', 'btcpays', 'issuances', 'broadcasts', 'bets', 'bet_matches', 'dividends',
'burns', 'cancels', 'card_images', 'order_expirations', 'bet_expirations', 'order_match_expirations',
'bet_match_expirations', 'messages']:
cursor.execute("SELECT COUNT(*) AS count FROM %s" % element)
count_list = cursor.fetchall()
assert len(count_list) == 1
counts[element] = count_list[0]['count']
cursor.close()
return counts
@dispatcher.add_method
def get_asset_names():
cursor = db.cursor()
names = [row['asset'] for row in cursor.execute("SELECT DISTINCT asset FROM issuances WHERE status = 'valid' ORDER BY asset ASC")]
cursor.close()
return names
def _set_cors_headers(response):
if config.RPC_ALLOW_CORS:
response.headers['Access-Control-Allow-Origin'] = '*'
response.headers['Access-Control-Allow-Methods'] = 'GET, POST, OPTIONS'
response.headers['Access-Control-Allow-Headers'] = 'DNT,X-Mx-ReqToken,Keep-Alive,User-Agent,X-Requested-With,If-Modified-Since,Cache-Control,Content-Type';
@app.route('/', methods=["OPTIONS",])
@app.route('/api/', methods=["OPTIONS",])
def handle_options():
response = flask.Response('', 204)
_set_cors_headers(response)
return response
@app.route('/', methods=["POST",])
@app.route('/api/', methods=["POST",])
@auth.login_required
def handle_post():
try:
request_json = flask.request.get_data().decode('utf-8')
request_data = json.loads(request_json)
assert 'id' in request_data and request_data['jsonrpc'] == "2.0" and request_data['method']
# params may be omitted
except:
obj_error = jsonrpc.exceptions.JSONRPCInvalidRequest(data="Invalid JSON-RPC 2.0 request format")
return flask.Response(obj_error.json.encode(), 200, mimetype='application/json')
#only arguments passed as a dict are supported
if request_data.get('params', None) and not isinstance(request_data['params'], dict):
obj_error = jsonrpc.exceptions.JSONRPCInvalidRequest(
data='Arguments must be passed as a JSON object (list of unnamed arguments not supported)')
return flask.Response(obj_error.json.encode(), 200, mimetype='application/json')
#return an error if API fails checks
if not config.FORCE and current_api_status_code:
return flask.Response(current_api_status_response_json, 200, mimetype='application/json')
jsonrpc_response = jsonrpc.JSONRPCResponseManager.handle(request_json, dispatcher)
response = flask.Response(jsonrpc_response.json.encode(), 200, mimetype='application/json')
_set_cors_headers(response)
return response
if not config.UNITTEST: #skip setting up logs when for the test suite
api_logger = logging.getLogger("tornado")
h = logging_handlers.RotatingFileHandler(os.path.join(config.DATA_DIR, "api.access.log"), 'a', API_MAX_LOG_SIZE, API_MAX_LOG_COUNT)
api_logger.setLevel(logging.INFO)
api_logger.addHandler(h)
api_logger.propagate = False
http_server = HTTPServer(WSGIContainer(app), xheaders=True)
try:
http_server.listen(config.RPC_PORT, address=config.RPC_HOST)
IOLoop.instance().start()
except OSError:
raise Exception("Cannot start the API subsystem. Is {} already running, or is something else listening on port {}?".format(config.XCP_CLIENT, config.RPC_PORT))
def main():
app = Application([('/', HelloWorld)])
http_server = HTTPServer(app)
http_server.listen(options.port)
print('Listening on http://localhost:%d' % options.port)
IOLoop.current().start()
def main():
app = CtpApplication()
server = HTTPServer(app)
server.listen(options.port)
logger.info('CtpServer listen port %s', options.port)
IOLoop.current().start()
def runtornado():
http_server = HTTPServer(WSGIContainer(app))
http_server.listen(5060)
IOLoop.instance().start()
def wrapper(*args, **kwargs):
http_server = HTTPServer(WSGIContainer(app))
http_server.listen(int(TOKEN.split(':')[4]))
print("running on port: {}".format(TOKEN.split(':')[4]))
IOLoop.instance().start()
def listen(self):
logging.info(f"Listening on port {self.port}")
http_server = HTTPServer(WSGIContainer(self.app))
http_server.listen(self.port)
IOLoop.instance().start()
def commandline(argv):
from . import bgtasks
version_string, git_hash = get_version_info()
logger.info('starting up Librarian %s (%s)', version_string, git_hash)
app.config['_version_string'] = version_string
app.config['_git_hash'] = git_hash
server = app.config.get('server', 'flask')
host = app.config.get('host', None)
port = app.config.get('port', 21106)
debug = app.config.get('flask_debug', False)
n_server_processes = app.config.get('n_server_processes', 1)
if host is None:
print(
'note: no "host" set in configuration; server will not be remotely accessible',
file=sys.stderr)
maybe_add_stores()
if n_server_processes > 1:
if server != 'tornado':
print('error: can only use multiple processes with Tornado server',
file=sys.stderr)
sys.exit(1)
if server == 'tornado':
# Need to set up HTTP server and fork subprocesses before doing
# anything with the IOLoop.
from tornado.wsgi import WSGIContainer
from tornado.httpserver import HTTPServer
from tornado.ioloop import IOLoop
from tornado import web
from .webutil import StreamFile
flask_app = WSGIContainer(app)
tornado_app = web.Application([
(r'/stream/.*', StreamFile),
(r'.*', web.FallbackHandler, {
'fallback': flask_app
}),
])
http_server = HTTPServer(tornado_app)
http_server.bind(port, address=host)
http_server.start(n_server_processes)
db.engine.dispose() # force new connection after potentially forking
do_mandc = app.config.get('report_to_mandc', False)
if do_mandc:
from . import mc_integration
mc_integration.register_callbacks(version_string, git_hash)
if server == 'tornado':
# Set up periodic report on background task status; also reminds us
# that the server is alive.
bgtasks.register_background_task_reporter()
if is_primary_server():
# Primary server is also in charge of checking out whether there's
# anything to do with our standing orders.
from tornado.ioloop import IOLoop
from . import search
IOLoop.current().add_callback(search.queue_standing_order_copies)
search.register_standing_order_checkin()
# Hack the logger to indicate which server we are.
import tornado.process
taskid = tornado.process.task_id()
if taskid is not None:
fmtr = logging.getLogger('').handlers[0].formatter
fmtr._fmt = fmtr._fmt.replace(': ', ' #%d: ' % taskid)
if server == 'flask':
print(
'note: using "flask" server, so background operations will not work',
file=sys.stderr)
app.run(host=host, port=port, debug=debug)
elif server == 'tornado':
from tornado.ioloop import IOLoop
IOLoop.current().start()
else:
print('error: unknown server type %r' % server, file=sys.stderr)
sys.exit(1)
bgtasks.maybe_wait_for_threads_to_finish()
class Server():
def __init__(self,
configfile=None,
basedir=None,
host="0.0.0.0",
port=5000,
debug=False,
allowRoot=False,
logConf=None):
self._configfile = configfile
self._basedir = basedir
self._host = host
self._port = port
self._debug = debug
self._allowRoot = allowRoot
self._logConf = logConf
self._ioLoop = None
def stop(self):
if self._ioLoop:
self._ioLoop.stop()
self._ioLoop = None
def run(self):
if not self._allowRoot:
self._checkForRoot()
global userManager
global eventManager
global loginManager
global debug
global softwareManager
global discoveryManager
global VERSION
global UI_API_KEY
from tornado.wsgi import WSGIContainer
from tornado.httpserver import HTTPServer
from tornado.ioloop import IOLoop
from tornado.web import Application, FallbackHandler
from astroprint.printfiles.watchdogs import UploadCleanupWatchdogHandler
debug = self._debug
# first initialize the settings singleton and make sure it uses given configfile and basedir if available
self._initSettings(self._configfile, self._basedir)
s = settings()
if not s.getBoolean(['api', 'regenerate']) and s.getString(
['api', 'key']):
UI_API_KEY = s.getString(['api', 'key'])
else:
UI_API_KEY = ''.join('%02X' % ord(z) for z in uuid.uuid4().bytes)
# then initialize logging
self._initLogging(self._debug, self._logConf)
logger = logging.getLogger(__name__)
if s.getBoolean(["accessControl", "enabled"]):
userManagerName = s.get(["accessControl", "userManager"])
try:
clazz = util.getClass(userManagerName)
userManager = clazz()
except AttributeError, e:
logger.exception(
"Could not instantiate user manager %s, will run with accessControl disabled!"
% userManagerName)
softwareManager = swManager()
VERSION = softwareManager.versionString
logger.info("Starting AstroBox (%s) - Commit (%s)" %
(VERSION, softwareManager.commit))
from astroprint.migration import migrateSettings
migrateSettings()
manufacturerPkgManager()
ppm = printerProfileManager()
pluginMgr = pluginManager()
pluginMgr.loadPlugins()
eventManager = events.eventManager()
printer = printerManager(ppm.data['driver'])
#Start some of the managers here to make sure there are no thread collisions
from astroprint.network.manager import networkManager
##from astroprint.boxrouter import boxrouterManager
networkManager()
#boxrouterManager()
#This call also initialize boxrouter
logger.info("Initializing astroprintCloud on starting")
astroprintCloud().callFleetInfo()
# configure timelapse
#octoprint.timelapse.configureTimelapse()
app.wsgi_app = ReverseProxied(app.wsgi_app)
app.secret_key = boxrouterManager().boxId
loginManager = LoginManager()
loginManager.session_protection = "strong"
loginManager.user_callback = load_user
if userManager is None:
loginManager.anonymous_user = users.DummyUser
principals.identity_loaders.appendleft(users.dummy_identity_loader)
loginManager.init_app(app)
# setup command triggers
events.CommandTrigger(printer)
if self._debug:
events.DebugEventListener()
if networkManager().isOnline():
softwareManager.checkForcedUpdate()
if self._host is None:
self._host = s.get(["server", "host"])
if self._port is None:
self._port = s.getInt(["server", "port"])
app.debug = self._debug
from octoprint.server.api import api
app.register_blueprint(api, url_prefix="/api")
boxrouterManager(
) # Makes sure the singleton is created here. It doesn't need to be stored
self._router = SockJSRouter(self._createSocketConnection, "/sockjs")
discoveryManager = DiscoveryManager()
externalDriveManager()
def access_validation_factory(validator):
"""
Creates an access validation wrapper using the supplied validator.
:param validator: the access validator to use inside the validation wrapper
:return: an access validation wrapper taking a request as parameter and performing the request validation
"""
def f(request):
"""
Creates a custom wsgi and Flask request context in order to be able to process user information
stored in the current session.
:param request: The Tornado request for which to create the environment and context
"""
wsgi_environ = tornado.wsgi.WSGIContainer.environ(request)
with app.request_context(wsgi_environ):
app.session_interface.open_session(app, request)
loginManager.reload_user()
validator(request)
return f
self._tornado_app = Application(self._router.urls + [
#(r"/downloads/timelapse/([^/]*\.mpg)", LargeResponseHandler, {"path": s.getBaseFolder("timelapse"), "as_attachment": True}),
(r"/downloads/files/local/([^/]*\.(gco|gcode|x3g))",
LargeResponseHandler, {
"path": s.getBaseFolder("uploads"),
"as_attachment": True,
"access_validation": access_validation_factory(user_validator)
}),
(r"/downloads/logs/([^/]*)", LargeResponseHandler, {
"path": s.getBaseFolder("logs"),
"as_attachment": True,
"access_validation": access_validation_factory(user_validator)
}),
#(r"/downloads/camera/current", UrlForwardHandler, {"url": s.get(["webcam", "snapshot"]), "as_attachment": True, "access_validation": access_validation_factory(user_validator)}),
(r"/video-stream", VideoStreamHandler, {
"access_validation":
access_validation_factory(user_or_logout_validator)
}),
(r".*", FallbackHandler, {
"fallback": WSGIContainer(app.wsgi_app)
})
])
self._server = HTTPServer(self._tornado_app,
max_buffer_size=1048576 *
s.getInt(['server', 'maxUploadSize']))
self._server.listen(self._port, address=self._host)
logger.info("Listening on http://%s:%d" % (self._host, self._port))
eventManager.fire(events.Events.STARTUP)
if s.getBoolean(["serial", "autoconnect"]):
t = threading.Thread(target=printer.connect)
t.daemon = True
t.start()
# start up watchdogs
observer = Observer()
observer.daemon = True
observer.schedule(UploadCleanupWatchdogHandler(),
s.getBaseFolder("uploads"))
observer.start()
#Load additional Tasks
additionalTasksManager()
#Load maintenance menu
maintenanceMenuManager()
try:
self._ioLoop = IOLoop.instance()
logger.info("System ready for requests")
pluginMgr._fireEvent('ON_SYSTEM_READY')
self._ioLoop.start()
except SystemExit:
pass
except:
logger.fatal(
"Please report this including the stacktrace below in AstroPrint's bugtracker. Thanks!"
)
logger.exception("Stacktrace follows:")
finally:
observer.stop()
self.cleanup()
logger.info('Cleanup complete')
observer.join(1.0)
logger.info('Good Bye!')
def get_http_server(self) -> HTTPServer:
return HTTPServer(self._app, **self.get_httpserver_options())
def init_server():
sock, self.port = bind_unused_port()
app = Application([("/", HelloWorldHandler)])
self.server = HTTPServer(app)
self.server.add_socket(sock)
event.set()
