fix: add local endpoint detection to UnoServerPool and skip demand file updates for remote-only configurations

Author: balazs-szucs

app/common/src/main/java/stirling/software/common/util/ProcessExecutor.java

@@ -16,7 +16,6 @@
 import java.util.concurrent.Semaphore;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.TimeoutException;
-import java.util.concurrent.locks.LockSupport;
 
 import io.github.pixee.security.BoundedLineReader;
 
@@ -548,57 +547,22 @@ private void validateCommand(List<String> command) {
 
     /**
      * Signal the on-demand unoserver manager that a conversion is needed. Writes the current epoch
-     * timestamp to /tmp/uno-last-used. The demand manager watches this file and:
+     * timestamp to /tmp/uno-last-used. The demand manager watches this file. Skips writing when
+     * configured purely with remoteunoserver endpoints.
      */
     private static void signalUnoServerDemand() {
+        if (unoServerPool != null && !unoServerPool.hasLocalEndpoints()) {
+            return;
+        }
         try {
             Path demandFile = Path.of("/tmp/uno-last-used");
             String epoch = String.valueOf(System.currentTimeMillis() / 1000);
             Files.writeString(demandFile, epoch);
-
-            // waitForUnoServerReady(30);
         } catch (IOException e) {
             log.debug("Could not write unoserver demand file: {}", e.getMessage());
         }
     }
 
-    /**
-     * Wait for at least one unoserver endpoint to accept connections. Uses a simple TCP connect
-     * probe to the first configured endpoint.
-     */
-    private static void waitForUnoServerReady(int maxWaitSeconds) {
-        if (unoServerPool == null || unoServerPool.isEmpty()) {
-            return;
-        }
-        // Try a quick TCP probe to the first endpoint
-        try {
-            var lease = unoServerPool.acquireEndpoint(1, TimeUnit.MILLISECONDS);
-            var endpoint = lease.getEndpoint();
-            lease.close();
-
-            String host = endpoint.getHost();
-            int port = endpoint.getPort();
-            if (host == null || host.isBlank()) host = "127.0.0.1";
-            if (port <= 0) port = 2003;
-
-            for (int i = 0; i < maxWaitSeconds; i++) {
-                try (var socket = new java.net.Socket()) {
-                    socket.connect(new java.net.InetSocketAddress(host, port), 1000);
-                    log.debug("unoserver ready on {}:{}", host, port);
-                    return;
-                } catch (IOException e) {
-                    // Not ready yet, wait
-                    LockSupport.parkNanos(TimeUnit.SECONDS.toNanos(1));
-                }
-            }
-            log.warn("unoserver not ready after {}s, proceeding anyway", maxWaitSeconds);
-        } catch (InterruptedException e) {
-            Thread.currentThread().interrupt();
-        } catch (TimeoutException e) {
-            // Pool fully occupied, unoserver is likely running
-        }
-    }
-
     public enum Processes {
         LIBRE_OFFICE,
         PDFTOHTML,

app/common/src/main/java/stirling/software/common/util/UnoServerPool.java

@@ -35,6 +35,38 @@ public boolean isEmpty() {
         return endpoints.isEmpty();
     }
 
+    public boolean hasLocalEndpoints() {
+        if (endpoints.isEmpty()) {
+            return true;
+        }
+        for (ApplicationProperties.ProcessExecutor.UnoServerEndpoint ep : endpoints) {
+            if (isLocalEndpoint(ep)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private static boolean isLocalEndpoint(
+            ApplicationProperties.ProcessExecutor.UnoServerEndpoint ep) {
+        if (ep == null) {
+            return true;
+        }
+        String loc = ep.getHostLocation();
+        if ("remote".equalsIgnoreCase(loc)) {
+            return false;
+        }
+        if ("local".equalsIgnoreCase(loc)) {
+            return true;
+        }
+        String host = ep.getHost();
+        if (host == null || host.isBlank()) {
+            return true;
+        }
+        host = host.trim().toLowerCase(Locale.ROOT);
+        return "127.0.0.1".equals(host) || "localhost".equals(host) || "::1".equals(host);
+    }
+
     public UnoServerLease acquireEndpoint() throws InterruptedException {
         if (endpoints.isEmpty()) {
             return new UnoServerLease(defaultEndpoint(), null, this);

app/common/src/test/java/stirling/software/common/util/UnoServerPoolTest.java

@@ -259,6 +259,31 @@ void testHostLocationAndProtocol() throws InterruptedException {
         }
     }
 
+    @Test
+    void testHasLocalEndpoints() {
+        // Empty pool defaults to local
+        assertTrue(new UnoServerPool(Collections.emptyList()).hasLocalEndpoints());
+
+        // Pool with 127.0.0.1 (default auto) is local
+        assertTrue(new UnoServerPool(createEndpoints(1)).hasLocalEndpoints());
+
+        // Pool with explicit remote location is not local
+        ApplicationProperties.ProcessExecutor.UnoServerEndpoint remoteEp =
+                new ApplicationProperties.ProcessExecutor.UnoServerEndpoint();
+        remoteEp.setHost("unoserver1");
+        remoteEp.setHostLocation("remote");
+        UnoServerPool remotePool = new UnoServerPool(Collections.singletonList(remoteEp));
+        assertFalse(remotePool.hasLocalEndpoints());
+
+        // Pool with explicit local location is local
+        ApplicationProperties.ProcessExecutor.UnoServerEndpoint localEp =
+                new ApplicationProperties.ProcessExecutor.UnoServerEndpoint();
+        localEp.setHost("unoserver1");
+        localEp.setHostLocation("local");
+        UnoServerPool localPool = new UnoServerPool(Collections.singletonList(localEp));
+        assertTrue(localPool.hasLocalEndpoints());
+    }
+
     private List<ApplicationProperties.ProcessExecutor.UnoServerEndpoint> createEndpoints(
             int count) {
         List<ApplicationProperties.ProcessExecutor.UnoServerEndpoint> endpoints = new ArrayList<>();

docker/unoserver/entrypoint.sh

@@ -58,13 +58,20 @@ start_unoserver() {
   log "Starting unoserver on ${INTERFACE}:${PORT} (uno-port ${UNO_PORT}, timeout ${CONVERSION_TIMEOUT}s, profile ${PROFILE_DIR})"
   # Pass --user-installation as a plain path; unoserver 3.6 wraps it itself
   # and crashes if pre-wrapped as a file:// URI.
+  local demand_file="/tmp/uno-last-used"
   unoserver \
     --interface "$INTERFACE" \
     --port "$PORT" \
     --uno-port "$UNO_PORT" \
     --user-installation "${PROFILE_DIR}" \
     --conversion-timeout "$CONVERSION_TIMEOUT" \
-    2> >(grep --line-buffered -v "POST /RPC2" >&2) \
+    2> >(while read -r line; do
+          if [[ "$line" == *"POST /RPC2"* ]]; then
+            date +%s > "$demand_file" 2>/dev/null || true
+          else
+            printf '%s\n' "$line" >&2
+          fi
+        done) \
     &
   UNOSERVER_PID=$!
 }
@@ -90,7 +97,7 @@ recycle_supervisor() {
   fi
 
   if [ "$IDLE_TIMEOUT" -gt 0 ]; then
-    log "Idle shutdown enabled: stop after ${IDLE_TIMEOUT}s of inactivity"
+    log "Idle shutdown enabled: stop after ${IDLE_TIMEOUT}s of inactivity (Note: remote clients cannot wake an idle-stopped standalone instance over TCP)"
   fi
 
   # Track last activity via demand file (Java writes to this)