Polite protocol, ref #8

__tests__/polite.test.ts

@@ -0,0 +1,34 @@
+import { Meet } from "../src/messages.js";
+import { BasicMessageForwarder } from "../src/node.js";
+import { Polite } from "../src/polite.js";
+
+class PoliteNode extends Polite {
+    onMeet(other: string): void {
+        this.sendMessage(other, new Meet());
+      }
+    handleMeetMessage(): void {}
+    handleProbeMessage(): void {}
+    handleLoopMessage(): void {}
+    sendTestMessage(to: string): void {
+      this.sendMessage(to, { getMessageType: () => 'test', toString: () => 'test' });
+    }
+}
+describe('Polite', () => {
+    it('[FIXME: fails!] queues messages when listening', () => {
+      const messageForwarder = new BasicMessageForwarder();
+      const alice = new PoliteNode('Alice', messageForwarder);
+      const bob = new PoliteNode('Bob', messageForwarder);
+      alice.meet(bob);
+      expect(alice.getFriends()).toEqual(['Bob']);
+      expect(bob.getFriends()).toEqual(['Alice']);
+      alice.sendTestMessage('Bob');
+      bob.sendTestMessage('Alice');
+      alice.sendTestMessage('Bob');
+      expect(messageForwarder.getFullLog()).toEqual([
+        "[Alice]->[Bob] meet",
+        "[Alice]->[Bob] test",
+        "[Bob]->[Alice] test",
+        "[Alice]->[Bob] test",
+      ]);
+    });
+});

jest.config.js

@@ -7,7 +7,7 @@ export default {
   moduleNameMapper: {
     '^(\\.{1,2}/.*)\\.(m)?js$': '$1',
   },
-  testRegex: '(/__tests__/self-mending-for-squid-triangle.test.ts$)',
+  testRegex: '(/__tests__/polite.test.ts$)',
   coverageDirectory: 'coverage',
   collectCoverageFrom: [
     'src/**/*.ts',

src/messages.ts

@@ -21,6 +21,15 @@ export class RaiseHand extends Message {
   }
 }
 
+export class OverToYou extends Message {
+  getMessageType(): string {
+    return 'over-to-you';
+  }
+  toString(): string {
+    return 'over-to-you';
+  }
+}
+
 export class Probe extends Message {
   private id: string;
   constructor(id: string) {

src/polite.ts

@@ -0,0 +1,46 @@
+import { Message, OverToYou, RaiseHand } from './messages.js';
+import { Node, BasicMessageForwarder } from "./node.js";
+
+export abstract class Polite extends Node {
+  constructor(name: string, messageForwarder?: BasicMessageForwarder) {
+    super(name, messageForwarder);
+  }
+
+  private raiseHand(to: string): void {
+    this.messageForwarder.forwardMessage(this, this.friends[to].node, new RaiseHand());
+  }
+  private handleRaiseHand(from: string): void {
+    this.friends[from].talking = false;
+    this.sendMessage(from, new OverToYou());
+  }
+  private handleOverToYouMessage(from: string): void {
+    this.friends[from].talking = true;
+    while (this.friends[from].outbox.length > 0) {
+      const message = this.friends[from].outbox.shift();
+      this.sendMessage(from, message);
+    }
+  }
+
+  protected sendMessage(to: string, message: Message): void {
+    if(this.friends[to].talking) {
+      this.messageForwarder.forwardMessage(this, this.friends[to].node, message);
+    } else {
+      this.friends[to].outbox.push(message);
+      this.raiseHand(to);
+    }
+  }
+  receiveMessage(sender: Node, message: Message): void {
+    // console.log(`${this.name} receives message from ${sender}`, message);
+    if (message.getMessageType() === `raise-hand`) {
+      this.messageForwarder.logMessageReceived(sender.getName(), this.getName(), message);
+      this.handleRaiseHand(sender.getName());
+    } else if (message.getMessageType() === `over-to-you`) {
+      this.handleOverToYouMessage(sender.getName());
+    } else {
+      super.receiveMessage(sender, message);
+    }
+  }
+  getMessageLog(): string[] {
+    return this.messageForwarder.getLocalLog(this.name);
+  }
+}