sen-ether-client 0.1.5 → 0.1.7

package/API.md

@@ -67,7 +67,12 @@ variable as its multicast default:
 - `SEN_ETHER_DISCOVERY_PORT`
 
 Multicast group, bind address and interface selection are explicit `sen-ether-client`
-options, not SEN environment variables.
+options, not SEN environment variables. When no `interfaceAddress` is provided,
+multicast discovery joins every local IPv4 interface visible to Node.js. If a
+SEN producer on the same host sends discovery through a physical interface that
+does not loop multicast packets back locally, discovery can still return no
+processes; in that case run the producer discovery on `lo`, pass the matching
+`interfaceAddress`, or use SEN TCP discovery.
 
 Preferred multi-session usage:
 

package/lib/discovery.js

@@ -50,6 +50,26 @@ function resolveInterfaceAddress(value) {
   return ipv4.address;
 }
 
+function multicastInterfaceCandidates(interfaceAddress) {
+  if (interfaceAddress) {
+    return [interfaceAddress];
+  }
+
+  try {
+    const addresses = [];
+    for (const candidates of Object.values(os.networkInterfaces())) {
+      for (const item of candidates ?? []) {
+        if ((item.family === 'IPv4' || item.family === 4) && item.address) {
+          addresses.push(item.address);
+        }
+      }
+    }
+    return [...new Set(addresses)];
+  } catch {
+    return [];
+  }
+}
+
 function normalizeTcpRemote(socket) {
   return {
     address: socket.remoteAddress,
@@ -149,8 +169,29 @@ export class EtherDiscoveryScanner extends EventEmitter {
       const onListening = () => {
         socket.off('error', onError);
         try {
-          socket.addMembership(this.group, this.interfaceAddress);
+          const interfaces = multicastInterfaceCandidates(this.interfaceAddress);
+          if (interfaces.length) {
+            let joined = 0;
+            /** @type {Error | undefined} */
+            let firstError;
+            for (const interfaceAddress of interfaces) {
+              try {
+                socket.addMembership(this.group, interfaceAddress);
+                joined += 1;
+              } catch (error) {
+                firstError ??= /** @type {Error} */ (error);
+              }
+            }
+            if (!joined) {
+              throw firstError ?? new Error(`could not join multicast group ${this.group}`);
+            }
+          } else {
+            socket.addMembership(this.group);
+          }
           socket.setMulticastLoopback(true);
+          if (this.interfaceAddress) {
+            socket.setMulticastInterface(this.interfaceAddress);
+          }
         } catch (error) {
           reject(error);
           return;

package/lib/sen.js

@@ -132,6 +132,13 @@ function busSummary(sessionName, busName) {
   };
 }
 
+function knownBusNames(sen) {
+  return [...new Set([
+    ...sen.remoteBuses,
+    ...sen.buses.keys()
+  ])].sort();
+}
+
 function selectorDescription(selector) {
   return typeof selector === 'function' ? '<predicate>' : String(selector);
 }
@@ -364,12 +371,7 @@ export class Sen extends EventEmitter {
         throw new Error('no SEN ether processes discovered');
       }
       this.targets = targets;
-      for (const target of targets) {
-        const sessionName = targetSessionName(target);
-        if (sessionName && !this.targetsBySession.has(sessionName)) {
-          this.targetsBySession.set(sessionName, target);
-        }
-      }
+      this.#rememberTargets(targets, { replace: false });
       this.emit('connect', {
         sessions: [...this.targetsBySession.keys()],
         targets
@@ -602,8 +604,7 @@ export class Sen extends EventEmitter {
     }
 
     const sessionName = this.target?.session?.name ?? this.client.processInfo.sessionName;
-    return [...this.remoteBuses]
-      .sort()
+    return knownBusNames(this)
       .map(busName => options.qualified ? queryBusName(sessionName, busName) : busName);
   }
 
@@ -621,24 +622,68 @@ export class Sen extends EventEmitter {
 
     if (this.client) {
       const sessionName = this.target?.session?.name ?? this.client.processInfo.sessionName;
-      return (await waitForSessionBuses(this, settleMs))
-        .map(busName => busSummary(sessionName, busName))
-        .filter(Boolean)
-        .sort((a, b) => a.qualified.localeCompare(b.qualified));
-    }
+      const summaries = new Map();
+      const addBus = busName => {
+        const summary = busSummary(sessionName, busName);
+        if (summary) {
+          summaries.set(summary.qualified, summary);
+        }
+      };
 
-    if (!this.targets.length && !this.sessions.size) {
-      const targets = await this.#discoverTargets(config);
-      if (!targets.length) {
-        throw new Error('no SEN ether processes discovered');
+      for (const busName of await waitForSessionBuses(this, settleMs)) {
+        addBus(busName);
       }
-      this.targets = targets;
-      for (const target of targets) {
-        const sessionName = targetSessionName(target);
-        if (sessionName && !this.targetsBySession.has(sessionName)) {
-          this.targetsBySession.set(sessionName, target);
+
+      if (!summaries.size || config.refreshTargets === true) {
+        try {
+          const target = await this.#discoverTarget({ ...config, session: sessionName });
+          if (target) {
+            const session = new Sen({
+              ...config,
+              session: sessionName,
+              reconnect: false
+            });
+            session.on('warning', error => this.emit('warning', error));
+            session.on('error', error => this.emit('warning', error));
+            try {
+              await session.connect({
+                ...config,
+                session: sessionName,
+                target,
+                reconnect: false
+              });
+              for (const busName of await waitForSessionBuses(session, settleMs)) {
+                addBus(busName);
+              }
+            } finally {
+              await session.close().catch(error => this.emit('warning', error));
+            }
+          }
+        } catch (error) {
+          this.emit('warning', error);
         }
       }
+
+      return [...summaries.values()].sort((a, b) => a.qualified.localeCompare(b.qualified));
+    }
+
+    let discoveredTargets = [];
+    if (!this.targets.length || this.sessions.size || config.refreshTargets === true) {
+      try {
+        discoveredTargets = await this.#discoverTargets(config);
+      } catch (error) {
+        if (!this.targets.length && !this.sessions.size) {
+          throw error;
+        }
+        this.emit('warning', error);
+      }
+    }
+
+    if (discoveredTargets.length) {
+      this.targets = discoveredTargets;
+      this.#rememberTargets(discoveredTargets, { replace: true });
+    } else if (!this.targets.length && !this.sessions.size) {
+      throw new Error('no SEN ether processes discovered');
     }
 
     const summaries = new Map();
@@ -782,6 +827,16 @@ export class Sen extends EventEmitter {
     return target;
   }
 
+  #rememberTargets(targets, options = {}) {
+    const replace = options.replace !== false;
+    for (const target of targets) {
+      const sessionName = targetSessionName(target);
+      if (sessionName && (replace || !this.targetsBySession.has(sessionName))) {
+        this.targetsBySession.set(sessionName, target);
+      }
+    }
+  }
+
   async #reconnectTarget(options) {
     if (options.tcpHub || !options.target) {
       return await this.#discoverTarget(options);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sen-ether-client",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "description": "Pure JavaScript SEN client for existing kernels over ether",
   "senCompatibility": {
     "kernelProtocolVersion": 9,