@deepblend/dsh-blender-provider-local 0.2.8 → 0.2.10

package/lib/index.js

@@ -363,6 +363,8 @@ class BlenderSession {
     // itself, in the `ready` line bootstrap.py opens with — which is better evidence anyway, because
     // it is the pid the script believes it is rather than the one the spawn returned.
     this.pid = input.transport.pid ?? null
+    /** The workspace the other end says it serves, or null when it did not say. */
+    this.workspace = null
     /** @type {Map<string, {resolve: Function, reject: Function, timer: object}>} */
     this.waiting = new Map()
     this.progress = []
@@ -456,6 +458,9 @@ class BlenderSession {
     }
     if (document?.kind === 'ready') {
       if (typeof document.pid === 'number') this.pid = document.pid
+      // What the other end says it serves, when it says anything. Empty means "not stated", which the
+      // attach path treats as "serves anything" — every deployment before this key existed.
+      if (typeof document.workspace === 'string') this.workspace = document.workspace
       this.readyResolve?.(this)
       return
     }
@@ -986,6 +991,24 @@ export default class LocalBlenderRuntime extends Service {
     // connected and said nothing took 180 s to report — long enough that a user would conclude the
     // product had hung.
     await session.ready(ATTACH_READY_MS)
+
+    // THE WRONG-BLENDER CHECK. A socket path has a global default, so two workspaces on one machine
+    // can point the product at the SAME Blender — and without this, workspace B would drive the
+    // Blender workspace A's user is looking at, silently, because both sides behave correctly. A
+    // bridge that states a workspace and states a DIFFERENT one is refused; a bridge that states none
+    // is served, because that is what every deployment did before the key existed.
+    const stated = session.workspace
+    if (typeof stated === 'string' && stated.length > 0 && resolve(stated) !== resolve(this.workspaceRoot)) {
+      await session.close()
+      throw new BlenderError(
+        BlenderErrorCode.RUNTIME_UNAVAILABLE,
+        `The Blender at ${socketPath} serves the workspace ${stated}, and this deployment is ${this.workspaceRoot}. ` +
+          'Point this deployment at its own bridge (DEEPBLEND_BRIDGE_SOCKET / sessionSocket), or start that Blender ' +
+          'with DEEPBLEND_BRIDGE_WORKSPACE set to this workspace.',
+        { detail: { socketPath, bridgeWorkspace: stated, workspaceRoot: this.workspaceRoot } },
+      )
+    }
+
     return session
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deepblend/dsh-blender-provider-local",
-  "version": "0.2.8",
+  "version": "0.2.10",
   "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.8"
+    "@deepblend/dsh-blender-contracts": "0.2.10"
   },
   "license": "MIT",
   "repository": {

package/python/deepblend_bridge.py

@@ -97,6 +97,15 @@ class _Bridge:
     def __init__(self, socket_path, options=None):
         self.socket_path = socket_path
         self.options = options or {}
+        # WHICH WORKSPACE THIS BLENDER SERVES, when it was told. Empty means "not stated", which is
+        # what every deployment did before this existed — and the product treats "not stated" as
+        # "serves anything" rather than as a mismatch, so nothing that worked before stops working.
+        #
+        # WHY IT MATTERS: the socket path has a global default, so two workspaces on one machine can
+        # point the product at the SAME Blender. Without this, the product in workspace B would drive
+        # the Blender that workspace A's user is looking at, and the operations would land in a scene
+        # nobody intended — silently, because both sides are behaving correctly.
+        self.workspace = self.options.get("workspace") or ""
         self.server = None
         self.thread = None
         self.requests = 0
@@ -107,10 +116,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 +140,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:
@@ -159,7 +196,12 @@ class _Bridge:
         nothing — so the product's `BlenderSession.ready()` waited forever on a peer that was already
         serving. A transport that answers the same conversation has to open it the same way.
         """
-        connection.sendall((json.dumps({"kind": "ready", "pid": os.getpid(), "socket": self.socket_path}) + "\n").encode("utf-8"))
+        connection.sendall((json.dumps({
+            "kind": "ready",
+            "pid": os.getpid(),
+            "socket": self.socket_path,
+            "workspace": self.workspace,
+        }) + "\n").encode("utf-8"))
         buffer = b""
         while True:
             chunk = connection.recv(65536)
@@ -239,6 +281,8 @@ class DEEPBLEND_PT_bridge(bpy.types.Panel):
         layout.label(text="Status: %s" % (_BRIDGE.status(),))
         layout.label(text="Socket: %s" % (os.path.basename(_BRIDGE.socket_path),))
         layout.label(text="Operations served: %d" % (_BRIDGE.requests,))
+        if _BRIDGE.workspace:
+            layout.label(text="Workspace: %s" % (os.path.basename(_BRIDGE.workspace),))
         if _BRIDGE.last_action is not None:
             layout.label(text="Last: %s" % (_BRIDGE.last_action,))
         if _BRIDGE.last_error is not None:
@@ -248,7 +292,7 @@ class DEEPBLEND_PT_bridge(bpy.types.Panel):
 def register():
     global _BRIDGE
     socket_path = os.environ.get("DEEPBLEND_BRIDGE_SOCKET", DEFAULT_SOCKET)
-    _BRIDGE = _Bridge(socket_path)
+    _BRIDGE = _Bridge(socket_path, {"workspace": os.environ.get("DEEPBLEND_BRIDGE_WORKSPACE", "")})
     try:
         _BRIDGE.start()
     except Exception as exc:
@@ -272,6 +316,7 @@ def main():
     """Headless entry point: serve until the process is asked to stop."""
     argv = sys.argv
     options = {}
+    workspace = os.environ.get("DEEPBLEND_BRIDGE_WORKSPACE", "")
     if "--" in argv:
         tokens = argv[argv.index("--") + 1:]
         index = 0
@@ -280,6 +325,10 @@ def main():
                 options["socket"] = tokens[index + 1]
                 index += 2
                 continue
+            if tokens[index] == "--workspace" and index + 1 < len(tokens):
+                workspace = tokens[index + 1]
+                index += 2
+                continue
             index += 1
     socket_path = options.get("socket", DEFAULT_SOCKET)
 
@@ -288,9 +337,17 @@ def main():
         return 2
 
     global _BRIDGE
-    _BRIDGE = _Bridge(socket_path, {"proc": None})
-    _BRIDGE.start()
-    print(json.dumps({"kind": "ready", "pid": os.getpid(), "socket": socket_path}), flush=True)
+    _BRIDGE = _Bridge(socket_path, {"proc": None, "workspace": workspace})
+    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, "workspace": workspace}), flush=True)
     try:
         # The serve thread is a daemon, so this loop is what keeps the process alive. A SIGTERM (or
         # the product closing the socket and asking for shutdown) ends it.