wip: handling connection events

Still need to hook stream events to the RPC handlers.

[ci skip]

Author: tegefaulkes

src/nodes/NodeConnectionManager.ts

@@ -17,8 +17,7 @@ import type {
 } from './types';
 import type KeyRing from '../keys/KeyRing';
 import type { Key, CertificatePEM } from '../keys/types';
-import type { Host, Hostname, Port } from '../network/types';
-import type { RPCStream } from '../rpc/types';
+import type { ConnectionData, Host, Hostname, Port } from '../network/types';
 import type { TLSConfig } from '../network/types';
 import type { HolePunchRelayMessage } from '../agent/handlers/types';
 import Logger from '@matrixai/logger';
@@ -849,7 +848,8 @@ class NodeConnectionManager {
     //  The connection event should only contain connection metadata and not the connection itself otherwise we circumvent the locking.
     // Setting up events
     const nodeConnectionEventsHandler = (e) => {
-      console.log(e);
+      // Propagate all events upwards
+      this.dispatchEvent(e.clone());
     };
     nodeConnection.addEventListener(nodeConnectionEventsHandler);
     nodeConnection.addEventListener(
@@ -883,6 +883,16 @@ class NodeConnectionManager {
       usageCount: 0,
     };
     this.connections.set(nodeIdString, newConnAndTimer);
+    const connectionData: ConnectionData = {
+      remoteNodeId: nodeConnection.nodeId,
+      remoteHost: nodeConnection.host,
+      remotePort: nodeConnection.port,
+    };
+    this.dispatchEvent(
+      new nodesEvents.EventNodeConnectionManagerConnection({
+        detail: connectionData,
+      }),
+    );
     return newConnAndTimer;
   }
 

src/nodes/NodeManager.ts

@@ -37,6 +37,7 @@ import { IdInternal } from '@matrixai/id';
 import { timedCancellable, context } from '@matrixai/contexts/dist/decorators';
 import * as nodesErrors from './errors';
 import * as nodesUtils from './utils';
+import * as nodesEvents from './events';
 import * as claimsUtils from '../claims/utils';
 import * as tasksErrors from '../tasks/errors';
 import * as claimsErrors from '../claims/errors';
@@ -190,6 +191,15 @@ class NodeManager {
   public readonly checkSeedConnectionsHandlerId: TaskHandlerId =
     `${this.basePath}.${this.checkSeedConnectionsHandler.name}.checkSeedConnectionsHandler` as TaskHandlerId;
 
+  handleNodeConnectionEvent = (
+    e: nodesEvents.EventNodeConnectionManagerConnection,
+  ) => {
+    this.setNode(e.detail.remoteNodeId, {
+      host: e.detail.remoteHost,
+      port: e.detail.remotePort,
+    });
+  };
+
   constructor({
     db,
     keyRing,
@@ -259,11 +269,21 @@ class NodeManager {
       lazy: true,
       path: [this.basePath, this.checkSeedConnectionsHandlerId],
     });
+    // Add handling for connections
+    this.nodeConnectionManager.addEventListener(
+      nodesEvents.EventNodeConnectionManagerConnection.name,
+      this.handleNodeConnectionEvent,
+    );
     this.logger.info(`Started ${this.constructor.name}`);
   }
 
   public async stop() {
     this.logger.info(`Stopping ${this.constructor.name}`);
+    // Remove handling for connections
+    this.nodeConnectionManager.removeEventListener(
+      nodesEvents.EventNodeConnectionManagerConnection.name,
+      this.handleNodeConnectionEvent,
+    );
     this.logger.info('Cancelling ephemeral tasks');
     if (this.taskManager.isProcessing()) {
       throw new tasksErrors.ErrorTaskManagerProcessing();

src/nodes/events.ts

@@ -1,4 +1,5 @@
 import type { QUICStream } from '@matrixai/quic';
+import type { ConnectionData } from '@/network/types';
 
 type OptDetail<T> = T extends undefined ? {} : { detail: T };
 
@@ -36,4 +37,18 @@ class EventNodeStream extends EventsNode<QUICStream> {
   }
 }
 
-export { EventNodeConnectionDestroy, EventNodeStream };
+abstract class EventNodeConnectionManager<
+  T = undefined,
+> extends EventsNode<T> {}
+
+class EventNodeConnectionManagerConnection extends EventNodeConnectionManager<ConnectionData> {
+  constructor(options?: EventInit & { detail: ConnectionData }) {
+    super(EventNodeConnectionManagerConnection.name, options);
+  }
+}
+
+export {
+  EventNodeConnectionDestroy,
+  EventNodeStream,
+  EventNodeConnectionManagerConnection,
+};