def run(self,
host,
port,
dev=False,
debug=False,
logging_queue=None,
cmd_args=None):
if logging_queue:
hlogger.Logger.setup_logger(cmd_args,
logging_queue,
dev=dev,
debug=debug)
utils.setup_online_reporter()
utils.enable_loggers(config.enabled_loggers.value)
if cmd_args is not None:
utils.parse_options(cmd_args)
views.init_views(self.happyweb, self.socketio)
self._ssl_args = {}
if config.enable_ssl.value is True or config.enable_ssl.value == "web":
log.i("SSL enabled for webserver", stdout=True)
self._ssl_args['ssl_context'] = utils.create_ssl_context(
webserver=True, server_side=True)
self._ssl_args['suppress_ragged_eofs'] = True
try:
self.socketio.run(self.happyweb,
host,
port,
debug=False,
**self._ssl_args)
except KeyboardInterrupt:
pass
def start(argv=None, db_kwargs={}):
if argv is None:
argv = sys.argv[1:]
utils.setup_dirs()
args = parser.parse_args(argv)
utils.parse_options(args)
if not args.only_web:
db.init(**db_kwargs)
command.init_commands()
hlogger.Logger.init_listener(args)
monkey.patch_all(thread=False)
hlogger.Logger.setup_logger(args)
if args.generate_config:
constants.config.save()
log.i("Generated configuration file at '{}'".format(
io_cmd.CoreFS(constants.settings_file).path),
stdout=True)
return
log.i("HPX SERVER START")
if not args.only_web:
constants.available_commands = command.get_available_commands()
services.init_generic_services()
if not args.safe:
plugins.plugin_loader(constants.dir_plugin)
else:
plugins.registered.init_plugins()
log.i("Starting webserver... ({}:{})".format(constants.host_web,
constants.port_web),
stdout=True)
web_args = (constants.host_web, constants.port_web,
constants.dev if args.only_web else False)
if args.only_web:
server.WebServer().run(*web_args)
else:
Process(target=server.WebServer().run,
args=web_args,
kwargs={
'logging_queue': hlogger.Logger._queue,
'logging_args': args
},
daemon=True).start()
server.HPServer().run(interactive=args.interact)
if not args.only_web:
constants.config.save()
hlogger.Logger.shutdown_listener()
log.i("HPX SERVER END")
def start():
utils.setup_dirs()
args = parser.parse_args()
utils.parse_options(args)
utils.setup_logger(args)
if args.generate_config:
constants.config.save()
print("Generated configuration file at '{}'".format(
io_cmd.CoreFS(constants.settings_file).path))
return
log.i("HPX SERVER START")
if not args.only_web:
constants.available_commands = command.get_available_commands()
constants.core_plugin = plugins._plugin_load(
"happypanda.core.coreplugin", "core", _logger=log)
if not args.safe:
plugins.plugin_loader(constants.dir_plugin)
else:
plugins.registered.init_plugins()
log.i("Starting webserver... ({}:{})".format(constants.host_web,
constants.port_web),
stdout=True)
web_args = (constants.host_web, constants.port_web,
constants.dev if args.only_web else False)
if args.only_web:
server.WebServer().run(*web_args)
else:
Process(target=server.WebServer().run, args=web_args,
daemon=True).start()
server.HPServer().run(interactive=args.interact)
if not args.only_web:
constants.config.save()
log.i("HPX SERVER END")
else:
app_path = os.path.join(app_path, gui_name)
name = "HappyPanda X GUI"
if value:
utils.add_to_startup(name, app_path)
else:
utils.remove_from_startup(name)
if __name__ == "__main__":
SQueue = StreamQueue()
SQueueExit = StreamQueue()
utils.parse_options(utils.get_argparser().parse_args())
utils.setup_i18n()
if config.gui_start_on_boot.value:
toggle_start_on_boot(None, config.gui_start_on_boot.value)
config.gui_start_on_boot.add_trigger(toggle_start_on_boot)
app = QApplication(sys.argv)
app.setAttribute(Qt.AA_EnableHighDpiScaling)
app.setWindowIcon(QIcon(constants.favicon_path))
app.setApplicationDisplayName("HappyPanda X")
app.setApplicationName("HappyPanda X")
app.setApplicationVersion(".".join(str(x) for x in constants.version))
app.setOrganizationDomain("Twiddly")
app.setOrganizationName("Twiddly")
app.setDesktopFileName("HappyPanda X")
def start(argv=None, db_kwargs={}):
assert sys.version_info >= (3, 6), "Python 3.6 and up is required"
e_code = None
e_num = 0
try:
utils.setup_online_reporter()
log.i("HPX START")
log.i("Version:", constants.version_str)
log.i("DB Version:", constants.version_db_str)
log.i("Web Version:", constants.version_web_str)
if argv is None:
argv = sys.argv[1:]
utils.setup_dirs()
args = parser.parse_args(argv)
utils.parse_options(args)
# setup logger without multiprocessing
hlogger.Logger.setup_logger(args, main=True, dev=constants.dev, debug=config.debug.value)
utils.enable_loggers(config.enabled_loggers.value)
db_inited = False
if constants.dev:
log.i("DEVELOPER MODE ENABLED", stdout=True)
else:
pdb.set_trace = lambda: None # disable pdb
if config.debug.value:
log.i("DEBUG MODE ENABLED", stdout=True)
log.i(utils.os_info())
if not args.only_web:
db_inited = db.init(**db_kwargs)
command.setup_commands()
else:
db_inited = True
if cmd_commands(args):
return
if not args.only_web: # can't init earlier because of cmd_commands
hlogger.Logger.init_listener(args=args, debug=config.debug.value, dev=constants.dev)
# setup logger with multiprocessing
hlogger.Logger.setup_logger(
args,
main=True,
dev=constants.dev,
debug=config.debug.value,
logging_queue=hlogger.Logger._queue)
# invalidate all cache
if constants.dev or config.debug.value:
for n, c in constants.cache_regions.items():
c.invalidate()
update_state = check_update() if not (not constants.is_frozen and constants.dev) else None
if not update_state == constants.UpdateState.Installing.value and db_inited:
utils.setup_i18n()
if not args.only_web:
constants.available_commands = command.get_available_commands()
services.setup_generic_services()
constants.plugin_manager = plugins.PluginManager()
if not args.safe:
plugins.plugin_loader(constants.plugin_manager, constants.dir_plugin)
if config.plugin_dir.value:
plugins.plugin_loader(constants.plugin_manager, config.plugin_dir.value)
constants.notification = server.ClientNotifications()
# starting stuff
services.Scheduler.generic.start()
init_commands(args)
log.i("Starting webserver... ({}:{})".format(config.host_web.value, config.port_web.value), stdout=True)
web_args = (config.host_web.value, config.port_web.value)
web_kwargs = {
'dev': constants.dev,
'debug': config.debug.value,
}
if args.only_web:
server.WebServer().run(*web_args, **web_kwargs)
else:
web_kwargs.update({'logging_queue': hlogger.Logger._queue,
'cmd_args': args, })
constants.web_proc = Process(target=server.WebServer().run,
args=web_args,
kwargs=web_kwargs,
daemon=True,
name="gevent")
constants.web_proc.start()
hp_server = server.HPServer()
meta_cmd.ShutdownApplication.shutdown.subscribe(hp_server.shutdown)
meta_cmd.RestartApplication.restart.subscribe(hp_server.restart)
meta_cmd.UpdateApplication.update.subscribe(hp_server.update)
e_code = hp_server.run(interactive=args.interact)
else:
if db_inited:
e_code = constants.ExitCode.Update
else:
e_code = constants.ExitCode.Exit
io_cmd.CoreFS(constants.dir_temp).delete(ignore_errors=True)
log.i("HPX END")
if e_code == constants.ExitCode.Exit:
log.i("Shutting down...", stdout=True)
elif e_code == constants.ExitCode.Restart:
log.i("Restarting...", stdout=True)
if not args.only_web:
config.config.save()
services.Scheduler.shutdown_all()
hlogger.Logger.shutdown_listener()
hlogger.shutdown()
# the gui will handle the restart
if e_code == constants.ExitCode.Restart and not constants.from_gui:
utils.restart_process()
elif e_code == constants.ExitCode.Update and not constants.from_gui:
utils.launch_updater()
except Exception as e:
if constants.web_proc:
constants.web_proc.terminate()
print(e) # intentional
e_num = 1
if not isinstance(e, exceptions.CoreError):
if config.report_critical_errors.value and not constants.dev and constants.is_frozen:
rollbar.report_exc_info()
raise
return e_code.value if e_code else e_num