sen-ether-client 0.1.6 → 0.2.0

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

@@ -384,42 +384,57 @@ export class Sen extends EventEmitter {
 
   async #connectSingle(config) {
     const target = config.target ?? await this.#discoverTarget(config);
-    if (!target) {
+    const activeNode = Boolean(config.session && (config.tcpHub || config.multicastDiscovery !== false));
+    if (!target && !activeNode) {
       throw new Error('no SEN ether process matches the requested filters');
     }
 
-    const sessionName = target.session?.name ?? target.info?.sessionName ?? config.session;
+    const sessionName = target?.session?.name ?? target?.info?.sessionName ?? config.session;
     if (!sessionName) {
       throw new Error('cannot connect without a SEN session name');
     }
-    if (!this.targets.includes(target)) {
+    if (target && !this.targets.includes(target)) {
       this.targets.push(target);
     }
-    if (!this.targetsBySession.has(sessionName)) {
+    if (target && !this.targetsBySession.has(sessionName)) {
       this.targetsBySession.set(sessionName, target);
     }
 
     const client = new EtherClient({
       sessionName,
       appName: config.appName,
+      tcpHub: config.tcpHub,
+      multicastDiscovery: config.multicastDiscovery,
+      listen: config.listen,
+      listenHost: config.listenHost,
+      listenPort: config.listenPort,
+      advertisedHost: config.advertisedHost,
+      beamPeriodMs: config.beamPeriodMs,
       socketKeepAlive: config.socketKeepAlive,
       socketKeepAliveInitialDelayMs: config.socketKeepAliveInitialDelayMs,
       socketIdleTimeoutMs: config.socketIdleTimeoutMs,
       interfaceAddress: config.interfaceAddress,
+      group: config.group,
+      bindAddress: config.bindAddress,
       discoveryPort: config.port,
       busMulticast: config.busMulticast,
       busMulticastPort: config.busMulticastPort,
       busMulticastRange: config.busMulticastRange
     });
     this.client = client;
-    this.target = target;
+    this.target = target ?? { session: { name: sessionName }, process: client.processInfo, info: client.processInfo, local: true };
     this.#wireClient(client);
 
     try {
-      await client.connect(target);
-      await waitForEvent(client, 'ready', config.timeout ?? 3000);
-      this.#startPresenceWatchdog(target, config);
-      this.emit('connect', { target, sessionName });
+      if (config.tcpHub || config.listen !== false) {
+        await client.start(config);
+      }
+      if (target) {
+        await client.connect(target);
+        await waitForEvent(client, 'ready', config.timeout ?? 3000);
+        this.#startPresenceWatchdog(target, config);
+      }
+      this.emit('connect', { target: this.target, sessionName });
       return this;
     } catch (error) {
       await client.close().catch(closeError => this.emit('warning', closeError));
@@ -534,6 +549,60 @@ export class Sen extends EventEmitter {
     return await this.subscribe(name, options);
   }
 
+  /**
+   * Publish local JavaScript objects on a SEN bus.
+   *
+   * @param {string} busName Session-qualified or ether-local bus name.
+   * @param {object|object[]} objects
+   * @param {object} [options]
+   */
+  async publishObjects(busName, objects, options = {}) {
+    if (!this.client) {
+      const sessionName = this.#sessionNameForBus(busName, options);
+      const session = await this.session(sessionName);
+      return await session.publishObjects(busName, objects, options);
+    }
+
+    if (!this.client || !this.target) {
+      throw new Error('Sen is not connected');
+    }
+
+    const sessionName = this.target.session?.name ?? this.client.processInfo.sessionName;
+    this.#assertBusBelongsToSession(busName, sessionName);
+    const bus = etherBusName(sessionName, busName);
+
+    if (!this.buses.has(bus)) {
+      const joined = await this.client.joinBus(bus, options);
+      this.buses.set(bus, new SenBus(this, bus, joined.busId));
+    }
+
+    return this.client.publishObjects(bus, objects, options);
+  }
+
+  /**
+   * Remove previously published local JavaScript objects from a SEN bus.
+   *
+   * @param {string} busName Session-qualified or ether-local bus name.
+   * @param {Array<string|number>|string|number} objects Object ids or names.
+   * @param {object} [options]
+   */
+  async removePublishedObjects(busName, objects, options = {}) {
+    if (!this.client) {
+      const sessionName = this.#sessionNameForBus(busName, options);
+      const session = await this.session(sessionName);
+      return await session.removePublishedObjects(busName, objects, options);
+    }
+
+    if (!this.client || !this.target) {
+      throw new Error('Sen is not connected');
+    }
+
+    const sessionName = this.target.session?.name ?? this.client.processInfo.sessionName;
+    this.#assertBusBelongsToSession(busName, sessionName);
+    const bus = etherBusName(sessionName, busName);
+    return this.client.removePublishedObjects(bus, objects);
+  }
+
   async session(name) {
     const sessionName = String(name || '').trim();
     if (!sessionName) {
@@ -970,17 +1039,36 @@ export class Sen extends EventEmitter {
         client = new EtherClient({
           sessionName,
           appName: config.appName,
+          tcpHub: config.tcpHub,
+          multicastDiscovery: config.multicastDiscovery,
+          listen: config.listen,
+          listenHost: config.listenHost,
+          listenPort: config.listenPort,
+          advertisedHost: config.advertisedHost,
+          beamPeriodMs: config.beamPeriodMs,
           socketKeepAlive: config.socketKeepAlive,
           socketKeepAliveInitialDelayMs: config.socketKeepAliveInitialDelayMs,
-          socketIdleTimeoutMs: config.socketIdleTimeoutMs
+          socketIdleTimeoutMs: config.socketIdleTimeoutMs,
+          interfaceAddress: config.interfaceAddress,
+          group: config.group,
+          bindAddress: config.bindAddress,
+          discoveryPort: config.port,
+          busMulticast: config.busMulticast,
+          busMulticastPort: config.busMulticastPort,
+          busMulticastRange: config.busMulticastRange
         });
         this.client = client;
         this.target = target;
         this.#wireClient(client);
 
-        await client.connect(target);
-        await waitForEvent(client, 'ready', config.timeout ?? 3000);
-        this.#startPresenceWatchdog(target, config);
+        if (config.tcpHub || config.listen !== false) {
+          await client.start(config);
+        }
+        if (target) {
+          await client.connect(target);
+          await waitForEvent(client, 'ready', config.timeout ?? 3000);
+          this.#startPresenceWatchdog(target, config);
+        }
 
         for (const bus of this.buses.values()) {
           await bus.rejoin(config.timeout ?? 3000);

package/lib/values.js

@@ -1,5 +1,6 @@
 import { SenBinaryReader, SenBinaryWriter } from './codec.js';
 import { decodePropertyUpdateBuffer } from './bus.js';
+import { propertyHash } from './hash32.js';
 
 function numberOrBigInt(value) {
   return value <= BigInt(Number.MAX_SAFE_INTEGER) ? Number(value) : value;
@@ -323,6 +324,19 @@ export function encodeValue(value, typeName, typeRegistry) {
   return writer.toBuffer();
 }
 
+export function encodePropertyUpdateBuffer(updates = [], typeRegistry) {
+  const writer = new SenBinaryWriter();
+  for (const update of updates) {
+    writer.writeUInt32(update.id ?? propertyHash(update.name));
+    const value = update.valueBuffer
+      ? Buffer.from(update.valueBuffer)
+      : encodeValue(update.value, update.type, typeRegistry);
+    writer.writeUInt32(value.length);
+    writer.chunks.push(value);
+  }
+  return writer.toBuffer();
+}
+
 export function encodeArguments(values, argSpecs = [], typeRegistry) {
   if ((values?.length ?? 0) !== argSpecs.length) {
     throw new TypeError(`SEN method expects ${argSpecs.length} argument(s), got ${values?.length ?? 0}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sen-ether-client",
-  "version": "0.1.6",
+  "version": "0.2.0",
   "description": "Pure JavaScript SEN client for existing kernels over ether",
   "senCompatibility": {
     "kernelProtocolVersion": 9,
@@ -25,7 +25,7 @@
   "exports": "./index.js",
   "scripts": {
     "generate:protocol": "node ./scripts/generate-protocol.mjs",
-    "test": "node --test ./test/protocol.test.js ./test/codec.test.js ./test/discovery.test.js ./test/sen.test.js",
+    "test": "node --test --test-concurrency=1 --test-reporter spec ./test/protocol.test.js ./test/codec.test.js ./test/discovery.test.js ./test/client.test.js ./test/sen.test.js",
     "test:integration": "node --test ./test/integration-*.test.js"
   }
 }