sen-ether-client 0.1.4 → 0.1.6

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);
 }
@@ -159,17 +166,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 {
@@ -367,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
@@ -605,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);
   }
 
@@ -624,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();
@@ -785,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.4",
+  "version": "0.1.6",
   "description": "Pure JavaScript SEN client for existing kernels over ether",
   "senCompatibility": {
     "kernelProtocolVersion": 9,