def __init__(self):
from opmuse.utils import get_staticdir
self.dir_from = os.path.join(os.path.dirname(__file__), "..", "javascript")
self.dir_to = os.path.join(get_staticdir(), "scripts")
def configure(config_file=None, environment=None):
cherrypy.tools.database = SqlAlchemyTool()
cherrypy.tools.authenticated = AuthenticatedTool()
cherrypy.tools.session_query_string = SessionQueryStringTool()
cherrypy.tools.jinja = Jinja()
cherrypy.tools.jinjaenv = JinjaEnvTool()
cherrypy.tools.jinjaauthenticated = JinjaAuthenticatedTool()
cherrypy.tools.library = LibraryTool()
cherrypy.tools.backgroundtask = BackgroundTaskTool()
cherrypy.tools.transcodingsubprocess = FFMPEGTranscoderSubprocessTool()
cherrypy.tools.multiheaders = multi_headers_tool
cherrypy.tools.error_handler = error_handler_tool
cherrypy.tools.websocket = WebSocketTool()
cherrypy.tools.database_events = DatabaseEventsTool()
from opmuse.controllers.main import Root
if config_file is None:
config_file = join(abspath(dirname(__file__)), '..', 'config', 'opmuse.ini')
if config_file is not False and not exists(config_file):
config_file = '/etc/opmuse/opmuse.ini'
if config_file and not exists(config_file):
print('Configuration is missing!')
sys.exit(1)
cache_path = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', 'cache'))
app_config = {
'/': {
'tools.error_handler.on': True,
'tools.autovary.on': True,
'tools.encode.on': False,
'tools.database.on': True,
'tools.jinjaauthenticated.on': True,
'tools.library.on': True,
'tools.backgroundtask.on': True,
'tools.jinjaenv.on': True,
'tools.authenticated.on': True,
'tools.database_events.on': True,
'tools.sessions.on': True,
# use sqlalchemy for dev env because it saves session when cherrypy
# restarts but it doesn't support locking so we use ram for production.
'tools.sessions.storage_type': 'ram' if environment == 'production' else 'sqlalchemy',
# there's an annoying bug with autovary and sessions where if you dont
# set session.path the sessions tool will try to access a None header
# (because path_header is None) which will cause autovary to try to
# sort header strs and a None value...
'tools.sessions.path': '/',
'tools.sessions.httponly': True,
'tools.sessions.persistent': False,
'tools.sessions.locking': 'explicit',
'tools.sessions.timeout': 60 * 8
}, '/ws': {
'tools.websocket.on': True,
'tools.websocket.handler_cls': WebSocketHandler
}, '/static': {
'tools.jinjaauthenticated.on': False,
'tools.sessions.on': False,
'tools.database.on': False,
'tools.staticdir.on': True,
'tools.staticdir.dir': get_staticdir(),
'tools.expires.on': False,
'tools.expires.secs': 3600 * 24 * 30
},
'/library/upload/add': {
'response.timeout': 3600
},
'/library/edit/submit': {
'response.timeout': 3600
},
}
if environment == "production":
app_config['/static']['tools.expires.on'] = True
app = cherrypy.tree.mount(Root(), '/', app_config)
if config_file:
app.merge(config_file)
if config_file is False:
config = cherrypy._cpconfig.Config()
else:
config = cherrypy._cpconfig.Config(file=config_file)
# 5 gigabyte file upload limit
config['server.max_request_body_size'] = 1024 ** 3 * 5
config['engine.timeout_monitor.frequency'] = 60 * 5
config['error_page.default'] = Root.handle_error
config['opmuse'] = {}
config['opmuse']['cache.path'] = cache_path
cherrypy.config.update(config)
cherrypy._cpconfig.environments['production']['opmuse'] = {}
cherrypy._cpconfig.environments['production']['opmuse']['jinja.auto_reload'] = False
cherrypy._cpconfig.environments['production']['opmuse']['less_reloader.enable'] = False
cherrypy._cpconfig.environments['production']['opmuse']['js_reloader.enable'] = False
cherrypy._cpconfig.environments['production']['opmuse']['cache.path'] = '/var/cache/opmuse'
# dont use the default server
cherrypy.server.unsubscribe()
cherrypy.server = None
cherrypy.ssl_server = None
# setup ssl/https server if enabled
if 'ssl_server.enabled' in cherrypy.config and cherrypy.config['ssl_server.enabled']:
ssl_socket_host = cherrypy.config.get('ssl_server.socket_host')
ssl_socket_port = cherrypy.config.get('ssl_server.socket_port')
ssl_certificate = cherrypy.config['ssl_server.ssl_certificate']
ssl_private_key = cherrypy.config['ssl_server.ssl_private_key']
if ssl_socket_host is None:
ssl_socket_host = '127.0.0.1'
if ssl_socket_port is None:
ssl_socket_port = 8443
if 'ssl_server.ssl_certificate_chain' in cherrypy.config:
ssl_certificate_chain = cherrypy.config['ssl_server.ssl_certificate_chain']
else:
ssl_certificate_chain = None
config_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), '..', 'config')
if not os.path.isabs(ssl_certificate):
ssl_certificate = os.path.join(config_path, ssl_certificate)
if not os.path.isabs(ssl_private_key):
ssl_private_key = os.path.join(config_path, ssl_private_key)
if ssl_certificate_chain is not None and not os.path.isabs(ssl_certificate_chain):
ssl_certificate_chain = os.path.join(config_path, ssl_certificate_chain)
ssl_server = cherrypy._cpserver.Server()
ssl_server.max_request_body_size = config['server.max_request_body_size']
ssl_server.bind_addr = (ssl_socket_host, ssl_socket_port)
ssl_server.ssl_certificate = ssl_certificate
ssl_server.ssl_private_key = ssl_private_key
ssl_server.ssl_certificate_chain = ssl_certificate_chain
ssl_server.subscribe()
cherrypy.ssl_server = ssl_server
# setup regular http server
socket_host = cherrypy.config.get('server.socket_host')
socket_port = cherrypy.config.get('server.socket_port')
if socket_host is None:
socket_host = '127.0.0.1'
if socket_port is None:
socket_port = 8080
server = cherrypy._cpserver.Server()
server.max_request_body_size = config['server.max_request_body_size']
server.bind_addr = (socket_host, socket_port)
server.subscribe()
cherrypy.server = server
WebSocketPlugin.start.priority = 80
WebSocketPlugin(cherrypy.engine).subscribe()
LessReloader(cherrypy.engine).subscribe()
JsReloader(cherrypy.engine).subscribe()
cherrypy.engine.database = SqlAlchemyPlugin(cherrypy.engine)
cherrypy.engine.database.subscribe()
cherrypy.engine.jinja = JinjaPlugin(cherrypy.engine)
cherrypy.engine.jinja.subscribe()
cherrypy.engine.library = LibraryPlugin(cherrypy.engine)
cherrypy.engine.library.subscribe()
cherrypy.engine.library_watchdog = LibraryWatchdogPlugin(cherrypy.engine)
cherrypy.engine.library_watchdog.subscribe()
cherrypy.engine.whoosh = WhooshPlugin(cherrypy.engine)
cherrypy.engine.whoosh.subscribe()
cherrypy.engine.cache = CachePlugin(cherrypy.engine)
cherrypy.engine.cache.subscribe()
cherrypy.engine.bgtask = BackgroundTaskPlugin(cherrypy.engine)
cherrypy.engine.bgtask.subscribe()
cherrypy.engine.bgtaskcron = BackgroundTaskCronPlugin(cherrypy.engine)
cherrypy.engine.bgtaskcron.subscribe()
cherrypy.engine.bgtaskcron.add_cron(DelugeBackgroundTaskCron())
return app
