From 4b923c1dc70eaa4a3ca58d9e9f3218785b2fe919 Mon Sep 17 00:00:00 2001 From: marios Date: Thu, 26 May 2022 04:00:18 +0300 Subject: display overhaul, compatibility with legacy plugins, fixes --- backend/loader.py | 93 ++++++++++++++++++++++++++++++++++--------------------- 1 file changed, 57 insertions(+), 36 deletions(-) (limited to 'backend/loader.py') diff --git a/backend/loader.py b/backend/loader.py index e68842e2..60b1a901 100644 --- a/backend/loader.py +++ b/backend/loader.py @@ -2,16 +2,15 @@ from asyncio import Queue from logging import getLogger from os import listdir, path from pathlib import Path -from time import time from traceback import print_exc from aiohttp import web -from aiohttp_jinja2 import template from genericpath import exists +from json.decoder import JSONDecodeError from watchdog.events import FileSystemEventHandler from watchdog.observers.polling import PollingObserver as Observer -from injector import inject_to_tab +from injector import inject_to_tab, get_tab from plugin import PluginWrapper @@ -63,7 +62,6 @@ class Loader: self.plugin_path = plugin_path self.logger.info(f"plugin_path: {self.plugin_path}") self.plugins = {} - self.import_plugins() if live_reload: self.reload_queue = Queue() @@ -73,17 +71,21 @@ class Loader: self.loop.create_task(self.handle_reloads()) server_instance.add_routes([ - web.get("/plugins", self.handle_plugins), + web.get("/plugins", self.get_plugins), web.get("/plugins/{plugin_name}/frontend_bundle", self.handle_frontend_bundle), web.post("/plugins/{plugin_name}/methods/{method_name}", self.handle_plugin_method_call), - web.post("/methods/{method_name}", self.handle_server_method_call) + + # The following is legacy plugin code. + web.get("/plugins/load_main/{name}", self.load_plugin_main_view), + web.get("/plugins/plugin_resource/{name}/{path:.+}", self.handle_sub_route), + web.get("/steam_resource/{path:.+}", self.get_steam_resource) ]) - def handle_plugins(self, request): - plugins = list(map(lambda kv: dict([("name", kv[0])]), self.plugins.items())) - return web.json_response(plugins) + async def get_plugins(self, request): + plugins = list(self.plugins.values()) + return web.json_response([str(i) if not i.legacy else "$LEGACY_"+str(i) for i in plugins]) - def handle_frontend_bundle(self, request): + async def handle_frontend_bundle(self, request): plugin = self.plugins[request.match_info["plugin_name"]] with open(path.join(self.plugin_path, plugin.plugin_directory, plugin.frontend_bundle), 'r') as bundle: @@ -103,14 +105,13 @@ class Loader: self.logger.info(f"Plugin {plugin.name} is passive") self.plugins[plugin.name] = plugin.start() self.logger.info(f"Loaded {plugin.name}") - if refresh: - self.loop.create_task(self.reload_frontend_plugin(plugin.name)) + #self.loop.create_task(self.dispatch_plugin(plugin.name)) except Exception as e: self.logger.error(f"Could not load {file}. {e}") print_exc() - async def reload_frontend_plugin(self, name): - await inject_to_tab("SP", f"window.DeckyPluginLoader?.loadPlugin('{name}')") + async def dispatch_plugin(self, name): + await inject_to_tab("SP", f"window.importDeckyPlugin('{name}')") def import_plugins(self): self.logger.info(f"import plugins from {self.plugin_path}") @@ -125,38 +126,58 @@ class Loader: args = await self.reload_queue.get() self.import_plugin(*args) - async def handle_server_method_call(self, request): - method_name = request.match_info["method_name"] - method_info = await request.json() - args = method_info["args"] - - res = {} - try: - r = await self.utilities.util_methods[method_name](**args) - res["result"] = r - res["success"] = True - except Exception as e: - res["result"] = str(e) - res["success"] = False - - return web.json_response(res) - async def handle_plugin_method_call(self, request): res = {} plugin = self.plugins[request.match_info["plugin_name"]] method_name = request.match_info["method_name"] - - method_info = await request.json() - args = method_info["args"] - + try: + method_info = await request.json() + args = method_info["args"] + except JSONDecodeError: + args = {} try: if method_name.startswith("_"): raise RuntimeError("Tried to call private method") - res["result"] = await plugin.execute_method(method_name, args) res["success"] = True except Exception as e: res["result"] = str(e) res["success"] = False - return web.json_response(res) + + """ + The following methods are used to load legacy plugins, which are considered deprecated. + I made the choice to re-add them so that the first iteration/version of the react loader + can work as a drop-in replacement for the stable branch of the PluginLoader, so that we + can introduce it more smoothly and give people the chance to sample the new features even + without plugin support. They will be removed once legacy plugins are no longer relevant. + """ + async def load_plugin_main_view(self, request): + plugin = self.plugins[request.match_info["name"]] + with open(path.join(self.plugin_path, plugin.plugin_directory, plugin.main_view_html), 'r') as template: + template_data = template.read() + ret = f""" + + + + {template_data} + """ + return web.Response(text=ret, content_type="text/html") + + async def handle_sub_route(self, request): + plugin = self.plugins[request.match_info["name"]] + route_path = request.match_info["path"] + self.logger.info(path) + ret = "" + file_path = path.join(self.plugin_path, plugin.plugin_directory, route_path) + with open(file_path, 'r') as resource_data: + ret = resource_data.read() + + return web.Response(text=ret) + + async def get_steam_resource(self, request): + tab = await get_tab("QuickAccess") + try: + return web.Response(text=await tab.get_steam_resource(f"https://steamloopback.host/{request.match_info['path']}"), content_type="text/html") + except Exception as e: + return web.Response(text=str(e), status=400) \ No newline at end of file -- cgit v1.2.3