node-red-contrib-uos-nats 1.3.55 → 1.3.68

package/README.md

@@ -77,7 +77,7 @@ Reads values from existing providers (like `u_os_adm`).
 ### DataHub - Write
 Changes values in other providers.
 -   **Single Mode:** Select a variable from the list. Send `msg.payload` = value.
--   **Batch Mode:** Select NO variable (clear selection). Send `msg.payload` as a JSON object: `{"var_key": value, "var2": value}` (uses Configured Provider).
+-   **Batch Mode:** Select NO variable (clear selection). Send `msg.payload` as a FLAT JSON object: `{"var_key": value, "machine.status": value}` (uses Configured Provider). **Nested objects are NOT supported** (keys must use dot-notation).
 -   **Dynamic Mode:** Send a full target object to write anywhere:
     ```json
     {
@@ -87,8 +87,8 @@ Changes values in other providers.
     }
     ```json
     {
-      "provider": "target_provider_id",
-      "key": "variable_key",
+      "provider": "u_os_sbm",
+      "key": "ur20_8do_p_1.process_data.channel_7.do",
       "value": 123
     }
     ```

package/nodes/datahub-input.js

@@ -168,134 +168,100 @@ module.exports = function (RED) {
           return; // Stop here, do not start Interval or Subscription
         }
 
-        performSnapshot = async (overrideItems) => {
+        performSnapshot = async () => {
+          // Debugging connection state
           if (!nc || nc.isClosed()) {
             this.warn('Snapshot skipped: Connection is closed or not ready.');
             return;
           }
 
-          // Group items by Provider
-          // Default Provider: this.providerId
-          const requests = new Map(); // ProviderId -> Set<VariableId>
-
-          if (overrideItems) {
-            // Dynamic Mode: Resolve each item
-            for (const item of overrideItems) {
-              let pId = (typeof item === 'object' && item.provider) ? item.provider : this.providerId;
-              let key = (typeof item === 'object') ? item.key : item; // String or Object.key
-
-              if (!key) continue;
+          try {
+            // Resolve requested variable names to IDs
+            let targetIds = [];
+            let isWildcard = (this.variables.length === 0);
 
-              try {
-                // Use Config Node Resolution (Cache)
-                // This handles fetching definitions for ANY provider on demand
-                const resolved = await connection.resolveVariableId(pId, key);
-
-                if (!requests.has(pId)) requests.set(pId, new Set());
-                requests.get(pId).add(resolved.id);
-              } catch (e) {
-                this.warn(`Dynamic Read: Skipping '${key}' on '${pId}': ${e.message}`);
-              }
-            }
-          } else {
-            // Static Mode: Use local defMap for configured provider
-            const targetIds = new Set();
-            const isWildcard = (this.variables.length === 0);
             if (!isWildcard) {
+              // Reverse lookup: Find Def by Key
               const requestedKeys = new Set(this.variables);
+
               for (const def of defMap.values()) {
-                if (requestedKeys.has(def.key)) targetIds.add(def.id);
+                if (requestedKeys.has(def.key)) {
+                  targetIds.push(Number(def.id));
+                }
               }
-              if (targetIds.size === 0) {
-                this.warn(`Snapshot Aborted: None of the configured variables could be resolved.`);
+
+              // CRITICAL FIX: If user requested specific variables but we found NONE, 
+              // we MUST NOT send an empty list, because that would interpret as "Read All".
+              if (targetIds.length === 0) {
+                // Already handled by Gate above mostly, but good for safety
+                this.warn(`Snapshot Aborted: None of the ${this.variables.length} requested variables could be resolved to IDs.`);
                 return;
               }
             }
-            requests.set(this.providerId, targetIds); // Empty Set = Wildcard
-          }
-
-          if (requests.size === 0) {
-            this.warn("Snapshot Aborted: No valid variables resolved.");
-            return;
-          }
 
-          const allResults = [];
-          const errors = [];
+            // If Wildcard (empty targetIds and isWildcard=true) -> Request ALL.
+            // If Specific (targetIds has items) -> Request specific.
+            // Use serialRequest via Config Node to prevent concurrency issues on the connection
+            // Simple Snapshot Logic using Config Node Semaphore
+            // The Config Node now handles concurrency (max 3 parallel), preventing 503s naturally.
+            // We use a simple retry wrapper just in case.
+            let lastError;
+            for (let attempt = 1; attempt <= 3; attempt++) {
+              try {
+                let snapshotMsg;
+                // If config node has serialRequest (Semaphore), use it.
+                if (typeof connection.serialRequest === 'function') {
+                  snapshotMsg = await connection.serialRequest(subjects.readVariablesQuery(this.providerId), payloads.buildReadVariablesQuery(targetIds), { timeout: 10000 });
+                } else {
+                  // Fallback to direct request (unsafe)
+                  snapshotMsg = await nc.request(subjects.readVariablesQuery(this.providerId), payloads.buildReadVariablesQuery(targetIds), { timeout: 10000 });
+                }
 
-          // Execute Requests (Serial or Parallel?) 
-          // Using Serial to be safe with connection bandwidth
-          for (const [pId, varIds] of requests) {
-            try {
-              let targetIdsArr = Array.from(varIds);
+                const bb = new flatbuffers.ByteBuffer(snapshotMsg.data);
+                const snapshotObj = ReadVariablesQueryResponse.getRootAsReadVariablesQueryResponse(bb);
+                const states = payloads.decodeVariableList(snapshotObj.variables());
+
+                const filteredSnapshot = processStates(states);
+                if (filteredSnapshot.length > 0) {
+                  this.send({ payload: { type: 'snapshot', variables: filteredSnapshot } });
+                  this.status({ fill: 'green', shape: 'dot', text: 'active' });
+                } else {
+                  // Handle empty/partial...
+                  this.status({ fill: 'green', shape: 'ring', text: 'active (empty)' });
+                }
+                return true; // Success
 
-              // Request
-              let snapshotMsg;
-              if (typeof connection.serialRequest === 'function') {
-                snapshotMsg = await connection.serialRequest(subjects.readVariablesQuery(pId), payloads.buildReadVariablesQuery(targetIdsArr), { timeout: 10000 });
+              } catch (err) {
+                lastError = err;
+                // If semaphore is full or timeout, wait a bit
+                await new Promise(r => setTimeout(r, 1000 * attempt));
+              }
+            }
+            if (lastError) {
+              const msg = lastError.message || '';
+              if (msg.includes('503') || msg.includes('no responders')) {
+                this.debug(`Snapshot skipped (Provider offline/503): ${msg}`);
+                this.status({ fill: 'yellow', shape: 'dot', text: 'provider offline' });
+              } else if (msg.includes('Cooldown')) {
+                this.debug(`Snapshot skipped (Cooldown): ${msg}`);
+                this.status({ fill: 'yellow', shape: 'ring', text: 'cooldown (10s)' });
+              } else if (msg.includes('Authorization') || msg.includes('Permission')) {
+                this.debug(`Snapshot skipped (Auth): ${msg}`);
+                this.status({ fill: 'yellow', shape: 'ring', text: 'auth failed' });
               } else {
-                snapshotMsg = await nc.request(subjects.readVariablesQuery(pId), payloads.buildReadVariablesQuery(targetIdsArr), { timeout: 10000 });
+                this.warn(`Snapshot failed: ${msg}`);
+                this.status({ fill: 'red', shape: 'ring', text: 'snapshot error' });
               }
-
-              const bb = new flatbuffers.ByteBuffer(snapshotMsg.data);
-              const snapshotObj = ReadVariablesQueryResponse.getRootAsReadVariablesQueryResponse(bb);
-              const states = payloads.decodeVariableList(snapshotObj.variables());
-
-              // Add Provider Info to Result?
-              // ProcessStates adds keys, but we might want to know which provider it came from if mixed?
-              // The current `processStates` maps IDs back to Keys using `defMap`. 
-              // ISSUE: `defMap` only has local provider defs.
-              // If we read from foreign provider, `processStates` will return IDs or "Unknown".
-              // We need `resolveVariableId` to also START caching the reverse lookup or we assume result has IDs?
-              // Wait, `decodeVariableList` returns {id, value}.
-              // `processStates` tries to find Key.
-
-              // QUICK FIX for Dynamic Multi-Provider:
-              // If pId !== this.providerId, we don't have local defMap.
-              // But `resolveVariableId` (in config) caches definitions.
-              // We can ask config to resolve ID back to Key? Or just return ID?
-              // Better: We know the Keys we asked for.
-
-              // Let's modify processStates to accept a custom Map?
-              // Or simple: Just return the raw objects with IDs if we can't map them?
-              // Actually, for Dynamic Read, users might accept {id, value} or we try to enrich.
-
-              const enriched = states.map(s => {
-                // Try local defMap
-                if (pId === this.providerId && defMap.has(s.id)) {
-                  return { ...s, key: defMap.get(s.id).key, provider: pId };
-                }
-                // Try Config Node Cache (it has all fetched defs)
-                const cachedDef = connection.getProviderVariable(pId, s.id);
-                if (cachedDef) {
-                  return { ...s, key: cachedDef.key, provider: pId };
-                }
-                return { ...s, key: `id:${s.id}`, provider: pId };
-              });
-
-              allResults.push(...enriched);
-
-            } catch (err) {
-              errors.push(`${pId}: ${err.message}`);
             }
-          }
-
-          if (allResults.length > 0) {
-            this.send({ payload: { type: 'snapshot', variables: allResults } });
-            this.status({ fill: 'green', shape: 'dot', text: 'active' });
-          } else if (errors.length > 0) {
-            const errStr = errors.join('; ');
-            if (errStr.includes('503') || errStr.includes('no responders')) {
-              this.status({ fill: 'green', shape: 'ring', text: 'waiting for provider' });
-              this.debug(`Snapshot waiting: ${errStr}`);
-            } else if (errStr.includes('Authorization') || errStr.includes('Permission')) {
-              this.status({ fill: 'yellow', shape: 'ring', text: 'auth failed' });
-              this.warn(`Snapshot auth failed: ${errStr}`);
+          } catch (e) {
+            const msg = e.message || '';
+            if (msg.includes('503') || msg.includes('no responders')) {
+              this.debug(`Snapshot skipped (Provider offline/503): ${msg}`);
+            } else if (msg.includes('Cooldown')) {
+              // Ignore cooldown errors in outer catch
             } else {
-              this.status({ fill: 'red', shape: 'ring', text: 'error' });
-              this.warn(`Snapshot errors: ${errStr}`);
+              this.warn(`Snapshot failed: ${msg}`);
             }
-          } else {
-            this.status({ fill: 'green', shape: 'ring', text: 'empty' });
           }
         };
 
@@ -368,17 +334,7 @@ module.exports = function (RED) {
     };
 
     this.on('input', (msg, send, done) => {
-      let overrideItems = null;
-      if (msg.payload) {
-        if (Array.isArray(msg.payload) && msg.payload.length > 0) {
-          overrideItems = msg.payload;
-        } else if (typeof msg.payload === 'string' || (typeof msg.payload === 'object' && !Buffer.isBuffer(msg.payload))) {
-          // Allow single item dynamic read (convenience)
-          overrideItems = [msg.payload];
-        }
-      }
-
-      performSnapshot(overrideItems)
+      performSnapshot()
         .then(() => done())
         .catch((err) => done(err));
     });

package/nodes/datahub-output.js

@@ -154,7 +154,7 @@ module.exports = function (RED) {
         const { payload, fingerprint: fp } = modPayloads.buildProviderDefinitionEvent(definitions);
         const subject = modSubjects.providerDefinitionChanged(this.providerId);
 
-        console.log(`[DataHub Output] Publishing definition for Provider '${this.providerId}' to '${subject}'`);
+        // console.log(`[DataHub Output] Publishing definition for Provider '${this.providerId}' to '${subject}'`);
 
         fingerprint = fp;
         await nc.publish(subject, payload);

package/nodes/datahub-write.html

@@ -250,12 +250,12 @@
     </ol>
     <p>If no variable is selected, the node works in <b>Batch Mode</b> or <b>Dynamic Mode</b>.</p>
     <ul>
-        <li><b>Batch:</b> Send a JSON object to update multiple keys for the configured Provider: <code>{"key": value, "key2": value}</code></li>
+        <li><b>Batch:</b> Send a FLAT JSON object to update multiple keys for the configured Provider: <code>{"key": value, "machine.status": value}</code>. <br><b>Note:</b> Nested objects are NOT flattened automatically. Use dot-notation for keys!</li>
         <li><b>Dynamic:</b> Send a specific object to target ANY Provider/Key:
             <code>
             {
                 "provider": "u_os_sbm",
-                "key": "machine.outputs.DO01",
+                "key": "ur20_8do_p_1.process_data.channel_7.do",
                 "value": true
             }
             </code>

package/nodes/uos-config.js

@@ -187,6 +187,9 @@ module.exports = function (RED) {
           // Ensure we have a valid token initially
           await this.getToken();
 
+          // Sanitize clientName for Inbox usage (Strict NATS subjects)
+          const safeClientName = this.clientName.replace(/[^a-zA-Z0-9_-]/g, '_');
+
           this.nc = await connect({
             servers: `nats://${this.host}:${this.port}`,
             // Authenticator must be SYNCHRONOUS. We rely on background refresh to keep this.tokenInfo current.
@@ -197,7 +200,10 @@ module.exports = function (RED) {
             // REVERT: Use Configured Client Name for Connection.
             // Using UUID caused "Authorization Violation" for some users.
             name: this.clientName,
-            inboxPrefix: `_INBOX.${this.clientName}`,
+
+            // inboxPrefix: `_INBOX.${safeClientName}`, // RESTORED: Spec requires strictly this format (ACLs enforce it). 
+            // Using safeClientName avoids invalid subject errors.
+            inboxPrefix: `_INBOX.${safeClientName}`,
             maxReconnectAttempts: -1, // Infinite reconnects
             reconnectTimeWait: 2000,
           });
@@ -457,10 +463,18 @@ module.exports = function (RED) {
         if (!def || !def.variables) return null;
 
         const v = def.variables.find(v => v.key === variableKey);
-        if (v) return v.id;
+        if (v) {
+          return {
+            id: v.id,
+            fingerprint: def.fingerprint || BigInt(0),
+            dataType: v.dataType
+          };
+        }
 
         // Try explicit numeric string fallback
-        if (!isNaN(variableKey)) return parseInt(variableKey);
+        if (!isNaN(variableKey)) {
+          return { id: parseInt(variableKey), fingerprint: BigInt(0) }; // Fallback, no fingerprint known
+        }
 
         return null;
       } catch (e) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-red-contrib-uos-nats",
-  "version": "1.3.55",
+  "version": "1.3.68",
   "description": "Node-RED nodes for Weidmüller u-OS Data Hub. Read, write, and provide variables via NATS protocol with OAuth2 authentication. Features: Variable Key resolution, custom icons, example flows, and provider definition caching.",
   "author": {
     "name": "IoTUeli",