sen-ether-client 0.1.3 → 0.1.5

package/lib/client.js

@@ -103,6 +103,25 @@ 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.internal && item.address) {
+          addresses.push(item.address);
+        }
+      }
+    }
+    return [...new Set(addresses)];
+  } catch {
+    return [];
+  }
+}
+
 function normalizeMulticastRange(value) {
   const ranges = Array.isArray(value) && value.length === 4 ? value : DEFAULT_MULTICAST_RANGE;
   return ranges.map((range, index) => {
@@ -435,6 +454,15 @@ export class EtherClient extends EventEmitter {
     return { busName: busState.busName, busId: busState.busId, id, query };
   }
 
+  #restartInterestForRemote(busState) {
+    for (const interest of busState.interests.values()) {
+      this.#sendBusControl(busState, busState.participantId, {
+        type: 'InterestStarted',
+        value: { query: interest.query, id: interest.id }
+      });
+    }
+  }
+
   /**
    * Stop a previously started interest.
    *
@@ -711,25 +739,13 @@ export class EtherClient extends EventEmitter {
 
   #onMulticastBusDatagram(busState, message, remote) {
     try {
-      if (message.length < 8) {
+      if (message.length < 9) {
         throw new RangeError(`SEN multicast bus datagram too small: ${message.length}`);
       }
-      const processId = message.readUInt32LE(0);
-      const payloadSize = message.readUInt32LE(4);
-      if (processId === this.processInfo.processId) {
+      const frame = decodeConfirmedBusFrame(message);
+      if (frame.to !== busState.participantId) {
         return;
       }
-      if (payloadSize !== message.length - 8) {
-        throw new RangeError(
-          `SEN multicast bus payload size mismatch: expected ${payloadSize}, got ${message.length - 8}`
-        );
-      }
-
-      const frame = {
-        to: busState.participantId,
-        busId: busState.busId,
-        message: message.subarray(8)
-      };
       const busMessage = decodeBusMessage(frame.message);
       this.emit('busFrame', { ...frame, busMessage, remote, multicast: true });
       if (busMessage.categoryName === 'controlMessage') {
@@ -766,7 +782,14 @@ export class EtherClient extends EventEmitter {
       const onListening = () => {
         socket.off('error', onError);
         try {
-          socket.addMembership(group, this.interfaceAddress);
+          const interfaces = multicastInterfaceCandidates(this.interfaceAddress);
+          if (interfaces.length) {
+            for (const interfaceAddress of interfaces) {
+              socket.addMembership(group, interfaceAddress);
+            }
+          } else {
+            socket.addMembership(group);
+          }
           socket.setMulticastLoopback(true);
           if (this.interfaceAddress) {
             socket.setMulticastInterface(this.interfaceAddress);
@@ -789,13 +812,14 @@ export class EtherClient extends EventEmitter {
       return;
     }
 
-    const remoteParticipantId = frame.to;
+    const remoteParticipantId = frame.to >>> 0;
     if (!busState.readyRemoteParticipants.has(remoteParticipantId)) {
       busState.readyRemoteParticipants.add(remoteParticipantId);
       this.#sendBusControl(busState, busState.participantId, {
         type: 'RemoteParticipantReady',
         value: { id: remoteParticipantId }
       });
+      this.#restartInterestForRemote(busState);
       this.emit('busParticipantReady', {
         busName: busState.busName,
         busId: busState.busId,

package/lib/sen.js

@@ -9,6 +9,9 @@ function wait(ms) {
   return new Promise(resolve => setTimeout(resolve, ms));
 }
 
+const STATE_RESYNC_DELAYS_MS = [250, 1000, 3000, 8000];
+const STATE_RESYNC_INTERVAL_MS = 1000;
+
 async function waitForEvent(emitter, event, timeoutMs) {
   let timeoutId;
   const timeout = new Promise((_, reject) => {
@@ -156,17 +159,14 @@ function stateRequestKey(interestId, objectId) {
 }
 
 async function waitForSessionBuses(session, timeoutMs) {
-  let buses = session.listBuses();
-  if (buses.length || timeoutMs <= 0) {
-    return buses;
+  if (timeoutMs <= 0) {
+    return session.listBuses();
   }
-
   const deadline = Date.now() + timeoutMs;
-  while (!buses.length && Date.now() < deadline) {
+  while (Date.now() < deadline) {
     await wait(Math.min(50, Math.max(1, deadline - Date.now())));
-    buses = session.listBuses();
   }
-  return buses;
+  return session.listBuses();
 }
 
 class ChangeBatcher {
@@ -782,6 +782,13 @@ export class Sen extends EventEmitter {
     return target;
   }
 
+  async #reconnectTarget(options) {
+    if (options.tcpHub || !options.target) {
+      return await this.#discoverTarget(options);
+    }
+    return options.target;
+  }
+
   #sessionNameForBus(busName, options = {}) {
     const explicit = String(options.session || '').trim();
     if (explicit) {
@@ -899,7 +906,7 @@ export class Sen extends EventEmitter {
         }
 
         const config = this.connectOptions;
-        const target = config.target ?? await this.#discoverTarget(config);
+        const target = await this.#reconnectTarget(config);
         if (!target) {
           throw new Error('no SEN ether process matches the requested filters');
         }
@@ -1062,6 +1069,8 @@ export class SenBus extends EventEmitter {
     this.typeRegistry = new Map();
     this.requestedTypeHashes = new Set();
     this.stateRequestedObjectIds = new Set();
+    this.stateResyncTimers = new Set();
+    this.stateResyncInterval = undefined;
     this.interests = new Map();
     this.pendingCalls = new Map();
     this.nextTicketId = 1;
@@ -1076,10 +1085,13 @@ export class SenBus extends EventEmitter {
 
   stopInterest(id) {
     const interestId = typeof id === 'object' ? id.id : id;
-    this.sen.client.stopInterest(this.name, interestId);
+    this.sen.client?.stopInterest(this.name, interestId);
     const interest = this.interests.get(interestId);
     this.#detachInterestObjects(interestId, interest);
     this.interests.delete(interestId);
+    if (!this.interests.size) {
+      this.#clearStateResyncTimers();
+    }
     interest?.closeLocal();
     interest?.emit('close');
   }
@@ -1097,7 +1109,7 @@ export class SenBus extends EventEmitter {
       }
     }
     try {
-      this.sen.client.leaveBus(this.name);
+      this.sen.client?.leaveBus(this.name);
     } catch (error) {
       this.sen.emit('warning', error);
     }
@@ -1117,6 +1129,7 @@ export class SenBus extends EventEmitter {
     this.typeRegistry.clear();
     this.requestedTypeHashes.clear();
     this.stateRequestedObjectIds.clear();
+    this.#clearStateResyncTimers();
     for (const interest of this.interests.values()) {
       interest.closeLocal();
       interest.objectsById.clear();
@@ -1158,8 +1171,25 @@ export class SenBus extends EventEmitter {
   handleObjectsPublished(event) {
     const newTypeHashes = new Set();
     for (const discovery of event.discoveries ?? []) {
+      const interest = this.interests.get(discovery.interestId);
+      if (interest && event.ownerId !== undefined) {
+        if (interest.ownerId !== undefined && interest.ownerId !== event.ownerId) {
+          this.#resetInterestForOwner(interest, event.ownerId);
+        } else {
+          interest.ownerId = event.ownerId;
+        }
+      }
+
       for (const info of discovery.objects ?? []) {
         let object = this.objectsById.get(info.id);
+        if (object && event.ownerId !== undefined && object.ownerId !== event.ownerId) {
+          this.#removeObjectFromAllInterests(object, {
+            reason: 'ownerChanged',
+            ownerId: event.ownerId,
+            previousOwnerId: object.ownerId
+          });
+          object = undefined;
+        }
         const isNewObject = !object;
         if (!object) {
           object = new SenRemoteObject(this, {
@@ -1175,26 +1205,22 @@ export class SenBus extends EventEmitter {
             ownerId: event.ownerId
           });
         }
-        const interest = this.interests.get(discovery.interestId);
         interest?.objectsById.set(object.id, object);
         if (info.state?.length) {
-          object.applyState(info.state, 'state', info.time, { interestId: discovery.interestId });
+          object.applyState(info.state, 'published', info.time, { interestId: discovery.interestId });
         }
         if (!this.requestedTypeHashes.has(info.typeHash)) {
           this.requestedTypeHashes.add(info.typeHash);
           newTypeHashes.add(info.typeHash);
         }
-        interest?.emit('object', object);
-        if (isNewObject) {
-          this.emit('object', object);
-          this.sen.emit('object', object);
-        }
+        this.#emitObjectWhenReady(interest, object, isNewObject);
       }
     }
     if (newTypeHashes.size) {
       this.sen.client.requestTypes(this.name, newTypeHashes);
     }
     this.#requestReadyObjectStates();
+    this.#scheduleStateResyncs();
   }
 
   handleObjectsRemoved(event) {
@@ -1202,18 +1228,8 @@ export class SenBus extends EventEmitter {
       for (const id of removal.ids ?? []) {
         const object = this.objectsById.get(id);
         const interest = this.interests.get(removal.interestId);
-        interest?.objectsById.delete(id);
-        this.stateRequestedObjectIds.delete(stateRequestKey(removal.interestId, id));
         if (object) {
-          object.detachInterest(removal.interestId);
-          object.emit('remove', { interestId: removal.interestId });
-          interest?.emit('remove', object);
-          if (object.interestIds.size === 0) {
-            this.objectsById.delete(id);
-            this.requestedTypeHashes.delete(object.typeHash);
-            this.emit('remove', object);
-            this.sen.emit('remove', object);
-          }
+          this.#removeObjectFromInterest(object, removal.interestId, interest);
         }
       }
     }
@@ -1233,13 +1249,74 @@ export class SenBus extends EventEmitter {
     }
 
     for (const object of interest.objectsById.values()) {
-      object.detachInterest(normalizedInterestId);
-      if (object.interestIds.size === 0) {
-        this.objectsById.delete(object.id);
-        this.requestedTypeHashes.delete(object.typeHash);
-      }
+      this.#removeObjectFromInterest(object, normalizedInterestId, interest);
+    }
+    interest.objectsById.clear();
+  }
+
+  #resetInterestForOwner(interest, ownerId) {
+    const previousOwnerId = interest.ownerId;
+    const detail = { reason: 'ownerChanged', ownerId, previousOwnerId };
+    for (const object of [...interest.objectsById.values()]) {
+      this.#removeObjectFromAllInterests(object, detail);
     }
     interest.objectsById.clear();
+    interest.ownerId = ownerId;
+    interest.resetLocal();
+    interest.emit('stale', detail);
+    this.emit('stale', { interest, ...detail });
+    this.sen.emit('stale', { bus: this, interest, ...detail });
+  }
+
+  #removeObjectFromAllInterests(object, detail = {}) {
+    for (const interestId of [...object.interestIds]) {
+      this.#removeObjectFromInterest(object, interestId, this.interests.get(interestId), detail);
+    }
+  }
+
+  #removeObjectFromInterest(object, interestId, interest, detail = {}) {
+    const normalizedInterestId = interestId >>> 0;
+    this.stateRequestedObjectIds.delete(stateRequestKey(normalizedInterestId, object.id));
+    interest?.objectsById.delete(object.id);
+    object.detachInterest(normalizedInterestId);
+    object.emit('remove', { interestId: normalizedInterestId, ...detail });
+    interest?.emit('remove', object);
+    if (object.interestIds.size === 0) {
+      this.objectsById.delete(object.id);
+      this.requestedTypeHashes.delete(object.typeHash);
+      this.emit('remove', object);
+      this.sen.emit('remove', object);
+    }
+  }
+
+  #emitObjectWhenReady(interest, object, emitGlobal) {
+    if (!interest) {
+      return;
+    }
+    const publish = () => {
+      if (!object.isReadyForInterest(interest.id)) {
+        return false;
+      }
+      if (object.markInterestObjectEmitted(interest.id)) {
+        interest.emit('object', object);
+      }
+      if (emitGlobal && object.markGlobalObjectEmitted()) {
+        this.emit('object', object);
+        this.sen.emit('object', object);
+      }
+      return true;
+    };
+
+    if (publish()) {
+      return;
+    }
+
+    const onReady = () => {
+      if (publish()) {
+        object.off('ready', onReady);
+      }
+    };
+    object.on('ready', onReady);
   }
 
   handleTypesInfoResponse(event) {
@@ -1267,13 +1344,14 @@ export class SenBus extends EventEmitter {
     }
     this.#retryPendingStates();
     this.#requestReadyObjectStates();
+    this.#scheduleStateResyncs();
   }
 
   handleObjectsStateResponse(event) {
     for (const response of event.responses ?? []) {
       for (const state of response.objectStates ?? []) {
         const object = this.objectsById.get(state.id);
-        if (!object) {
+        if (!object || (event.ownerId !== undefined && object.ownerId !== event.ownerId)) {
           continue;
         }
         object.applyState(state.state, 'state', state.timestamp, { interestId: response.interestId });
@@ -1354,7 +1432,8 @@ export class SenBus extends EventEmitter {
     });
   }
 
-  #requestReadyObjectStates() {
+  #requestReadyObjectStates(options = {}) {
+    const force = options.force === true;
     const requestsByInterest = new Map();
     for (const interest of this.interests.values()) {
       for (const object of interest.objectsById.values()) {
@@ -1362,7 +1441,7 @@ export class SenBus extends EventEmitter {
           continue;
         }
         const key = stateRequestKey(interest.id, object.id);
-        if (this.stateRequestedObjectIds.has(key)) {
+        if (!force && this.stateRequestedObjectIds.has(key)) {
           continue;
         }
         this.stateRequestedObjectIds.add(key);
@@ -1372,22 +1451,64 @@ export class SenBus extends EventEmitter {
       }
     }
 
-    if (requestsByInterest.size) {
-      this.sen.client.requestObjectStates(this.name, [...requestsByInterest].map(([interestId, objectIds]) => ({
-        interestId,
-        objectIds
-      })));
+    if (requestsByInterest.size && this.sen.client) {
+      try {
+        this.sen.client.requestObjectStates(this.name, [...requestsByInterest].map(([interestId, objectIds]) => ({
+          interestId,
+          objectIds
+        })));
+      } catch (error) {
+        this.sen.emit('warning', error);
+      }
+    }
+  }
+
+  #scheduleStateResyncs() {
+    if (!this.interests.size || this.stateResyncTimers.size) {
+      return;
+    }
+
+    for (const delayMs of STATE_RESYNC_DELAYS_MS) {
+      const timer = setTimeout(() => {
+        this.stateResyncTimers.delete(timer);
+        try {
+          this.#requestReadyObjectStates({ force: true });
+        } catch (error) {
+          this.sen.emit('warning', error);
+        }
+      }, delayMs);
+      timer.unref?.();
+      this.stateResyncTimers.add(timer);
+    }
+    const interval = setInterval(() => {
+      try {
+        this.#requestReadyObjectStates({ force: true });
+      } catch (error) {
+        this.sen.emit('warning', error);
+      }
+    }, STATE_RESYNC_INTERVAL_MS);
+    interval.unref?.();
+    this.stateResyncInterval = interval;
+    this.stateResyncTimers.add(interval);
+  }
+
+  #clearStateResyncTimers() {
+    for (const timer of this.stateResyncTimers) {
+      clearTimeout(timer);
     }
+    this.stateResyncTimers.clear();
+    this.stateResyncInterval = undefined;
   }
 
   #retryPendingStates() {
     for (const object of this.objectsById.values()) {
-      if (object.pendingState) {
+      const pendingStates = object.pendingStates.splice(0);
+      for (const pendingState of pendingStates) {
         object.applyState(
-          object.pendingState.buffer,
-          object.pendingState.source,
-          object.pendingState.timestampNs,
-          { interestId: object.pendingState.interestId }
+          pendingState.buffer,
+          pendingState.source,
+          pendingState.timestampNs,
+          { interestId: pendingState.interestId }
         );
       }
     }
@@ -1400,6 +1521,7 @@ export class SenInterest extends EventEmitter {
     this.bus = bus;
     this.id = id;
     this.query = query;
+    this.ownerId = undefined;
     this.options = { ...options };
     this.propertyNames = normalizePropertyNames(options.properties ?? options.propertyNames);
     this.changeMode = options.changeMode ?? (options.batch ? 'batch' : 'individual');
@@ -1491,7 +1613,12 @@ export class SenRemoteObject extends EventEmitter {
     }
     this.snapshot = {};
     this.spec = undefined;
+    this.typePromise = undefined;
     this.pendingState = undefined;
+    this.pendingStates = [];
+    this.readyInterestIds = new Set();
+    this.emittedInterestObjectIds = new Set();
+    this.emittedGlobalObject = false;
     this.timestamp = undefined;
     this.timestampNs = undefined;
     this.lastStateTimestamp = undefined;
@@ -1520,7 +1647,10 @@ export class SenRemoteObject extends EventEmitter {
 
   detachInterest(interestId) {
     if (interestId !== undefined) {
-      this.interestIds.delete(interestId);
+      const normalizedInterestId = interestId >>> 0;
+      this.interestIds.delete(normalizedInterestId);
+      this.readyInterestIds.delete(normalizedInterestId);
+      this.emittedInterestObjectIds.delete(normalizedInterestId);
       if (this.interestId === interestId) {
         this.interestId = this.interestIds.values().next().value;
       }
@@ -1552,18 +1682,38 @@ export class SenRemoteObject extends EventEmitter {
     }
 
     const timeoutMs = options.timeout ?? 3000;
-    return await new Promise((resolve, reject) => {
-      const timeout = setTimeout(() => {
-        this.off('type', onType);
-        reject(new Error(`timeout waiting for SEN type ${this.className}`));
-      }, timeoutMs);
+    let timeout;
+    try {
+      return await Promise.race([
+        this.#waitForTypeReady(),
+        new Promise((_, reject) => {
+          timeout = setTimeout(() => {
+            reject(new Error(`timeout waiting for SEN type ${this.className}`));
+          }, timeoutMs);
+          timeout.unref?.();
+        })
+      ]);
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+
+  #waitForTypeReady() {
+    if (this.spec) {
+      return Promise.resolve(this.spec);
+    }
+    if (this.typePromise) {
+      return this.typePromise;
+    }
+    this.typePromise = new Promise(resolve => {
       const onType = spec => {
-        clearTimeout(timeout);
         this.off('type', onType);
+        this.typePromise = undefined;
         resolve(spec);
       };
       this.on('type', onType);
     });
+    return this.typePromise;
   }
 
   async get(name) {
@@ -1574,6 +1724,27 @@ export class SenRemoteObject extends EventEmitter {
     return this.propertyTimestamps.get(name);
   }
 
+  isReadyForInterest(interestId) {
+    return this.readyInterestIds.has(interestId >>> 0);
+  }
+
+  markInterestObjectEmitted(interestId) {
+    const normalizedInterestId = interestId >>> 0;
+    if (this.emittedInterestObjectIds.has(normalizedInterestId)) {
+      return false;
+    }
+    this.emittedInterestObjectIds.add(normalizedInterestId);
+    return true;
+  }
+
+  markGlobalObjectEmitted() {
+    if (this.emittedGlobalObject) {
+      return false;
+    }
+    this.emittedGlobalObject = true;
+    return true;
+  }
+
   async set(name, value, options = {}) {
     await this.waitForType(options);
     const property = this.property(name);
@@ -1612,7 +1783,7 @@ export class SenRemoteObject extends EventEmitter {
     this.#rememberObjectTimestamp(source, timestampNs);
 
     if (!this.spec) {
-      this.pendingState = { buffer, source, timestampNs, interestId: options.interestId };
+      this.#queuePendingState({ buffer, source, timestampNs, interestId: options.interestId });
       return;
     }
 
@@ -1652,7 +1823,32 @@ export class SenRemoteObject extends EventEmitter {
       }
     }
 
-    this.pendingState = complete ? undefined : { buffer, source, timestampNs, interestId: options.interestId };
+    if (complete) {
+      if (source === 'state') {
+        this.#markReady(options.interestId);
+      }
+      if (!this.pendingStates.length) this.pendingState = undefined;
+    } else {
+      this.#queuePendingState({ buffer, source, timestampNs, interestId: options.interestId });
+    }
+  }
+
+  #markReady(interestId) {
+    if (interestId !== undefined) {
+      const normalizedInterestId = interestId >>> 0;
+      this.readyInterestIds.add(normalizedInterestId);
+      this.emit('ready', { interestId: normalizedInterestId });
+      return;
+    }
+    for (const id of this.interestIds) {
+      this.readyInterestIds.add(id >>> 0);
+      this.emit('ready', { interestId: id >>> 0 });
+    }
+  }
+
+  #queuePendingState(state) {
+    this.pendingStates.push(state);
+    this.pendingState = state;
   }
 
   #targetInterests(interestId) {

package/package.json

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