plexora 0.0.8__tar.gz → 0.0.10__tar.gz

{plexora-0.0.8/plexora.egg-info → plexora-0.0.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plexora
-Version: 0.0.8
+Version: 0.0.10
 Summary: OpenSeadragon-based cellular image viewing and analysis tool.
 License-Expression: LicenseRef-Plexora-Academic-1.0
 Requires-Python: <3.14,>=3.12

{plexora-0.0.8 → plexora-0.0.10}/plexora/client/src/js/main.js

@@ -60,10 +60,9 @@ async function init(config) {
     // to "everything is on this server" without a single probe, and the rewrite
     // below is exactly what it has always been. For a project reading from a
     // data node it decides, once per tab, whether this browser can reach that
-    // node directly -- see services/resourceRouting.js.
-    const routing = await PlexoraRouting.load(datasource);
-    const imageRoute = PlexoraRouting.tileSource(routing, "image");
-    const segRoute = PlexoraRouting.tileSource(routing, "segmentation");
+    // node directly -- see services/resourceRouting.js. `let`, because a
+    // reconnect mid-session replaces it -- see repairRouting below.
+    let routing = await PlexoraRouting.load(datasource);
 
     // A layer that could not be loaded at all is already absent from `config`
     // by this point, so nothing below would ever mention it. Not awaited: the
@@ -74,21 +73,49 @@ async function init(config) {
     }
 
     if (Array.isArray(config.imageData)) {
-        config.imageData.forEach(function (channel, index) {
+        config.imageData.forEach(function (channel) {
             if (channel.src && channel.src.startsWith("/")) {
                 channel.src = plexoraUrl(channel.src);
             }
+            // The address THIS server serves the layer at, kept apart from the
+            // routed rewrite below so routing can be applied again later. A
+            // reconnect changes a node's port and token, and re-deriving the
+            // direct address from the previous direct address would strand the
+            // one case that has to work: a route that has fallen back to the
+            // proxy and later becomes direct again.
+            channel.origSrc = channel.src;
+        });
+        applyRouting(routing);
+    }
+
+    /**
+     * Point every layer's tile address at what `routing` says, from scratch.
+     *
+     * Idempotent over `origSrc`, so it can run again when the answer changes
+     * -- at boot, and on every repair after a node reconnects or goes away.
+     */
+    function applyRouting(resolved) {
+        const imageRoute = PlexoraRouting.tileSource(resolved, "image");
+        const segRoute = PlexoraRouting.tileSource(resolved, "segmentation");
+        (config.imageData || []).forEach(function (channel, index) {
+            if (!channel.origSrc) return;
             // imageData[0] is the label layer when, and only when, the project
             // has a mask -- the same rule ViewerManager.raiseLabelLayer applies
             // and for the same reason, so the two cannot disagree about which
             // entry is which.
             const isLabel = index === 0 && Boolean(config.segmentation);
             const route = isLabel ? segRoute : imageRoute;
-            if (!route) return;
+            if (!route) {
+                // This server's own address: the proxy path, which is also the
+                // only path for a local layer.
+                channel.src = channel.origSrc;
+                channel.srcQuery = "";
+                return;
+            }
             // An image names which channel in the path; a mask has one plane
             // and names nothing. The key is the last segment of the address
-            // this entry already had, whichever server it pointed at.
-            const key = channel.src.replace(/\/+$/, "").split("/").pop();
+            // this server would serve the entry at.
+            const key = channel.origSrc.replace(/\/+$/, "").split("/").pop();
             channel.src = route.appendKey ? route.base + key + "/" : route.base;
             // Carried apart from `src` rather than appended to it, because
             // `channel_add` reads the key back out of `src` by position and a
@@ -163,6 +190,112 @@ async function init(config) {
     __plexora.dataset = PlexoraDataset.build(config, imageChannels, dd);
     channelList.init(dd);
 
+    /**
+     * Rebuild every tiled image off the addresses `config` now holds.
+     *
+     * The same remove-and-re-add the HD toggle uses, and for the same reason
+     * (see ViewerManager.setHdMode): invalidating tiles in place leaves stale
+     * canvases on screen. `currentChannels` still holds each layer's OLD url,
+     * which is exactly what channel_remove matches world items against -- so
+     * the order is fixed: applyRouting first, this second.
+     */
+    function rebuildTileLayers() {
+        const world = seaDragonViewer.viewer && seaDragonViewer.viewer.world;
+        if (!world) return;
+        Object.keys(channelList.currentChannels).map(Number).forEach((srcIdx) => {
+            viewerManager.channel_remove(srcIdx);
+            viewerManager.channel_add(srcIdx);
+        });
+        if (config.segmentation) {
+            for (let i = world.getItemCount() - 1; i >= 0; i -= 1) {
+                const item = world.getItemAt(i);
+                if (item && item.source && item.source.tileFormat === 32) {
+                    world.removeItem(item);
+                }
+            }
+            // Both guards exist to make lazy loading happen once; this is the
+            // one caller that means "again" -- the same resets
+            // adoptSegmentation makes when a mask arrives mid-session.
+            // `noLabel` is set by the error callback when the label layer
+            // failed to load, which during an outage it did.
+            seaDragonViewer.noLabel = false;
+            viewerManager.labelLayerRequested = false;
+            viewerManager.load_label_image();
+        }
+    }
+
+    /**
+     * Say again what is missing, now that the answer may have changed.
+     *
+     * One banner at a time: whatever strip is up is about the addresses that
+     * were just replaced, and report() draws a fresh one when there is still
+     * something to say (and clears its own per-tab memories when there is not).
+     */
+    function rereportResources(resolved) {
+        if (!window.PlexoraResourceStatus) return;
+        document.querySelectorAll(".resource-status-banner")
+            .forEach((strip) => strip.remove());
+        PlexoraResourceStatus.report(datasource, resolved);
+    }
+
+    //: The in-flight repair, shared: a burst of failing tiles and a reconnect
+    //: event landing together is one re-resolution, not several racing ones.
+    let repairing = null;
+
+    /**
+     * Re-resolve where tiles come from, and take the answer on in place.
+     *
+     * What a reconnect used to require a page reload for: the node comes back
+     * on a new port with a new token, the server's own providers re-resolve on
+     * their next call (nodes.address_generation), and this is the browser-side
+     * counterpart -- without it every direct tile URL on the page kept the
+     * dead address, which made each reconnect look like it had done nothing.
+     */
+    function repairRouting() {
+        if (!window.PlexoraRouting) return Promise.resolve(null);
+        if (repairing) return repairing;
+        repairing = (async () => {
+            const before = JSON.stringify(routing && routing.routes || {});
+            const fresh = await PlexoraRouting.refresh(datasource);
+            routing = fresh;
+            rereportResources(fresh);
+            if (JSON.stringify(fresh.routes || {}) === before) return null;
+            applyRouting(fresh);
+            rebuildTileLayers();
+            return fresh;
+        })().finally(() => { repairing = null; });
+        return repairing;
+    }
+    __plexora.repairRouting = repairRouting;
+
+    // A data node connecting or going away is the moment tile addresses can
+    // change. remoteState announces the transition (it is already watching
+    // whenever one can happen in this tab); repairing on it is what lets a
+    // reconnect heal an open viewer instead of needing a reload nobody was
+    // told about.
+    window.addEventListener("plexora:remote-nodes-changed", () => {
+        repairRouting();
+    });
+
+    //: How often failing tiles may trigger a repair attempt. A dead node fails
+    //: tiles for as long as it is dead; asking the server once per window is
+    //: what keeps that from becoming a poll.
+    const TILE_FAILURE_REPAIR_MS = 30000;
+    let lastTileRepair = 0;
+    // A burst of failing tiles is how a moved or dead node actually presents
+    // mid-session -- nothing else on the page is watching when no dialog is
+    // open. Repairing answers both cases: an address that changed is taken on
+    // in place, and a node that is gone from the map gets the resource-status
+    // report (the modal with the Connect button) instead of silent timeouts.
+    if (seaDragonViewer.viewer && seaDragonViewer.viewer.addHandler) {
+        seaDragonViewer.viewer.addHandler("tile-load-failed", () => {
+            const now = Date.now();
+            if (now - lastTileRepair < TILE_FAILURE_REPAIR_MS) return;
+            lastTileRepair = now;
+            repairRouting();
+        });
+    }
+
     /**
      * Re-fetch what the server says this project's numbers are.
      *

{plexora-0.0.8 → plexora-0.0.10}/plexora/client/src/js/services/remoteGlobe.js

@@ -85,7 +85,7 @@ window.PlexoraRemoteGlobe = (function () {
      * Collapsing them loses the case that matters -- a session that still
      * reads connected against a node that has stopped answering.
      */
-    function healthOf(entry, health) {
+    function healthOf(entry, health, stale) {
         //: The probe first, and the session only as a fallback. A data node
         //: outlives the process that started it, so after a restart there is
         //: no session and the registry still holds the node -- asking the
@@ -101,6 +101,18 @@ window.PlexoraRemoteGlobe = (function () {
                      cls: "is-checking", ms: null, detail: "" };
         }
         if (probe.state === "healthy") {
+            //: The BROWSER's own version of the server's "stale" below, and it
+            //: outlasts it: the server's held address heals itself on its next
+            //: proxied call, while the page's direct tile URLs stay wherever
+            //: the tiles on screen were fetched from. Checked here, on top of
+            //: a healthy probe, because both claims are true at once -- the
+            //: machine IS well, and this page is not reading from it.
+            if (stale && stale[nodeNameOf(entry)]) {
+                return { word: "Reconnected", glyph: "arrows-rotate",
+                         cls: "is-degraded", ms: null,
+                         detail: "That machine is answering at a new address; "
+                                 + "this page is being repointed at it now." };
+            }
             return { word: "Healthy", glyph: "circle-check", cls: "is-healthy",
                      ms: probe.ms, detail: "" };
         }
@@ -120,6 +132,33 @@ window.PlexoraRemoteGlobe = (function () {
         };
     }
 
+    /**
+     * Which nodes the open page is still addressing at a retired location.
+     *
+     * Compares what this page's tiles were actually built from
+     * (`PlexoraRouting.held`) with what `/resource_routing` answers NOW. Only
+     * a direct route can be stale in the browser -- a proxied layer goes
+     * through this server, whose providers re-resolve on their own -- and a
+     * node that has left the map entirely is not stale, it is gone, which the
+     * probe already says in its own words. Empty on every page that never
+     * resolved routing, which is every page but the viewer.
+     */
+    function staleNodes(datasource, candidates) {
+        const held = window.PlexoraRouting && PlexoraRouting.held
+            ? PlexoraRouting.held(datasource) : null;
+        const routes = (held && held.routes) || {};
+        const stale = {};
+        Object.keys(routes).forEach((kind) => {
+            const mine = routes[kind];
+            const now = candidates[kind];
+            if (!mine || mine.mode !== "direct" || !now) return;
+            if (mine.base !== now.tile_base || mine.query !== now.query) {
+                stale[mine.node] = true;
+            }
+        });
+        return stale;
+    }
+
     //: The one mount there will ever be. This icon lives in the NAVBAR, which
     //: the router does not swap -- only the page below it is replaced -- so
     //: `PlexoraPage.register` runs again on every internal navigation against
@@ -158,6 +197,10 @@ window.PlexoraRemoteGlobe = (function () {
         //: and a different one from "we have not asked".
         let imageNode = null;
         let routingRead = false;
+        //: Node names whose registry address no longer matches what this
+        //: page's tiles were built from -- see staleNodes. Computed with the
+        //: routing read, drawn over a healthy probe as "Reconnected".
+        let pageStale = {};
         //: What `/remote_health` last said, by profile name, and which set of
         //: connected machines that answer was about -- so becoming connected
         //: while the panel is open re-asks, and a poll that changed nothing
@@ -234,6 +277,7 @@ window.PlexoraRemoteGlobe = (function () {
 
             imageNode = null;
             routingRead = false;
+            pageStale = {};
             health = {};
             healthFor = null;
             readRouting();
@@ -295,6 +339,18 @@ window.PlexoraRemoteGlobe = (function () {
                     const routes = (payload && payload.routes) || {};
                     imageNode = (routes.image && routes.image.node) || null;
                     routingRead = true;
+                    pageStale = staleNodes(datasource, routes);
+                    if (Object.keys(pageStale).length) {
+                        // Saying so is this panel's job; fixing it is the
+                        // viewer's. The same event a watched reconnect fires,
+                        // so there is one repair path -- this is the backstop
+                        // for a reconnect made from another tab, which no poll
+                        // in this one was awake to see.
+                        window.dispatchEvent(new CustomEvent(
+                            "plexora:remote-nodes-changed",
+                            { detail: { changed: Object.keys(pageStale).map(
+                                (node) => ({ name: null, node: node, up: true })) } }));
+                    }
                     if (panel) draw(Remotes().snapshot());
                 })
                 .catch(() => {});
@@ -430,7 +486,7 @@ window.PlexoraRemoteGlobe = (function () {
             item.append(top);
 
             const bottom = el("div", "remote-conn-bottom");
-            const state = healthOf(entry, health);
+            const state = healthOf(entry, health, pageStale);
             const well = el("span", "remote-conn-health " + state.cls);
             well.append(icon(state.glyph));
             well.append(el("span", null, state.word));

{plexora-0.0.8 → plexora-0.0.10}/plexora/client/src/js/services/remoteState.js

@@ -299,7 +299,52 @@ window.PlexoraRemotes = (function () {
         timer = window.setTimeout(() => { refresh(); }, POLL_MS);
     }
 
+    /**
+     * Which profiles' data nodes changed condition between two snapshots.
+     *
+     * The one thing a snapshot difference can say that no subscriber can:
+     * a node session coming up or going away changes which ADDRESS the open
+     * project's tiles should be fetched from, and the page holding those tile
+     * URLs (main.js) is not a subscriber -- it resolved routing once at boot.
+     * The event is what lets it repair itself instead of failing against a
+     * port that has gone until somebody thinks to reload.
+     *
+     * Only real transitions: a profile present in both snapshots whose node
+     * half changed being-up, map name, or registry name. The first snapshot
+     * has nothing to differ from, and a failed poll republishes the same
+     * entries object, so neither fires anything.
+     */
+    function nodeChanges(previous, next) {
+        if (!previous.loaded || !next.loaded) return [];
+        if (previous.entries === next.entries) return [];
+        const before = new Map();
+        (previous.entries || []).forEach((entry) => {
+            before.set(entry.name, entry.node);
+        });
+        const changed = [];
+        (next.entries || []).forEach((entry) => {
+            const was = before.get(entry.name);
+            if (!was) return;
+            const wasUp = was.state === "connected" || Boolean(was.node);
+            const isUp = entry.node.state === "connected"
+                || Boolean(entry.node.node);
+            if (wasUp !== isUp
+                    || (was.node || null) !== (entry.node.node || null)
+                    || (was.registered || null)
+                        !== (entry.node.registered || null)) {
+                changed.push({
+                    name: entry.name,
+                    node: entry.node.node || entry.node.registered
+                        || was.node || was.registered || null,
+                    up: isUp,
+                });
+            }
+        });
+        return changed;
+    }
+
     function publish(next) {
+        const changed = nodeChanges(current, next);
         current = next;
         subscribers.forEach((sub) => {
             try {
@@ -311,6 +356,10 @@ window.PlexoraRemotes = (function () {
                 if (window.console) console.error("remote state subscriber", e);
             }
         });
+        if (changed.length) {
+            window.dispatchEvent(new CustomEvent("plexora:remote-nodes-changed",
+                                                 { detail: { changed } }));
+        }
     }
 
     /**

{plexora-0.0.8 → plexora-0.0.10}/plexora/client/src/js/services/resourceRouting.js

@@ -48,6 +48,14 @@ window.PlexoraRouting = (function () {
     //: wait on the same probe rather than starting their own.
     const pending = new Map();
 
+    //: datasource -> the last fully-resolved table this page handed out: what
+    //: the page is ACTUALLY using, kept for anything that compares it against
+    //: the registry's current answer (the globe's stale check). Overwritten
+    //: when a re-resolution lands, never cleared by `forget` -- while a fresh
+    //: probe is in flight the old table is still the truthful account of what
+    //: the tiles on screen were built from.
+    const settled = new Map();
+
     //: The answer for a project with nothing on a node. Frozen and shared:
     //: every lookup against it returns "local", which is what every call site
     //: already assumed.
@@ -119,7 +127,11 @@ window.PlexoraRouting = (function () {
                               + "?datasource=" + encodeURIComponent(datasource))
             .then((response) => (response.ok ? response.json() : { routes: {} }))
             .then((body) => decide(datasource, body.routes || {}))
-            .catch(() => NOTHING_REMOTE);
+            .catch(() => NOTHING_REMOTE)
+            .then((resolved) => {
+                settled.set(datasource, resolved);
+                return resolved;
+            });
 
         pending.set(datasource, promise);
         return promise;
@@ -142,8 +154,14 @@ window.PlexoraRouting = (function () {
         });
 
         const asked = Array.from(byNode.entries()).map(([node, route]) => {
-            if (Object.prototype.hasOwnProperty.call(known, node)) {
-                verdicts[node] = known[node];
+            // Only a remembered YES is reused. A remembered "unreachable" was
+            // true of a moment -- a node mid-restart, a tunnel not yet up --
+            // and reusing it pinned the whole tab to the proxy hop for as long
+            // as it stayed open, silently, after the node came back. Probing
+            // again costs this one load at most PROBE_TIMEOUT_MS; being wrong
+            // the other way cost every tile an extra hop for the afternoon.
+            if (known[node] === true) {
+                verdicts[node] = true;
                 return Promise.resolve();
             }
             return probe(route).then((reachable) => { verdicts[node] = reachable; });
@@ -202,5 +220,30 @@ window.PlexoraRouting = (function () {
         pending.delete(datasource);
     }
 
-    return { load, tileSource, unreachable, forget, PROBE_TIMEOUT_MS };
+    /**
+     * The routing table this page is currently using, or null.
+     *
+     * Synchronous and never resolving anything: it answers "what were the
+     * tiles on screen built from", which is a fact about the past. The globe
+     * compares it against `/resource_routing`'s current answer to tell whether
+     * the open project is still addressed to where a node was before it was
+     * reconnected.
+     */
+    function held(datasource) {
+        return settled.get(datasource) || null;
+    }
+
+    /**
+     * Ask again from scratch: drop the memoised table AND the remembered
+     * verdicts, then resolve anew. What a reconnect calls -- the node came
+     * back on a new port with a new token, so both halves of what this tab
+     * remembers are about an address that has gone.
+     */
+    function refresh(datasource) {
+        forget(datasource);
+        return load(datasource);
+    }
+
+    return { load, tileSource, unreachable, forget, held, refresh,
+             PROBE_TIMEOUT_MS };
 })();

{plexora-0.0.8 → plexora-0.0.10}/plexora/client/templates/base.html

@@ -34,7 +34,7 @@
          awaits it before it builds a single tile source, and every page that
          can open a viewer loads it. Costs one request that answers "{}" for a
          project with nothing on a node. -->
-    <script src="{{ data.base_url }}/client/src/js/services/resourceRouting.js?v=20260826_direct_routing" type="text/javascript"></script>
+    <script src="{{ data.base_url }}/client/src/js/services/resourceRouting.js?v=20260830_reconnect_repair" type="text/javascript"></script>
     <!-- Why a layer is missing, when one is. Asks /resource_status once per
          project load and says nothing at all for a project with everything on
          this machine, which is every ordinary one. -->
@@ -87,7 +87,7 @@
        the one poll that four surfaces used to run three of. It costs nothing
        on a page that never subscribes -- there is no timer until somebody
        does. #}
-    <script src="{{ data.base_url }}/client/src/js/services/remoteState.js?v=20260830_install_plexora" defer></script>
+    <script src="{{ data.base_url }}/client/src/js/services/remoteState.js?v=20260830_reconnect_repair" defer></script>
     {# The connection log, shared by the modal and the Settings page's cards.
        Before both of them: they call into it as they build. #}
     <script src="{{ data.base_url }}/client/src/js/services/logTerminal.js?v=20260829_terminal" defer></script>
@@ -97,7 +97,7 @@
        it after pageBoot.js below (a normal script beats every deferred one),
        so PlexoraPage.register exists by the time this file's last line runs.
        It needs popoverPortal.js, loaded above with the other widgets. #}
-    <script src="{{ data.base_url }}/client/src/js/services/remoteGlobe.js?v=20260830_node_reconnect" defer></script>
+    <script src="{{ data.base_url }}/client/src/js/services/remoteGlobe.js?v=20260830_reconnect_repair" defer></script>
     {# Says so before a scheduled job ends, from whichever page the user is on.
        After connectionModal.js, which its one button opens; passive, so it
        costs nothing while a connection sits settled. #}

{plexora-0.0.8 → plexora-0.0.10}/plexora/client/templates/index.html

@@ -244,7 +244,7 @@
    by the time the user clicks the sidebar's upload icon, so deferred is ample.
    #}
 <script src="{{ data.base_url }}/client/src/js/views/channelNamesUpload.js?v=20260829_channel_names_switch" defer></script>
-<script src="{{ data.base_url }}/client/src/js/main.js?v=20260826_direct_routing" defer></script>
+<script src="{{ data.base_url }}/client/src/js/main.js?v=20260830_reconnect_repair" defer></script>
 {% else %}
 <div id="quick_view_landing" class="quick-view-landing">
     <div class="quick-view-card">