@deepblend/dsh-blender-provider-local 0.2.7 → 0.2.9

package/lib/index.js

@@ -225,6 +225,28 @@ async function connect(socketPath, timeoutMs) {
   }
 }
 
+/**
+ * The actions this provider can serve from a kept session, and the ONLY ones it can.
+ *
+ * DERIVED, NOT CHOSEN: these are exactly the actions whose calls go through `runBootstrap`, which is
+ * the one place the session path is decided. Everything else spawns its own process on purpose —
+ * `render_frames` most of all, because cancelling a render has to kill exactly that render, and a
+ * request inside a kept session cannot be killed without ending the session (and, attached, the
+ * user's own Blender).
+ *
+ * WHY THE LIST IS CHECKED RATHER THAN TRUSTED. MEASURED: naming `render_frames` in `sessionActions`
+ * used to do NOTHING AT ALL — the configuration was inert, the render ran in its own process as
+ * before, and nothing anywhere said so. A key that silently does nothing is worse than a key that
+ * fails: the operator believes they changed something. `contract/session-routing.test.mjs` derives
+ * this set from the source, so adding a `runBootstrap` call site without adding it here goes red.
+ */
+export const SESSION_ROUTABLE_ACTIONS = Object.freeze([
+  'get_capabilities',
+  'compile_scene',
+  'render_preview',
+  'render_views',
+])
+
 /**
  * A live Blender, presented as one shape whatever carries the bytes.
  *
@@ -574,6 +596,20 @@ export default class LocalBlenderRuntime extends Service {
     // See the host's constructor: a key this row does not read is a startup error, because the schema
     // accepts it silently (SPEC §17's nested groups versus this package's flat keys).
     assertKnownConfigKeys(ProviderConfig, config, 'deepblend-blender-runtime')
+    // A CONFIGURED ACTION THAT CANNOT BE ROUTED IS REFUSED AT STARTUP, not ignored. Naming a render
+    // here would leave the operator believing their renders now run in their own Blender, while the
+    // render quietly kept its own process — the same shape as a key this row does not read, which the
+    // line above already refuses.
+    const unroutable = (config.sessionActions ?? []).filter(action => !SESSION_ROUTABLE_ACTIONS.includes(action))
+    if (unroutable.length > 0) {
+      throw new Error(
+        `sessionActions names ${unroutable.map(action => `"${action}"`).join(', ')}, and this provider can only ` +
+        `serve ${SESSION_ROUTABLE_ACTIONS.join(', ')} from a kept session. The renders that must be cancellable ` +
+        '(`render_frames`) spawn their own process on purpose: cancelling one kills exactly that render, and a ' +
+        'request inside a kept session cannot be killed without ending the session — which, attached, is the ' +
+        'user\'s own Blender.',
+      )
+    }
     this.config = config
     this.bootstrapPath = this._resolveBootstrapPath(config.bootstrapPath)
     /** Resolved once: the host must be configured with the same value. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deepblend/dsh-blender-provider-local",
-  "version": "0.2.7",
+  "version": "0.2.9",
   "type": "module",
   "description": "Local Blender Provider: the BlenderRuntime Service over ctx.subprocess (batch execution).",
   "main": "lib/index.js",
@@ -11,7 +11,7 @@
     "./package.json": "./package.json"
   },
   "dependencies": {
-    "@deepblend/dsh-blender-contracts": "0.2.7"
+    "@deepblend/dsh-blender-contracts": "0.2.9"
   },
   "license": "MIT",
   "repository": {

package/python/deepblend_bridge.py

@@ -107,10 +107,23 @@ class _Bridge:
     # -- lifecycle ---------------------------------------------------------
 
     def start(self):
+        # THREE STATES, NOT TWO. A socket path that exists is either a LIVE bridge or the file a dead
+        # one left behind, and the difference decides everything.
+        #
+        # MEASURED, and this is why: two workspaces on one machine both enabled the add-on, and the
+        # SECOND bridge unlinked the first's socket file, bound its own, and announced `ready` — so the
+        # first Blender became unreachable while still believing it was listening, and the second
+        # reported success. That is the failure this repository keeps paying for: something other than
+        # what was asked, reported as fine.
         if os.path.exists(self.socket_path):
-            # A socket file left by a process that died. Refusing to start would leave the user with
-            # no way forward except deleting a file they cannot see, so it is replaced — the same
-            # decision the render job's recovery path makes about a stale pid file.
+            if self._someone_is_listening():
+                raise RuntimeError(
+                    "another Blender is already serving %s. Give this one its own path with "
+                    "DEEPBLEND_BRIDGE_SOCKET (or the add-on's preferences), or stop the other bridge."
+                    % (self.socket_path,)
+                )
+            # Nothing answers, so it is the file a process that died left behind. Refusing here would
+            # leave the user with no way forward except deleting a file they cannot see.
             os.unlink(self.socket_path)
         self.server = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
         self.server.bind(self.socket_path)
@@ -118,6 +131,21 @@ class _Bridge:
         self.thread = threading.Thread(target=self._serve, name="deepblend-bridge", daemon=True)
         self.thread.start()
 
+    def _someone_is_listening(self):
+        """Whether a live bridge is behind this path, rather than a file left by a dead one."""
+        probe = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+        probe.settimeout(1.0)
+        try:
+            probe.connect(self.socket_path)
+            return True
+        except Exception:
+            return False
+        finally:
+            try:
+                probe.close()
+            except Exception:
+                pass
+
     def stop(self):
         try:
             if self.server is not None:
@@ -289,7 +317,15 @@ def main():
 
     global _BRIDGE
     _BRIDGE = _Bridge(socket_path, {"proc": None})
-    _BRIDGE.start()
+    try:
+        _BRIDGE.start()
+    except Exception as exc:
+        # A REFUSAL IS A RESULT, NOT A TRACEBACK. The one thing that can go wrong here is a named,
+        # actionable condition — another bridge on the same path — and a caller parsing stdout should
+        # get a document it can read rather than a stack it has to scrape. The add-on path already
+        # reports this in its panel; this is the same sentence for the headless one.
+        print(json.dumps({"kind": "error", "message": bootstrap.error_text(exc)}), flush=True)
+        return 2
     print(json.dumps({"kind": "ready", "pid": os.getpid(), "socket": socket_path}), flush=True)
     try:
         # The serve thread is a daemon, so this loop is what keeps the process alive. A SIGTERM (or