Improve performance on several API calls (#80)

* Streamline fetching renderer_info from API - use threading for performance improvements

* Use concurrent.futures instead of Threading

* Fix timeout issue with server proxy

* Minor fixes to code that handles proxy server online / offline status

src/api/api_server.py

@@ -1,4 +1,5 @@
 #!/usr/bin/env python3
+import concurrent.futures
 import json
 import logging
 import multiprocessing
@@ -341,13 +342,6 @@ def clear_history():
 
 @server.route('/api/status')
 def status():
-    renderer_data = {}
-    for render_class in EngineManager.supported_engines():
-        if EngineManager.all_versions_for_engine(render_class.name()):  # only return renderers installed on host
-            renderer_data[render_class.name()] = \
-                {'versions': EngineManager.all_versions_for_engine(render_class.name()),
-                 'is_available': RenderQueue.is_available_for_job(render_class.name())
-                 }
 
     # Get system info
     return {"timestamp": datetime.now().isoformat(),
@@ -361,7 +355,6 @@ def status():
             "memory_available": psutil.virtual_memory().available,
             "memory_percent": psutil.virtual_memory().percent,
             "job_counts": RenderQueue.job_counts(),
-            "renderers": renderer_data,
             "hostname": server.config['HOSTNAME'],
             "port": server.config['PORT']
             }
@@ -369,19 +362,38 @@ def status():
 
 @server.get('/api/renderer_info')
 def renderer_info():
+
+    def process_engine(engine):
+        try:
+            # Get all installed versions of the engine
+            installed_versions = EngineManager.all_versions_for_engine(engine.name())
+            if installed_versions:
+                # Use system-installed versions to avoid permission issues
+                system_installed_versions = [x for x in installed_versions if x['type'] == 'system']
+                install_path = system_installed_versions[0]['path'] if system_installed_versions else \
+                installed_versions[0]['path']
+
+                return {
+                    engine.name(): {
+                        'is_available': RenderQueue.is_available_for_job(engine.name()),
+                        'versions': installed_versions,
+                        'supported_extensions': engine.supported_extensions(),
+                        'supported_export_formats': engine(install_path).get_output_formats()
+                    }
+                }
+        except Exception as e:
+            logger.error(f'Error fetching details for {engine.name()} renderer: {e}')
+            return {}
+
     renderer_data = {}
-    for engine in EngineManager.supported_engines():
-        # Get all installed versions of engine
-        installed_versions = EngineManager.all_versions_for_engine(engine.name())
-        if installed_versions:
-            # fixme: using system versions only because downloaded versions may have permissions issues
-            system_installed_versions = [x for x in installed_versions if x['type'] == 'system']
-            install_path = system_installed_versions[0]['path'] if system_installed_versions \
-                else (installed_versions)[0]['path']
-            renderer_data[engine.name()] = {'is_available': RenderQueue.is_available_for_job(engine.name()),
-                                            'versions': installed_versions,
-                                            'supported_extensions': engine.supported_extensions(),
-                                            'supported_export_formats': engine(install_path).get_output_formats()}
+    with concurrent.futures.ThreadPoolExecutor() as executor:
+        futures = {executor.submit(process_engine, engine): engine.name() for engine in EngineManager.supported_engines()}
+
+        for future in concurrent.futures.as_completed(futures):
+            result = future.result()
+            if result:
+                renderer_data.update(result)
+
     return renderer_data
 
 

src/api/server_proxy.py

@@ -65,7 +65,7 @@ class RenderServerProxy:
         if self.__update_in_background:
             return self.__offline_flags < OFFLINE_MAX
         else:
-            return self.connect() is not None
+            return self.get_status() is not None
 
     def status(self):
         if not self.is_online():
@@ -76,8 +76,9 @@ class RenderServerProxy:
     def request_data(self, payload, timeout=5):
         try:
             req = self.request(payload, timeout)
-            if req.ok and req.status_code == 200:
+            if req.ok:
                 self.__offline_flags = 0
+            if req.status_code == 200:
                 return req.json()
         except json.JSONDecodeError as e:
             logger.debug(f"JSON decode error: {e}")
@@ -90,10 +91,10 @@ class RenderServerProxy:
         except Exception as e:
             logger.exception(f"Uncaught exception: {e}")
 
-        # If server unexpectedly drops off the network, remove from Zeroconf list
+        # If server unexpectedly drops off the network, stop background updates
         if self.__offline_flags > OFFLINE_MAX:
             try:
-                ZeroconfServer.client_cache.pop(self.hostname)
+                self.stop_background_update()
             except KeyError:
                 pass
         return None
@@ -108,9 +109,11 @@ class RenderServerProxy:
         self.__update_in_background = True
 
         def thread_worker():
+            logger.debug(f'Starting background updates for {self.hostname}')
             while self.__update_in_background:
                 self.__update_job_cache()
                 time.sleep(self.update_cadence)
+            logger.debug(f'Stopping background updates for {self.hostname}')
 
         self.__background_thread = threading.Thread(target=thread_worker)
         self.__background_thread.daemon = True
@@ -127,7 +130,11 @@ class RenderServerProxy:
             self.__update_job_cache(timeout, ignore_token)
         return self.__jobs_cache.copy() if self.__jobs_cache else None
 
-    def __update_job_cache(self, timeout=30, ignore_token=False):
+    def __update_job_cache(self, timeout=40, ignore_token=False):
+
+        if self.__offline_flags:  # if we're offline, don't bother with the long poll
+            ignore_token = True
+
         url = f'jobs_long_poll?token={self.__jobs_cache_token}' if (self.__jobs_cache_token and
                                                                     not ignore_token) else 'jobs'
         status_result = self.request_data(url, timeout=timeout)
@@ -151,7 +158,7 @@ class RenderServerProxy:
 
     def get_status(self):
         status = self.request_data('status')
-        if not self.system_cpu:
+        if status and not self.system_cpu:
             self.system_cpu = status['system_cpu']
             self.system_cpu_count = status['cpu_count']
             self.system_os = status['system_os']

src/api/serverproxy_manager.py

@@ -21,6 +21,7 @@ class ServerProxyManager:
         if state_change == ServiceStateChange.Added or state_change == ServiceStateChange.Updated:
             cls.get_proxy_for_hostname(hostname)
         else:
+            cls.get_proxy_for_hostname(hostname).stop_background_update()
             cls.server_proxys.pop(hostname)
 
     @classmethod