@streamr/dht 0.0.1-tatum.0

package/src/connection/Simulator/Simulator.ts

@@ -0,0 +1,399 @@
+/* eslint-disable @typescript-eslint/parameter-properties */
+import EventEmitter from 'eventemitter3'
+import { PeerIDKey } from '../../helpers/PeerID'
+import { PeerDescriptor } from '../../proto/packages/dht/protos/DhtRpc'
+import { ConnectionSourceEvents } from '../IConnectionSource'
+import { SimulatorConnector } from './SimulatorConnector'
+import { SimulatorConnection } from './SimulatorConnection'
+import { ConnectionID } from '../IConnection'
+import { Logger } from '@streamr/utils'
+import { getRegionDelayMatrix } from './pings'
+import { keyFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
+import Heap from 'heap'
+import { debugVars } from '../../helpers/debugHelpers'
+import * as sinon from 'sinon'
+
+const logger = new Logger(module)
+
+export enum LatencyType { NONE = 'NONE', RANDOM = 'RANDOM', REAL = 'REAL', FIXED = 'FIXED' }
+
+// One-way 'pipe' of messages
+
+class Association {
+    public sourceConnection: SimulatorConnection
+    public destinationConnection?: SimulatorConnection
+    private lastOperationAt: number = 0
+    private closing = false
+
+    constructor(sourceConnection: SimulatorConnection,
+        destinationConnection?: SimulatorConnection,
+        public connectedCallback?: (error?: string) => void
+    ) {
+        this.sourceConnection = sourceConnection
+        this.destinationConnection = destinationConnection
+    }
+
+    public setDestinationConnection(connection: SimulatorConnection) {
+        this.destinationConnection = connection
+    }
+
+    public getLastOperationAt(): number {
+        return this.lastOperationAt
+    }
+
+    public setLastOperationAt(executionTime: number): void {
+        this.lastOperationAt = executionTime
+    }
+
+    public setClosing(): void {
+        this.closing = true
+    }
+
+    public isClosing(): boolean {
+        return this.closing
+    }
+}
+
+class SimulatorOperation {
+    private static objectCounter = 0
+    public objectId = 0
+
+    constructor(
+        public executionTime: number,
+        public association: Association
+    ) {
+        this.objectId = SimulatorOperation.objectCounter
+        SimulatorOperation.objectCounter++
+    }
+}
+
+class ConnectOperation extends SimulatorOperation {
+    constructor(
+        executionTime: number,
+        association: Association,
+        public sourceConnection: SimulatorConnection,
+        public targetDescriptor: PeerDescriptor) {
+
+        super(executionTime, association)
+    }
+}
+
+class SendOperation extends SimulatorOperation {
+    constructor(
+        executionTime: number,
+        association: Association,
+        public data: Uint8Array
+    ) {
+        super(executionTime, association)
+    }
+}
+
+class CloseOperation extends SimulatorOperation {
+}
+
+export class Simulator extends EventEmitter<ConnectionSourceEvents> {
+    private stopped = false
+    private connectors: Map<PeerIDKey, SimulatorConnector> = new Map()
+    private latencyTable?: Array<Array<number>>
+    private associations: Map<ConnectionID, Association> = new Map()
+
+    private latencyType: LatencyType
+    private fixedLatency?: number
+
+    private loopCounter = 0
+    private operationCounter = 0
+    private MAX_LOOPS = 1000
+
+    private operationQueue: Heap<SimulatorOperation> = new Heap<SimulatorOperation>((a: SimulatorOperation, b: SimulatorOperation) => {
+        if ((a.executionTime - b.executionTime) === 0) {
+            return (a.objectId - b.objectId)
+        } else {
+            return (a.executionTime - b.executionTime)
+        }
+    })
+
+    private simulatorTimeout?: NodeJS.Timeout
+    private static clock: sinon.SinonFakeTimers | undefined
+
+    static useFakeTimers(on = true): void {
+        if (on) {
+            if (!Simulator.clock) {
+                Simulator.clock = sinon.useFakeTimers()
+            }
+        } else {
+            if (Simulator.clock) {
+                Simulator.clock.restore()
+                Simulator.clock = undefined
+            }
+        }
+    }
+
+    constructor(latencyType: LatencyType = LatencyType.NONE, fixedLatency?: number) {
+        super()
+
+        this.latencyType = latencyType
+        this.fixedLatency = fixedLatency
+
+        if (this.latencyType === LatencyType.REAL) {
+            this.latencyTable = getRegionDelayMatrix()
+        }
+
+        if (this.latencyType === LatencyType.FIXED && !this.fixedLatency) {
+            throw new Error('LatencyType.FIXED requires the desired latency to be given as second parameter')
+        }
+
+        this.generateExecutionTime = this.generateExecutionTime.bind(this)
+        this.getLatency = this.getLatency.bind(this)
+        this.executeCloseOperation = this.executeCloseOperation.bind(this)
+        this.executeConnectOperation = this.executeConnectOperation.bind(this)
+        this.executeSendOperation = this.executeSendOperation.bind(this)
+        this.executeQueuedOperations = this.executeQueuedOperations.bind(this)
+        this.accept = this.accept.bind(this)
+        this.send = this.send.bind(this)
+        this.close = this.close.bind(this)
+        this.scheduleNextTimeout = this.scheduleNextTimeout.bind(this)
+        this.scheduleOperation = this.scheduleOperation.bind(this)
+    }
+
+    private generateExecutionTime(association: Association, sourceRegion: number | undefined, targetRegion: number | undefined): number {
+        let executionTime = Date.now() + this.getLatency(sourceRegion, targetRegion)
+        if (association.getLastOperationAt() > executionTime) {
+            executionTime = association.getLastOperationAt()
+        }
+
+        return executionTime
+    }
+
+    private getLatency(sourceRegion: number | undefined, targetRegion: number | undefined): number {
+        let latency: number = 0
+
+        if (this.latencyType === LatencyType.FIXED) {
+            latency = this.fixedLatency!
+        }
+
+        if (this.latencyType === LatencyType.REAL) {
+
+            if (sourceRegion === undefined || targetRegion === undefined || sourceRegion > 15 || targetRegion > 15) {
+                logger.error('invalid region index given to Simulator')
+                throw ('invalid region index given to Simulator')
+            }
+
+            latency = this.latencyTable![sourceRegion!][targetRegion!]
+        }
+        if (this.latencyType === LatencyType.RANDOM) {
+            latency = Math.random() * (250 - 5) + 5
+        }
+
+        return latency
+    }
+
+    public accept(sourceConnection: SimulatorConnection, targetConnection: SimulatorConnection): void {
+
+        const sourceAssociation = this.associations.get(sourceConnection.connectionId)
+
+        if (!sourceAssociation) {
+            logger.error('source association not found in accept()')
+            return
+        }
+        sourceAssociation!.setDestinationConnection(targetConnection)
+
+        const targetAssociation = new Association(targetConnection, sourceConnection)
+        this.associations.set(targetConnection.connectionId, targetAssociation)
+
+        sourceAssociation.connectedCallback!()
+    }
+
+    public addConnector(connector: SimulatorConnector): void {
+        this.connectors.set(keyFromPeerDescriptor(connector.getPeerDescriptor()), connector)
+    }
+
+    private executeConnectOperation(operation: ConnectOperation): void {
+        const target = this.connectors.get(keyFromPeerDescriptor(operation.targetDescriptor))
+
+        if (!target) {
+            logger.error('Target connector not found when executing connect operation')
+            return operation.association.connectedCallback!('Target connector not found')
+        }
+
+        target!.handleIncomingConnection(operation.sourceConnection)
+    }
+
+    private executeCloseOperation(operation: CloseOperation): void {
+
+        if (this.stopped) {
+            return
+        }
+
+        const target = operation.association.destinationConnection
+
+        let counterAssociation: Association | undefined
+
+        if (target) {
+            counterAssociation = this.associations.get(target!.connectionId)
+        }
+
+        if (!target || !counterAssociation) {
+            this.associations.delete(operation.association.sourceConnection.connectionId)
+
+        } else if (!counterAssociation!.isClosing()) {
+            target!.handleIncomingDisconnection()
+            this.close(target!)
+        } else {
+            // this is the 'ack' of the CloseOperation to the original closer
+            this.associations.delete(target!.connectionId)
+            this.associations.delete(operation.association.sourceConnection.connectionId)
+        }
+    }
+
+    private executeSendOperation(operation: SendOperation): void {
+
+        if (this.stopped) {
+            return
+        }
+
+        const target = operation.association.destinationConnection
+        target!.handleIncomingData(operation.data)
+
+    }
+
+    private executeQueuedOperations(): void {
+        const currentTime = Date.now()
+        while (this.operationQueue.size() > 0
+            && this.operationQueue.peek()!.executionTime <= currentTime) {
+            const operation = this.operationQueue.pop()
+
+            this.operationCounter++
+
+            if (operation instanceof ConnectOperation) {
+                this.executeConnectOperation(operation)
+            } else if (operation instanceof CloseOperation) {
+                this.executeCloseOperation(operation)
+            } else if (operation instanceof SendOperation) {
+                this.executeSendOperation(operation)
+            } else {
+                logger.error('Unknown SimulatorOperation')
+            }
+
+            this.loopCounter++
+            if (this.loopCounter >= this.MAX_LOOPS) {
+                this.loopCounter = 0
+                setTimeout(() => this.executeQueuedOperations(), 0)
+                return
+            }
+        }
+
+        this.scheduleNextTimeout()
+    }
+
+    public getOperationCounter(): number {
+        return this.operationCounter
+    }
+
+    private scheduleNextTimeout(): void {
+        if (this.simulatorTimeout) {
+            clearTimeout(this.simulatorTimeout)
+            this.simulatorTimeout = undefined
+        }
+
+        const currentTime = Date.now()
+
+        const firstOperation = this.operationQueue.peek()
+
+        if (!firstOperation) {
+            return
+        }
+
+        const firstOperationTime = firstOperation!.executionTime
+        const timeDifference = firstOperationTime - currentTime
+
+        this.simulatorTimeout = setTimeout(this.executeQueuedOperations, timeDifference)
+       
+        if (Simulator.clock) {
+            Simulator.clock.runAllAsync()
+        }
+    }
+
+    private scheduleOperation(operation: SimulatorOperation) {
+        this.operationQueue.push(operation)
+        this.scheduleNextTimeout()
+    }
+
+    public connect(sourceConnection: SimulatorConnection, targetDescriptor: PeerDescriptor, connectedCallback: (error?: string) => void): void {
+
+        if (this.stopped) {
+            logger.error('connect() called on a stopped simulator ' + (new Error().stack))
+            return
+        }
+        debugVars['simulatorHeapSize'] = this.operationQueue.size()
+
+        const association = new Association(sourceConnection, undefined, connectedCallback)
+        this.associations.set(sourceConnection.connectionId, association)
+
+        const executionTime = this.generateExecutionTime(association, sourceConnection.ownPeerDescriptor.region, targetDescriptor.region)
+        association.setLastOperationAt(executionTime)
+
+        const operation = new ConnectOperation(executionTime, association,
+            sourceConnection, targetDescriptor)
+
+        this.scheduleOperation(operation)
+    }
+
+    public close(sourceConnection: SimulatorConnection): void {
+
+        if (this.stopped) {
+            return
+        }
+
+        const association = this.associations.get(sourceConnection.connectionId)
+        if (!association) {
+            return
+        }
+
+        association.setClosing()
+
+        const executionTime = this.generateExecutionTime(association,
+            sourceConnection.ownPeerDescriptor.region,
+            sourceConnection.getPeerDescriptor()?.region)
+        association.setLastOperationAt(executionTime)
+
+        const operation = new CloseOperation(executionTime, association)
+
+        this.scheduleOperation(operation)
+    }
+
+    public send(sourceConnection: SimulatorConnection, data: Uint8Array): void {
+
+        if (this.stopped) {
+            return
+        }
+
+        const association = this.associations.get(sourceConnection.connectionId)
+        if (!association) {
+            return
+        }
+
+        if (association.isClosing()) {
+            logger.trace('Tried to call send() on a closing association')
+            return
+        }
+
+        const executionTime = this.generateExecutionTime(association,
+            sourceConnection.ownPeerDescriptor.region,
+            association.destinationConnection!.ownPeerDescriptor.region)
+
+        association.setLastOperationAt(executionTime)
+
+        const operation = new SendOperation(executionTime, association, data)
+
+        this.scheduleOperation(operation)
+    }
+
+    public stop(): void {
+        this.stopped = true
+        logger.info(this.associations.size + ' associations in the beginning of stop()')
+
+        if (this.simulatorTimeout) {
+            clearTimeout(this.simulatorTimeout)
+        }
+    }
+}

package/src/connection/Simulator/SimulatorConnection.ts

@@ -0,0 +1,137 @@
+import { ConnectionType, IConnection } from '../IConnection'
+import { Simulator } from './Simulator'
+import { Message, PeerDescriptor } from '../../proto/packages/dht/protos/DhtRpc'
+import { Connection } from '../Connection'
+import { Logger } from '@streamr/utils'
+import { protoToString } from '../../helpers/protoToString'
+import { DisconnectionType } from '../../transport/ITransport'
+
+const logger = new Logger(module)
+
+export class SimulatorConnection extends Connection implements IConnection {
+
+    private stopped = false
+    public ownPeerDescriptor: PeerDescriptor
+    private targetPeerDescriptor: PeerDescriptor
+    private simulator: Simulator
+
+    constructor(
+        ownPeerDescriptor: PeerDescriptor,
+        targetPeerDescriptor: PeerDescriptor,
+        connectionType: ConnectionType,
+        simulator: Simulator
+    ) {
+        super(connectionType)
+
+        this.ownPeerDescriptor = ownPeerDescriptor
+        this.setPeerDescriptor(targetPeerDescriptor)
+        this.targetPeerDescriptor = targetPeerDescriptor
+        this.connectionType = connectionType
+        this.simulator = simulator
+
+        this.send = this.send.bind(this)
+        this.close = this.close.bind(this)
+        this.connect = this.connect.bind(this)
+        this.handleIncomingData = this.handleIncomingData.bind(this)
+        this.handleIncomingDisconnection = this.handleIncomingDisconnection.bind(this)
+        this.destroy = this.destroy.bind(this)
+        this.doDisconnect = this.doDisconnect.bind(this)
+    }
+
+    public send(data: Uint8Array): void {
+        logger.trace('send()')
+        if (!this.stopped) {
+
+            this.simulator.send(this, data)
+
+        } else {
+            logger.error(' ' + this.ownPeerDescriptor.nodeName + ', ' + (this.targetPeerDescriptor.nodeName!) +
+                'tried to send() on a stopped connection')
+        }
+    }
+
+    public async close(disconnectionType: DisconnectionType): Promise<void> {
+        logger.trace(' ' + this.ownPeerDescriptor.nodeName + ', ' + (this.targetPeerDescriptor.nodeName!) + ' close()')
+
+        if (!this.stopped) {
+            logger.trace(' ' + this.ownPeerDescriptor.nodeName + ', ' + (this.targetPeerDescriptor.nodeName!) + ' close() not stopped')
+            this.stopped = true
+
+            try {
+                logger.trace(' ' + this.ownPeerDescriptor.nodeName + ', ' + (this.targetPeerDescriptor.nodeName!) +
+                    ' close() calling simulator.disconnect()')
+                this.simulator.close(this)
+                logger.trace(' ' + this.ownPeerDescriptor.nodeName + ', ' + (this.targetPeerDescriptor.nodeName!) +
+                    ' close() simulator.disconnect returned')
+            } catch (e) {
+                logger.trace(' ' + this.ownPeerDescriptor.nodeName + ', ' + (this.targetPeerDescriptor.nodeName!) +
+                    'close aborted' + e)
+            } finally {
+                logger.trace(' ' + this.ownPeerDescriptor.nodeName + ', ' + (this.targetPeerDescriptor.nodeName!) +
+                    ' calling this.doDisconnect')
+                this.doDisconnect(disconnectionType)
+            }
+
+        } else {
+            logger.trace(' ' + this.ownPeerDescriptor.nodeName + ', ' + (this.targetPeerDescriptor.nodeName!) +
+                ' close() tried to close a stopped connection')
+        }
+    }
+
+    public connect(): void {
+        if (!this.stopped) {
+            logger.trace('connect() called')
+
+            this.simulator.connect(this, this.targetPeerDescriptor, (error?: string) => {
+                if (error) {
+                    logger.trace(error)
+                    this.doDisconnect('OTHER')
+                } else {
+                    this.emit('connected')
+                }
+            })
+        } else {
+            logger.trace('tried to connect() a stopped connection')
+        }
+    }
+
+    public handleIncomingData(data: Uint8Array): void {
+        if (!this.stopped) {
+            logger.trace('handleIncomingData()')
+            logger.trace(protoToString(Message.fromBinary(data), Message))
+            this.emit('data', data)
+        } else {
+            logger.trace('tried to call handleIncomingData() a stopped connection')
+        }
+    }
+
+    public handleIncomingDisconnection(): void {
+        if (!this.stopped) {
+            logger.trace(this.ownPeerDescriptor.nodeName + ' handleIncomingDisconnection()')
+            this.stopped = true
+            this.doDisconnect('OTHER')
+        } else {
+            logger.trace('tried to call handleIncomingDisconnection() a stopped connection')
+        }
+    }
+
+    public destroy(): void {
+        if (!this.stopped) {
+            logger.trace(this.ownPeerDescriptor.nodeName + ' destroy()')
+            this.removeAllListeners()
+            this.close('OTHER').catch((_e) => { })
+        } else {
+            logger.trace(this.ownPeerDescriptor.nodeName + ' tried to call destroy() a stopped connection')
+        }
+    }
+
+    private doDisconnect(disconnectionType: DisconnectionType) {
+        logger.trace(this.ownPeerDescriptor.nodeName + ' doDisconnect()')
+        this.stopped = true
+
+        logger.trace(' ' + this.ownPeerDescriptor.nodeName + ', ' + (this.targetPeerDescriptor.nodeName!) + ' doDisconnect emitting')
+
+        this.emit('disconnected', disconnectionType)
+
+    }
+}

package/src/connection/Simulator/SimulatorConnector.ts

@@ -0,0 +1,104 @@
+import { ConnectionType } from '../IConnection'
+
+import {
+    PeerDescriptor,
+} from '../../proto/packages/dht/protos/DhtRpc'
+import { Logger } from '@streamr/utils'
+import { ManagedConnection } from '../ManagedConnection'
+import { PeerIDKey } from '../../helpers/PeerID'
+import { Simulator } from './Simulator'
+import { SimulatorConnection } from './SimulatorConnection'
+import { keyFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
+
+const logger = new Logger(module)
+
+export class SimulatorConnector {
+
+    private connectingConnections: Map<PeerIDKey, ManagedConnection> = new Map()
+    private stopped = false
+    private protocolVersion: string
+    private ownPeerDescriptor: PeerDescriptor
+    private simulator: Simulator
+    private incomingConnectionCallback: (connection: ManagedConnection) => boolean
+
+    constructor(
+        protocolVersion: string,
+        ownPeerDescriptor: PeerDescriptor,
+        simulator: Simulator,
+        incomingConnectionCallback: (connection: ManagedConnection) => boolean
+    ) {
+        this.protocolVersion = protocolVersion
+        this.ownPeerDescriptor = ownPeerDescriptor
+        this.simulator = simulator
+        this.incomingConnectionCallback = incomingConnectionCallback
+    }
+
+    public connect(targetPeerDescriptor: PeerDescriptor): ManagedConnection {
+        logger.trace('connect() ' + this.ownPeerDescriptor.nodeName + ',' + targetPeerDescriptor.nodeName)
+        const peerKey = keyFromPeerDescriptor(targetPeerDescriptor)
+        const existingConnection = this.connectingConnections.get(peerKey)
+        if (existingConnection) {
+            return existingConnection
+        }
+
+        const connection = new SimulatorConnection(this.ownPeerDescriptor!, targetPeerDescriptor, ConnectionType.SIMULATOR_CLIENT, this.simulator)
+
+        const managedConnection = new ManagedConnection(this.ownPeerDescriptor!, this.protocolVersion,
+            ConnectionType.SIMULATOR_CLIENT, connection, undefined)
+        managedConnection.setPeerDescriptor(targetPeerDescriptor!)
+
+        this.connectingConnections.set(peerKey, managedConnection)
+        connection.once('disconnected', () => {
+            this.connectingConnections.delete(peerKey)
+        })
+        connection.once('connected', () => {
+            this.connectingConnections.delete(peerKey)
+        })
+
+        connection.connect()
+
+        return managedConnection
+    }
+
+    public getPeerDescriptor(): PeerDescriptor {
+        return this.ownPeerDescriptor
+    }
+
+    public handleIncomingConnection(sourceConnection: SimulatorConnection): void {
+        logger.trace(' ' + this.ownPeerDescriptor.nodeName + ', ' + sourceConnection.ownPeerDescriptor.nodeName +
+            ' incoming connection, stopped: ' + this.stopped)
+        if (this.stopped) {
+            return
+        }
+        const connection = new SimulatorConnection(this.ownPeerDescriptor!,
+            sourceConnection.ownPeerDescriptor, ConnectionType.SIMULATOR_SERVER, this.simulator)
+
+        const managedConnection = new ManagedConnection(this.ownPeerDescriptor!, this.protocolVersion,
+            ConnectionType.SIMULATOR_SERVER, undefined, connection)
+
+        logger.trace('connected, objectId: ' + managedConnection.objectId)
+
+        managedConnection.once('handshakeRequest', (_peerDescriptor: PeerDescriptor) => {
+            logger.trace(' ' + this.ownPeerDescriptor.nodeName + ', ' + sourceConnection.ownPeerDescriptor.nodeName + ' incoming handshake request')
+            logger.trace('incoming handshake request objectId: ' + managedConnection.objectId)
+
+            if (this.incomingConnectionCallback(managedConnection)) {
+                logger.trace(' ' + this.ownPeerDescriptor.nodeName + ', ' + sourceConnection.ownPeerDescriptor.nodeName + ' calling acceptHandshake')
+                managedConnection.acceptHandshake()
+            } else {
+                managedConnection.rejectHandshake('Duplicate connection')
+                managedConnection.destroy()
+            }
+        })
+
+        this.simulator.accept(sourceConnection, connection)
+    }
+
+    public async stop(): Promise<void> {
+        this.stopped = true
+        const conns = Array.from(this.connectingConnections.values())
+        await Promise.allSettled(conns.map((conn) =>
+            conn.close('OTHER')
+        ))
+    }
+}

package/src/connection/Simulator/SimulatorTransport.ts

@@ -0,0 +1,9 @@
+import { PeerDescriptor } from '../../proto/packages/dht/protos/DhtRpc'
+import { ConnectionManager } from '../ConnectionManager'
+import { Simulator } from './Simulator'
+
+export class SimulatorTransport extends ConnectionManager {
+    constructor(ownPeerDescriptor: PeerDescriptor, simulator: Simulator) {
+        super({ ownPeerDescriptor: ownPeerDescriptor, simulator, serviceIdPrefix: 'simulator/', nodeName: ownPeerDescriptor.nodeName })
+    }
+}

package/src/connection/Simulator/pings.ts

@@ -0,0 +1,42 @@
+/* eslint-disable max-len, @typescript-eslint/prefer-for-of */
+
+// This file contains a 16x16 matrix of ping times measured between
+// amazon regions. Converted to typescript from the file pings.csv
+// in order to make loading into browser easier.
+
+export enum RegionIndex { eu_central_1, eu_west_1, eu_west_2, eu_west_3, eu_north_1, us_east_1, us_east_2, us_west_1, us_west_2, ca_central_1, ap_south_1, ap_northeast_2, ap_southeast_1, ap_southeast_2, ap_northeast_1, sa_east_1 }
+
+export const regionPingMatrix = [
+    [0.325, 23.163, 12.942, 8.923, 20.699, 89.208, 99.98, 150.077, 139.224, 90.454, 117.0, 226.823, 154.592, 286.753, 222.719, 205.563],
+    [24.911, 0.195, 10.022, 18.544, 39.802, 66.161, 93.877, 136.271, 127.362, 73.733, 122.187, 229.064, 177.256, 254.277, 200.207, 186.817],
+    [12.879, 9.994, 0.167, 8.626, 31.896, 74.663, 85.231, 136.185, 125.328, 77.811, 111.29, 236.34, 164.357, 262.577, 207.745, 187.383],
+    [9.007, 16.823, 8.761, 0.191, 28.449, 81.969, 92.599, 140.961, 132.269, 85.444, 107.421, 243.981, 167.17, 279.322, 214.088, 197.986],
+    [20.661, 40.0, 31.176, 27.645, 0.137, 104.171, 115.704, 165.01, 155.741, 107.635, 136.75, 267.321, 173.951, 292.266, 238.492, 216.048],
+    [89.076, 67.701, 75.414, 81.598, 104.866, 0.284, 11.501, 61.662, 78.612, 14.115, 186.697, 174.546, 210.93, 196.071, 145.622, 114.919],
+    [100.018, 93.968, 85.06, 92.582, 115.719, 11.514, 0.184, 51.668, 48.447, 25.808, 195.433, 160.031, 197.27, 186.913, 133.115, 127.954],
+    [148.544, 137.18, 136.137, 141.333, 164.73, 60.257, 50.886, 0.197, 21.509, 77.668, 229.32, 134.858, 174.472, 137.329, 107.566, 175.944],
+    [137.885, 128.304, 125.316, 132.271, 155.726, 63.376, 48.457, 20.743, 0.293, 59.645, 218.285, 126.988, 162.72, 138.599, 100.203, 174.612],
+    [90.494, 78.203, 77.998, 84.348, 109.549, 14.136, 25.917, 77.323, 59.692, 0.163, 187.854, 169.253, 206.944, 195.467, 141.054, 126.962],
+    [120.19, 119.978, 112.023, 107.434, 139.361, 185.043, 195.679, 233.008, 216.025, 186.888, 0.177, 130.21, 56.019, 145.643, 128.57, 298.98],
+    [226.296, 229.187, 237.024, 243.839, 266.919, 174.727, 160.066, 136.623, 124.799, 169.854, 129.131, 0.189, 81.065, 139.967, 33.24, 284.578],
+    [154.691, 178.279, 170.997, 154.261, 173.776, 211.511, 197.551, 173.735, 162.834, 206.659, 56.964, 68.853, 0.215, 91.601, 69.684, 323.146],
+    [289.784, 253.234, 261.752, 277.504, 292.125, 198.099, 185.709, 136.413, 138.613, 194.986, 142.484, 147.706, 91.615, 0.156, 114.518, 311.12],
+    [223.926, 201.084, 210.133, 216.779, 237.762, 145.336, 132.887, 108.26, 98.057, 142.613, 122.716, 33.185, 68.547, 114.901, 0.162, 257.403],
+    [205.555, 178.082, 186.533, 195.774, 216.701, 117.089, 128.001, 175.761, 176.018, 125.551, 303.904, 285.782, 323.15, 309.618, 255.904, 0.262]
+]
+
+export function getRegionDelayMatrix(): Array<Array<number>> {
+    const ret = []
+    for (let i = 0; i < regionPingMatrix.length; i++) {
+        const row = []
+        for (let j = 0; j < regionPingMatrix[i].length; j++) {
+            row.push(regionPingMatrix[i][j] / 2)
+        }
+        ret.push(row)
+    }
+    return ret
+}
+
+export function getRandomRegion(): number {
+    return Math.floor(Math.random() * 15)
+}