Add dummy proxy (#21)

* Add proxy forwarding with dummy

* Fix: two-way forwarding in dummy

Author: tolauwae

src/framework/Testee.ts

@@ -97,7 +97,7 @@ export class Testee { // TODO unified with testbed interface
                 if (proxy) {
                     this.proxy = proxy;
                     await this.proxy.sendRequest(new SourceMap.Mapping(), Message.proxifyRequest);
-                    args = args.concat(['--proxy', `${spec.options.port}`]);
+                    args = args.concat(['--proxy', `${spec.dummy.port}`]);
                 }
             }
 

src/manage/Uploader.ts

@@ -39,6 +39,7 @@ export class UploaderFactory {
                 return new ArduinoUploader(this.arduino, args, specification.options as SerialOptions);
             case PlatformType.emulator:
             case PlatformType.emu2emu:
+            case PlatformType.emuproxy:
                 return new EmulatorUploader(this.emulator, args, specification.options as SubprocessOptions);
             case PlatformType.debug:
                 return new EmulatorConnector(specification.options as SubprocessOptions)

src/messaging/MessageQueue.ts

@@ -32,7 +32,7 @@ export class MessageQueue implements Iterable<string> {
         return last !== undefined && !last.includes(this.delimiter);
     }
 
-    private hasCompleteMessage(): boolean {
+    public hasCompleteMessage(): boolean {
         return this.queue.length > 0 && (!this.lastMessageIncomplete() || this.queue.length > 1);
     }
 

src/testbeds/Emulator.ts

@@ -1,5 +1,15 @@
 import {Platform} from './Platform';
 import {SubProcess} from '../bridge/SubProcess';
+import {Connection} from '../bridge/Connection';
+import {UploaderFactory} from '../manage/Uploader';
+import {ARDUINO, EMULATOR} from '../util/env';
+import {ProxySpecification} from './TestbedSpecification';
+import {CompileOutput} from '../manage/Compiler';
+import * as net from 'node:net';
+import {SourceMap} from '../sourcemap/SourceMap';
+import {Request} from '../messaging/Message';
+import {AddressInfo, Socket} from 'node:net';
+import {MessageQueue} from '../messaging/MessageQueue';
 
 export class Emulator extends Platform {
     readonly name: string = 'Emulator';
@@ -18,3 +28,54 @@ export class Emulator extends Platform {
         return super.kill();
     }
 }
+
+/**
+ * Dummy proxy object, forwards all requests on a dummy port to the real proxy instance
+ *
+ * todo this allows for testing the communication between supervisor and proxy
+ */
+export class DummyProxy extends Emulator {
+    dummy: net.Server;
+
+    protected forwarding: MessageQueue;
+
+    private supervisor?: Socket;
+
+    constructor(connection: SubProcess) {
+        super(connection);
+
+        this.forwarding = new MessageQueue('\n');
+
+        this.dummy = new net.Server();
+    }
+
+    public async init(specification: ProxySpecification) {
+        this.dummy.on('connection', (connection) => {
+            this.supervisor = connection;
+            connection.on('data', (data) => {
+                this.connection.channel.write(data.toString());
+            })
+        });
+        this.dummy.listen(specification.dummy.port);
+    }
+
+    protected listen(): void {
+        this.connection.channel.on('data', (data: Buffer) => {
+            if (this.waitingForMessages()) {
+                this.messages.push(data.toString());
+                this.process();
+            } else {
+                this.forwarding.push(data.toString());
+                while (this.forwarding.hasCompleteMessage()) {
+                    const message = this.forwarding.pop()
+                    if(!message?.includes('Interrupt')) this.supervisor!.write(message!.toString());
+                }
+
+            }
+        });
+    }
+
+    private waitingForMessages(): boolean {
+        return this.requests.length > 0;
+    }
+}

src/testbeds/TestbedFactory.ts

@@ -1,13 +1,13 @@
 import {Testbed} from './Testbed';
 import {ARDUINO, EMULATOR, WABT} from '../util/env';
 import {CompileOutput, CompilerFactory} from '../manage/Compiler';
-import {Emulator} from './Emulator';
+import {DummyProxy, Emulator} from './Emulator';
 import {UploaderFactory} from '../manage/Uploader';
 import {Connection} from '../bridge/Connection';
 import {Arduino} from './Arduino';
 import {Serial} from '../bridge/Serial';
 import {SubProcess} from '../bridge/SubProcess';
-import {TestbedSpecification, PlatformType} from './TestbedSpecification';
+import {PlatformType, ProxySpecification, TestbedSpecification} from './TestbedSpecification';
 
 export class TestbedFactory {
     public readonly timeout: number;
@@ -31,6 +31,10 @@ export class TestbedFactory {
             case PlatformType.emu2emu:
             case PlatformType.debug:
                 return new Emulator(connection as SubProcess);
+            case PlatformType.emuproxy:
+                const dummy = new DummyProxy(connection as SubProcess);
+                await dummy.init(specification as ProxySpecification);
+                return dummy;
             default:
                 return Promise.reject('Platform not implemented.');
         }

src/testbeds/TestbedSpecification.ts

@@ -2,6 +2,7 @@ export enum PlatformType {
     arduino,
     emulator,
     emu2emu,
+    emuproxy,
     debug
 }
 
@@ -33,11 +34,11 @@ export class OutofPlaceSpecification implements TestbedSpecification {
     public readonly type: PlatformType = PlatformType.emu2emu;
     public readonly options: SupervisorOptions;
 
-    public readonly proxy: EmulatorSpecification;
+    public readonly proxy: ProxySpecification;
 
-    constructor(supervisor: number, proxy: number) {
+    constructor(supervisor: number, proxy: number, dummy: number = proxy + 1) {
         this.options = {port: supervisor, proxy: proxy};
-        this.proxy = new EmulatorSpecification(proxy);
+        this.proxy = new ProxySpecification(proxy, dummy);
     }
 }
 
@@ -51,6 +52,14 @@ export class EmulatorSpecification implements TestbedSpecification {
     }
 }
 
+export class ProxySpecification extends EmulatorSpecification {
+    public readonly dummy: SubprocessOptions;
+    constructor(port: number, dummy: number) {
+        super(port, PlatformType.emuproxy);
+        this.dummy = {port: dummy};
+    }
+}
+
 export class ArduinoSpecification implements TestbedSpecification {
     public readonly type: PlatformType;
     public readonly options: SerialOptions;