moonraker: refactor "make_request"

The make_request() method is now awaitable and returns the result directly vs the previous behavior of returning a request that was awaited.

There is no longer a need to check the result to see if it is an error, exceptions are raised if an error is detected.

Signed-off-by:  Eric Callahan <arksine.code@gmail.com>

moonraker/app.py

@@ -259,12 +259,12 @@ class RemoteRequestHandler(AuthorizedRequestHandler):
         args = {}
         if self.request.query:
             args = self.query_parser(self.request)
-        request = self.server.make_request(
+        try:
-            self.remote_callback, method, args)
+            result = await self.server.make_request(
-        result = await request.wait()
+                self.remote_callback, method, args)
-        if isinstance(result, ServerError):
+        except ServerError as e:
             raise tornado.web.HTTPError(
-                result.status_code, str(result))
+                e.status_code, str(e)) from e
         self.finish({'result': result})
 
 class LocalRequestHandler(AuthorizedRequestHandler):
@@ -301,7 +301,7 @@ class LocalRequestHandler(AuthorizedRequestHandler):
             result = await self.callback(self.request.path, method, args)
         except ServerError as e:
             raise tornado.web.HTTPError(
-                e.status_code, str(e))
+                e.status_code, str(e)) from e
         self.finish({'result': result})
 
 

moonraker/moonraker.py

@@ -217,51 +217,53 @@ class Server:
             self.init_cb.stop()
 
     async def _request_endpoints(self):
-        request = self.make_request("list_endpoints", "GET", {})
+        try:
-        result = await request.wait()
+            result = await self.make_request("list_endpoints", "GET", {})
-        if not isinstance(result, ServerError):
+        except ServerError:
-            endpoints = result.get('hooks', {})
+            return
-            static_paths = result.get('static_paths', {})
+        endpoints = result.get('hooks', {})
-            for ep in endpoints:
+        static_paths = result.get('static_paths', {})
-                self.moonraker_app.register_remote_handler(ep)
+        for ep in endpoints:
-            mutable_paths = {sp['resource_id']: sp['file_path']
+            self.moonraker_app.register_remote_handler(ep)
-                             for sp in static_paths}
+        mutable_paths = {sp['resource_id']: sp['file_path']
-            file_manager = self.lookup_plugin('file_manager')
+                         for sp in static_paths}
-            file_manager.update_mutable_paths(mutable_paths)
+        file_manager = self.lookup_plugin('file_manager')
+        file_manager.update_mutable_paths(mutable_paths)
 
     async def _check_available_objects(self):
-        request = self.make_request("objects/list", "GET", {})
+        try:
-        result = await request.wait()
+            result = await self.make_request("objects/list", "GET", {})
-        if not isinstance(result, ServerError):
+        except ServerError as e:
-            missing_objs = []
-            for obj in ["virtual_sdcard", "display_status", "pause_resume"]:
-                if obj not in result:
-                    missing_objs.append(obj)
-            if missing_objs:
-                err_str = ", ".join([f"[{o}]" for o in missing_objs])
-                logging.info(
-                    f"\nWarning, unable to detect the following printer "
-                    f"objects:\n{err_str}\nPlease add the the above sections "
-                    f"to printer.cfg for full Moonraker functionality.")
-        else:
             logging.info(
-                f"{result}\nUnable to retreive Klipper Object List")
+                f"{e}\nUnable to retreive Klipper Object List")
+            return
+        missing_objs = []
+        for obj in ["virtual_sdcard", "display_status", "pause_resume"]:
+            if obj not in result:
+                missing_objs.append(obj)
+        if missing_objs:
+            err_str = ", ".join([f"[{o}]" for o in missing_objs])
+            logging.info(
+                f"\nWarning, unable to detect the following printer "
+                f"objects:\n{err_str}\nPlease add the the above sections "
+                f"to printer.cfg for full Moonraker functionality.")
 
     async def _check_ready(self):
-        request = self.make_request("info", "GET", {})
+        try:
-        result = await request.wait()
+            result = await self.make_request("info", "GET", {})
-        if not isinstance(result, ServerError):
+        except ServerError as e:
-            is_ready = result.get("is_ready", False)
-            if is_ready:
-                self._set_klippy_ready()
-            else:
-                msg = result.get("message", "Klippy Not Ready")
-                logging.info("\n" + msg)
-        else:
             logging.info(
-                f"{result}\nKlippy info request error.  This indicates that\n"
+                f"{e}\nKlippy info request error.  This indicates that\n"
                 f"Klippy may have experienced an error during startup.\n"
                 f"Please check klippy.log for more information")
+            return
+        is_ready = result.get("is_ready", False)
+        if is_ready:
+            self._set_klippy_ready()
+        else:
+            msg = result.get("message", "Klippy Not Ready")
+            logging.info("\n" + msg)
+
 
     def _handle_klippy_response(self, request_id, response):
         req = self.pending_requests.pop(request_id, None)
@@ -288,12 +290,13 @@ class Server:
     def _process_status_update(self, status):
         self.send_event("server:status_update", status)
 
-    def make_request(self, path, method, args):
+    async def make_request(self, path, method, args):
         base_request = BaseRequest(path, method, args)
         self.pending_requests[base_request.id] = base_request
         self.ioloop.spawn_callback(
             self.send_klippy_request, base_request)
-        return base_request
+        result = await base_request.wait()
+        return result
 
     async def _kill_server(self):
         # XXX - Currently this function is not used.
@@ -345,6 +348,8 @@ class BaseRequest:
                 self._event.clear()
                 continue
             break
+        if isinstance(self.response, ServerError):
+            raise self.response
         return self.response
 
     def notify(self, response):

moonraker/plugins/file_manager.py

@@ -167,11 +167,8 @@ class FileManager:
 
     async def _handle_operation_check(self, requested_path):
         # Get virtual_sdcard status
-        request = self.server.make_request(
+        result = await self.server.make_request(
             "objects/status", 'GET', {'print_stats': []})
-        result = await request.wait()
-        if isinstance(result, self.server.error):
-            raise result
         pstats = result.get('print_stats', {})
         loaded_file = pstats.get('filename', "")
         state = pstats.get('state', "")

moonraker/plugins/gcode_apis.py

@@ -32,11 +32,8 @@ class GCodeAPIs:
 
     async def _send_gcode(self, script):
         args = {'script': script}
-        request = self.server.make_request(
+        result = await self.server.make_request(
             GCODE_ENDPOINT, 'POST', args)
-        result = await request.wait()
-        if isinstance(result, self.server.error):
-            raise result
         return result
 
     async def gcode_pause(self, path, method, args):

moonraker/plugins/paneldue.py

@@ -196,10 +196,10 @@ class PanelDue:
         }
 
     async def _klippy_request(self, command, method='GET', args={}):
-        request = self.server.make_request(command, method, args)
+        try:
-        result = await request.wait()
+            result = await self.server.make_request(command, method, args)
-        if isinstance(result, self.server.error):
+        except self.server.error as e:
-            raise PanelDueError(str(result))
+            raise PanelDueError(str(e)) from e
         return result
 
     async def handle_klippy_state(self, state):

moonraker/plugins/temperature_store.py

@@ -36,22 +36,22 @@ class TemperatureStore:
             return
 
         # Fetch sensors
-        request = self.server.make_request(
+        try:
-            "objects/status", 'GET', {'heaters': []})
+            result = await self.server.make_request(
-        result = await request.wait()
+                "objects/status", 'GET', {'heaters': []})
-        if isinstance(result, self.server.error):
+        except self.server.error as e:
-            logging.info(f"Error Configuring Sensors: {result}")
+            logging.info(f"Error Configuring Sensors: {e}")
             return
         sensors = result.get("heaters", {}).get("available_sensors", [])
 
         if sensors:
             # Add Subscription
             sub = {s: [] for s in sensors}
-            request = self.server.make_request(
+            try:
-                "objects/subscription", 'POST', sub)
+                result = await self.server.make_request(
-            result = await request.wait()
+                    "objects/subscription", 'POST', sub)
-            if isinstance(result, self.server.error):
+            except self.server.error as e:
-                logging.info(f"Error subscribing to sensors: {result}")
+                logging.info(f"Error subscribing to sensors: {e}")
                 return
             logging.info(f"Configuring available sensors: {sensors}")
             new_store = {}

moonraker/websockets.py

@@ -72,11 +72,12 @@ class JsonRPC:
             result = await method(*args, **kwargs)
         except TypeError as e:
             return self.build_error(-32603, "Invalid params", req_id)
+        except ServerError as e:
+            return self.build_error(e.status_code, str(e), req_id)
         except Exception as e:
             return self.build_error(-31000, str(e), req_id)
-        if isinstance(result, ServerError):
+
-            return self.build_error(result.status_code, str(result), req_id)
+        if req_id is None:
-        elif req_id is None:
             return None
         else:
             return self.build_result(result, req_id)
@@ -142,9 +143,8 @@ class WebsocketManager:
 
     def _generate_callback(self, endpoint, request_method):
         async def func(**kwargs):
-            request = self.server.make_request(
+            result = await self.server.make_request(
                 endpoint, request_method, kwargs)
-            result = await request.wait()
             return result
         return func