[ENG-7607][ENG-8357] Feature/unoserver integration

Dockerfile

@@ -1,7 +1,5 @@
 FROM python:3.13-slim
 
-# ensure unoconv can locate the uno library
-ENV PYTHONPATH=/usr/lib/python3/dist-packages
 
 RUN usermod -d /home www-data \
     && chown www-data:www-data /home \

mfr/extensions/unoconv/export.py

@@ -1,37 +1,41 @@
 from http import HTTPStatus
 from os.path import basename, splitext
-from subprocess import run, CalledProcessError
 
+from unoserver.client import UnoClient
 from mfr.core.extension import BaseExporter
 from mfr.core.exceptions import SubprocessError
-from mfr.extensions.unoconv.settings import (PORT,
-                                             ADDRESS,
-                                             UNOCONV_BIN,
-                                             UNOCONV_TIMEOUT)
+from mfr.extensions.unoconv.settings import (
+    UNOSERVER_HOST,
+    UNOSERVER_PORT,
+    UNOSERVER_TIMEOUT,
+)
 
 
 class UnoconvExporter(BaseExporter):
+    """
+    Uses UnoClient (unoserver) to convert the source file into the requested format.
+    """
 
     def export(self):
+        client = UnoClient(
+            server=UNOSERVER_HOST,
+            port=int(UNOSERVER_PORT),
+        )
         try:
-            run([
-                UNOCONV_BIN,
-                '-n',
-                '-c', f'socket,host={ADDRESS},port={PORT};urp;StarOffice.ComponentContext',
-                '-f', self.format,
-                '-o', self.output_file_path,
-                '-vvv',
-                self.source_file_path
-            ], check=True, timeout=UNOCONV_TIMEOUT)
-        except CalledProcessError as err:
+            client.convert(
+                inpath=self.source_file_path,
+                outpath=self.output_file_path,
+                convert_to=self.format,
+            )
+        except Exception as err:
             name, extension = splitext(basename(self.source_file_path))
             raise SubprocessError(
                 'Unable to export the file in the requested format, please try again later.',
-                process='unoconv',
-                cmd=str(err.cmd),
-                returncode=err.returncode,
+                process='unoserver',
+                cmd=str(err),
+                returncode=None,
                 path=str(self.source_file_path),
                 code=HTTPStatus.BAD_REQUEST,
                 extension=extension or '',
-                exporter_class='unoconv',
+                exporter_class='unoserver',
             )

mfr/extensions/unoconv/render.py

@@ -34,7 +34,6 @@ def __init__(self, metadata, file_path, url, assets_url, export_url):
             export_url
         )
 
-        # can't call file_required until renderer is built
         self.renderer_metrics.add('file_required', self.file_required)
         self.renderer_metrics.add('cache_result', self.cache_result)
 
@@ -63,7 +62,7 @@ def render(self):
             try:
                 os.remove(self.export_file_path)
             except FileNotFoundError:
-                pass
+                logger.warning(f"[render] Export file not found for cleanup: {self.export_file_path}")
 
         return rendition
 

mfr/extensions/unoconv/settings.py

@@ -2,15 +2,12 @@
 
 from mfr import settings
 
+config = settings.child('UNOSERVER_EXTENSION_CONFIG')
 
-config = settings.child('UNOCONV_EXTENSION_CONFIG')
-
-UNOCONV_BIN = config.get('UNOCONV_BIN', '/usr/local/bin/unoconv')
-UNOCONV_TIMEOUT = int(config.get('UNOCONV_TIMEOUT', 60))
-
-ADDRESS = config.get('SERVER', os.environ.get('UNOCONV_PORT_2002_TCP_ADDR', '127.0.0.1'))
-PORT = config.get('PORT', os.environ.get('UNOCONV_PORT_2002_TCP_PORT', '2002'))
+UNOSERVER_TIMEOUT = int(config.get('TIMEOUT', 60))
 
+UNOSERVER_HOST = config.get( 'HOST',os.environ.get('UNOSERVER_INTERFACE', '127.0.0.1'))
+UNOSERVER_PORT = config.get('PORT',os.environ.get('UNOSERVER_PORT', '2003'))
 DEFAULT_RENDER = {'renderer': '.pdf', 'format': 'pdf'}
 
 RENDER_MAP = config.get_object('RENDER_MAP', {

mfr/server/app.py

@@ -71,7 +71,7 @@ def make_app(debug):
     app = tornado.web.Application(
         [
             (r'/static/(.*)', tornado.web.StaticFileHandler, {'path': server_settings.STATIC_PATH}),
-            (r'/assets/(.*?)/(.*\..*)', ExtensionsStaticFileHandler),
+            (r'/assets/(?P<module>[^/]+)/(?P<path>.*)', ExtensionsStaticFileHandler),
             (r'/export', ExportHandler),
             (r'/exporters', ExportersHandler),
             (r'/render', RenderHandler),

mfr/server/handlers/core.py

@@ -3,6 +3,8 @@
 import uuid
 import asyncio
 import logging
+import pathlib
+
 from importlib.metadata import entry_points
 
 import tornado.web
@@ -296,30 +298,45 @@ class ExtensionsStaticFileHandler(tornado.web.StaticFileHandler, CorsMixin):
 
     def initialize(self):
         # Todo: the method args differ in comparison with StaticFileHandler
-        namespace = 'mfr.renderers'
-        module_path = 'mfr.extensions'
-
+        namespace = "mfr.renderers"
+        module_path_prefix = "mfr.extensions"
         self.modules = {}
 
         for ep in entry_points().select(group=namespace):
-            module_name = ep.value.split(":")[0]  # replacement for ep.module_name
-            module = module_name.replace(module_path + ".", "").split(".")[0]
-            dist_location = ep.dist.locate_file("")  # replacement for ep.dist.location
-            static_path = os.path.join(dist_location, 'mfr', 'extensions', module, 'static')
-            self.modules[module] = static_path
-
-    async def get(self, module_name, path):
-        # Todo: the method args differ in comparison with StaticFileHandler, maybe it is ok
+            fq_mod = ep.value.split(":")[0]
+            module = fq_mod.replace(f"{module_path_prefix}.", "").split(".")[0]
+            root = pathlib.Path(ep.dist.locate_file(""))
+            static_dir = root / "mfr" / "extensions" / module / "static"
+            if static_dir.is_dir():
+                self.modules[module] = static_dir.as_posix()
+                logger.debug(f"   ↳ EP  {module}: {static_dir}")
+
+        repo_root = pathlib.Path(__file__).resolve().parents[2]
+        ext_root  = repo_root / "extensions"
+        if not ext_root.is_dir():
+            ext_root = repo_root.parent / "mfr" / "extensions"
+
+        for module_path in ext_root.iterdir():
+            static_dir = module_path / "static"
+            if static_dir.is_dir():
+                self.modules.setdefault(module_path.name, static_dir.as_posix())
+                logger.debug(f"   ↳ FS  {module_path.name}: {static_dir}")
+
+
+    async def get(self, module: str, path: str):
+        root = self.modules.get(module)
+        if not root:
+            self.set_status(404)
+            return
+
         try:
-            super().initialize(self.modules[module_name])
+            super().initialize(root)
             return await super().get(path)
-        except Exception:
-            # Todo: maybe it is needed to use logger and specific message for exception logging
+        except Exception as e:
             self.set_status(404)
 
         try:
             super().initialize(settings.STATIC_PATH)
             return await super().get(path)
-        except Exception:
-            # Todo: maybe it is needed to use logger and specific message for exception logging
+        except Exception as e:
             self.set_status(404)