test

config/config.json

+{
+  "port": 500,
+  "timeout": 10,
+  "interval": 1000
+}

config/routers.json

+[
+  { "id": 1, "inbound_cost": 0, "outbound_cost": 1 },
+  { "id": 3, "inbound_cost": 0, "outbound_cost": 1 },
+  { "id": 7, "inbound_cost": 0, "outbound_cost": 1 },
+  { "id": 9, "inbound_cost": 0, "outbound_cost": 1 }
+]

package.json

 {
-  "name": "application-name",
+  "name": "railgun-routing-server",
   "version": "0.0.1",
-  "devDependencies": {
-    "@types/node": "^14.14.19"
-  },
+  "author": "zh99998 <zh99998@gmail.com>",
   "dependencies": {
+    "lodash": "^4.17.21"
+  },
+  "devDependencies": {
     "@types/lodash": "^4.14.172",
-    "lodash": "^4.17.21",
-    "ts-node": "^9.1.1",
-    "typescript": "^4.1.3"
+    "@types/node": "^16.6.1",
+    "ts-node": "^10.2.0",
+    "typescript": "^4.3.5"
   }
 }

protocol.ts

+// 这个文件两端共用
+
+export interface PeerQuality {
+  delay: number;
+  jitter: number;
+  reliability: number;
+}
+
+// 路由器向中心服务器发送的消息
+export interface UploadMessage {
+  id: number; // router id
+  ack: number;
+  peers?: Record<number, PeerQuality>;
+}
+
+// 中心服务器向路由器发送的消息
+export interface DownloadMessage {
+  seq: number,
+  to: number,
+  via: number;
+}
+
+// 路由器向路由器发送的消息
+export interface PeerMessage {
+  id: number;
+  seq: number;
+  time: number;
+}

servers.json

-[
-  { "id": 2, "inbound_cost": 0, "outbound_cost": 0.8 },
-  { "id": 3, "inbound_cost": 0, "outbound_cost": 0.05 },
-  { "id": 4, "inbound_cost": 0, "outbound_cost": 0.03 },
-  { "id": 6, "inbound_cost": 0, "outbound_cost": 0.8 },
-  { "id": 7, "inbound_cost": 0, "outbound_cost": 1 }
-]

src/Router.ts

 import { RemoteInfo } from 'dgram';
-import { PeerQuality } from './protocol';
-import servers from '../servers.json';
+import { PeerQuality } from '../protocol';
+import routers from '../config/routers.json';
 import assert from 'assert';
 import { Quality } from './Quality';
 
 export class Router {
-  static all: Router[] = servers.map(s => Object.assign(new Router(), s));
+  static all: Router[] = routers.map(s => Object.assign(new Router(), s));
 
   // config
   id!: number;
   inbound_cost!: number;
   outbound_cost!: number;
 
-  //report
+  seq = 0;
   peers: Record<number, PeerQuality> = {};
+  via: Map<Router, Router> = new Map();
 
-  // routing
-  next_hop: Map<Router, Router> = new Map();
   rinfo?: RemoteInfo;
 
   reset() {
+    this.seq = 0;
     this.peers = {};
     for (const router of Router.all) {
-      this.next_hop.set(router, router);
+      this.via.set(router, router);
     }
   }
 
   lost() {
+    this.seq = 0;
     this.rinfo = undefined;
     return console.log(`router ${this.id} lost connection.`);
   }
 
-  route_quality(to: Router, next_hop = this.next_hop.get(to)!) {
-    assert(next_hop != null);
-    assert(this !== next_hop);
+  route_quality(to: Router, via = this.via.get(to)!) {
+    assert(via != null);
+    assert(this !== via);
     assert(this !== to);
 
     const result = new Quality();
 
     let current: Router = this;
-    let next = next_hop;
+    let next = via;
     const route = [current, next];
 
     while (true) {
@@ -50,7 +51,7 @@ export class Router {
 
       // 寻找下一跳
       current = next;
-      next = current.next_hop.get(to)!;
+      next = current.via.get(to)!;
       assert(next); //to server_id 型路由，由于 server 两两相连，下一跳一定是存在的，至少能直达
       if (route.includes(next)) {
         // 环路

src/main.ts

 import dgram from 'dgram';
 import http from 'http';
-import peers from '../servers.json';
-import { ServerMessage } from './protocol';
+
+import { DownloadMessage, UploadMessage } from '../protocol';
 import assert from 'assert';
 import { Router } from './Router';
 import _ from 'lodash';
 
-const server_port = 495;
-const timeout = 10;
+import config from '../config/config.json';
 
-let sequence = 0;
 let updating: any = null;
 let timeout_timer: any = null;
 
-export function send_route(router: Router, to: Router, next_hop: Router) {
-  const message = { sequence, to: to.id, next_hop: next_hop.id };
-  return socket.send(JSON.stringify(message), router.rinfo!.port, router.rinfo!.address);
+export function send_route(from: Router, to: Router, via: Router) {
+  const message: DownloadMessage = { seq: from.seq, to: to.id, via: via.id };
+  return socket.send(JSON.stringify(message), from.rinfo!.port, from.rinfo!.address);
 }
 
-
 const socket = dgram
   .createSocket('udp4')
   .on('message', function(message, rinfo) {
     try {
-      const hello: ServerMessage = JSON.parse(message.toString());
+      const hello: UploadMessage = JSON.parse(message.toString());
 
       assert(hello.id);
       const router: Router = Router.all.find(r => r.id === hello.id)!;
       assert(router);
 
-      if (_.isEqual(rinfo, router.rinfo)) {
-        router.rinfo = rinfo;
+      router.rinfo = rinfo;
+
+      if (hello.ack === 0) {
         router.reset();
       }
 
-      router.peers = hello.peers;
+      if (hello.peers) router.peers = hello.peers;
 
       if (updating) {
-        if (hello.ack === sequence) {
+        if (hello.ack === router.seq + 1) {
           clearInterval(updating);
           clearTimeout(timeout_timer);
           updating = null;
-          sequence++;
+          router.seq++;
         }
         return;
       }
@@ -55,28 +53,27 @@ const socket = dgram
         const best_route = _.minBy(Router.all.filter(router => router.id !== from.id), (router) => from.route_quality(to, router).metric())!;
 
         // 变更
-        if (from.next_hop.get(to) !== best_route) {
-          from.next_hop.set(to, best_route);
-          updating = setInterval(() => send_route(from, to, best_route), 1000);
+        if (from.via.get(to) !== best_route) {
+          from.via.set(to, best_route);
+          updating = setInterval(() => send_route(from, to, best_route), config.interval);
           send_route(from, to, best_route);
           timeout_timer = setTimeout(function() {
             from.lost();
             clearInterval(updating);
             updating = null;
-          }, timeout * 1000);
+          }, config.timeout * config.interval);
           return;
         }
       }
     }
   });
-socket.bind(server_port);
+socket.bind(config.port);
 
 //web management api
 http
   .createServer(function(req, res) {
     res.writeHead(200, { 'Content-Type': 'application/json' });
-    return res.end(JSON.stringify(peers));
+    const result: Record<number, Record<number, number>> = Object.fromEntries(Router.all.map(from => [from.id, Object.fromEntries([...from.via.entries()].map(([to, via]) => [to.id, via.id]))]));
+    return res.end(JSON.stringify(result));
   })
-  .listen(server_port);
-
-// setInterval(refresh(socket, routers), 1000)
+  .listen(config.port);

src/protocol.ts

-export interface PeerQuality {
-  delay: number;
-  jitter: number;
-  reliability: number;
-}
-
-export interface ServerMessage {
-  id: number;
-  ack: number;
-  peers: PeerQuality[];
-}