Allow requesting a secondary link from a session.

This is provided for Surfer integration.

Author: whitequark

src/cxxrtl/client.ts

@@ -84,7 +84,7 @@ export class Connection {
                 this._events = packet.events;
                 this._itemValuesEncodings = packet.features.item_values_encoding;
                 this._state = ConnectionState.Connected;
-                await this.onConnected();
+                await this.onConnected(packet);
             } else {
                 this.rejectPromises(new Error(`unexpected CXXRTL protocol version ${packet.version}`));
             }
@@ -119,14 +119,14 @@ export class Connection {
         }
     }
 
-    private async perform(command: proto.AnyCommand): Promise<proto.AnyResponse> {
+    async perform(command: proto.AnyCommand): Promise<proto.AnyResponse> {
         await this.send(command);
         return new Promise((resolve, reject) => {
             this.promises.push({ resolve, reject });
         });
     }
 
-    async onConnected(): Promise<void> {}
+    async onConnected(greetingPacket: proto.ServerGreeting): Promise<void> {}
 
     async onDisconnected(): Promise<void> {}
 

src/debug/session.ts

@@ -35,9 +35,23 @@ export interface ISimulationStatus {
 export class Session {
     private connection: Connection;
 
+    private secondaryLinks: ILink[] = [];
+    private greetingPacketPromise: Promise<proto.ServerGreeting>;
+
     constructor(link: ILink) {
         this.connection = new Connection(link);
+        this.greetingPacketPromise = new Promise((resolve, _reject) => {
+            this.connection.onConnected = async (greetingPacket) => resolve(greetingPacket);
+        });
+        this.connection.onDisconnected = async () => {
+            for (const secondaryLink of this.secondaryLinks) {
+                secondaryLink.onDone();
+            }
+        };
         this.connection.onEvent = async (event) => {
+            for (const secondaryLink of this.secondaryLinks) {
+                secondaryLink.onRecv(event);
+            }
             if (event.event === 'simulation_paused' || event.event === 'simulation_finished') {
                 await this.querySimulationStatus();
             }
@@ -49,6 +63,35 @@ export class Session {
         this.connection.dispose();
     }
 
+    createSecondaryLink(): ILink {
+        const link: ILink = {
+            dispose: () => {
+                this.secondaryLinks.splice(this.secondaryLinks.indexOf(link));
+            },
+
+            send: async (clientPacket) => {
+                if (clientPacket.type === 'greeting') {
+                    const serverGreetingPacket = await this.greetingPacketPromise;
+                    if (clientPacket.version === serverGreetingPacket.version) {
+                        await link.onRecv(serverGreetingPacket);
+                    } else {
+                        throw new Error(
+                            `Secondary link requested greeting version ${clientPacket.version}, ` +
+                            `but server greeting version is ${serverGreetingPacket.version}`
+                        );
+                    }
+                } else {
+                    const serverPacket = await this.connection.perform(clientPacket);
+                    await link.onRecv(serverPacket);
+                }
+            },
+
+            onRecv: async (serverPacket) => {},
+            onDone: async () => {},
+        };
+        return link;
+    }
+
     // ======================================== Inspecting the design
 
     private itemCache: Map<string, proto.ItemDescriptionMap> = new Map();