@streamr/dht 100.0.0-testnet-one.4 → 100.0.0-testnet-two.1

package/src/connection/websocket/WebsocketConnector.ts

@@ -9,8 +9,7 @@ import {
     ConnectivityResponse,
     HandshakeError,
     PeerDescriptor,
-    WebsocketConnectionRequest,
-    WebsocketConnectionResponse
+    WebsocketConnectionRequest
 } from '../../proto/packages/dht/protos/DhtRpc'
 import { WebsocketConnectorRpcClient } from '../../proto/packages/dht/protos/DhtRpc.client'
 import { Logger, binaryToHex, wait } from '@streamr/utils'
@@ -18,11 +17,9 @@ import { ManagedConnection } from '../ManagedConnection'
 import { WebsocketServer } from './WebsocketServer'
 import { sendConnectivityRequest } from '../connectivityChecker'
 import { NatType, PortRange, TlsCertificate } from '../ConnectionManager'
-import { PeerIDKey } from '../../helpers/PeerID'
 import { ServerWebsocket } from './ServerWebsocket'
-import { toProtoRpcClient } from '@streamr/proto-rpc'
 import { Handshaker } from '../Handshaker'
-import { areEqualPeerDescriptors, keyFromPeerDescriptor, peerIdFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
+import { areEqualPeerDescriptors, getNodeIdFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
 import { ParsedUrlQuery } from 'querystring'
 import { range, sample } from 'lodash'
 import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
@@ -31,6 +28,10 @@ import { WebsocketServerStartError } from '../../helpers/errors'
 import { AutoCertifierClientFacade } from './AutoCertifierClientFacade'
 import { attachConnectivityRequestHandler } from '../connectivityRequestHandler'
 import * as Err from '../../helpers/errors'
+import { Empty } from '../../proto/google/protobuf/empty'
+import { NodeID } from '../../helpers/nodeId'
+import { version } from '../../../package.json'
+import { isCompatibleVersion } from '../../helpers/versionCompatibility'
 
 const logger = new Logger(module)
 
@@ -45,6 +46,7 @@ const ENTRY_POINT_CONNECTION_ATTEMPTS = 5
 export interface WebsocketConnectorConfig {
     transport: ITransport
     onNewConnection: (connection: ManagedConnection) => boolean
+    hasConnection: (peerDescriptor: PeerDescriptor) => boolean
     portRange?: PortRange
     maxMessageSize?: number
     host?: string
@@ -61,38 +63,26 @@ export class WebsocketConnector {
     private static readonly WEBSOCKET_CONNECTOR_SERVICE_ID = 'system/websocket-connector'
     private readonly rpcCommunicator: ListeningRpcCommunicator
     private readonly websocketServer?: WebsocketServer
-    private readonly ongoingConnectRequests: Map<PeerIDKey, ManagedConnection> = new Map()
-    private onNewConnection: (connection: ManagedConnection) => boolean
+    private readonly ongoingConnectRequests: Map<NodeID, ManagedConnection> = new Map()
     private host?: string
-    private readonly entrypoints?: PeerDescriptor[]
-    private readonly tlsCertificate?: TlsCertificate
-    private readonly autoCertifierTransport: ITransport
-    private readonly autoCertifierUrl: string
-    private readonly autoCertifierConfigFile: string
-    private readonly serverEnableTls: boolean
     private autoCertifierClient?: AutoCertifierClientFacade
     private selectedPort?: number
     private localPeerDescriptor?: PeerDescriptor
-    private connectingConnections: Map<PeerIDKey, ManagedConnection> = new Map()
+    private connectingConnections: Map<NodeID, ManagedConnection> = new Map()
     private abortController = new AbortController()
+    private readonly config: WebsocketConnectorConfig
 
     constructor(config: WebsocketConnectorConfig) {
+        this.config = config
         this.websocketServer = config.portRange ? new WebsocketServer({
             portRange: config.portRange,
             tlsCertificate: config.tlsCertificate,
             maxMessageSize: config.maxMessageSize,
             enableTls: config.serverEnableTls
         }) : undefined
-        this.onNewConnection = config.onNewConnection
         this.host = config.host
-        this.entrypoints = config.entrypoints
-        this.tlsCertificate = config.tlsCertificate
-        this.autoCertifierTransport = config.autoCertifierTransport
-        this.autoCertifierUrl = config.autoCertifierUrl
-        this.autoCertifierConfigFile = config.autoCertifierConfigFile
-        this.serverEnableTls = config.serverEnableTls
         this.rpcCommunicator = new ListeningRpcCommunicator(WebsocketConnector.WEBSOCKET_CONNECTOR_SERVICE_ID, config.transport, {
-            rpcRequestTimeout: 15000
+            rpcRequestTimeout: 15000  // TODO use config option or named constant?
         })
         this.registerLocalRpcMethods(config)
     }
@@ -101,10 +91,11 @@ export class WebsocketConnector {
         const rpcLocal = new WebsocketConnectorRpcLocal({
             connect: (targetPeerDescriptor: PeerDescriptor) => this.connect(targetPeerDescriptor),
             hasConnection: (targetPeerDescriptor: PeerDescriptor): boolean => {
-                const peerKey = keyFromPeerDescriptor(targetPeerDescriptor)
-                if (this.connectingConnections.has(peerKey)
-                    || this.connectingConnections.has(peerKey)
-                    || this.ongoingConnectRequests.has(peerKey)
+                const nodeId = getNodeIdFromPeerDescriptor(targetPeerDescriptor)
+                if (this.connectingConnections.has(nodeId)
+                    || this.connectingConnections.has(nodeId)
+                    || this.ongoingConnectRequests.has(nodeId)
+                    || config.hasConnection(targetPeerDescriptor)
                 ) {
                     return true
                 } else {
@@ -114,15 +105,14 @@ export class WebsocketConnector {
             onNewConnection: (connection: ManagedConnection) => config.onNewConnection(connection),
             abortSignal: this.abortController.signal
         })
-        this.rpcCommunicator.registerRpcMethod(
+        this.rpcCommunicator.registerRpcNotification(
             WebsocketConnectionRequest,
-            WebsocketConnectionResponse,
             'requestConnection',
-            async (req: WebsocketConnectionRequest, context: ServerCallContext): Promise<WebsocketConnectionResponse> => {
+            async (req: WebsocketConnectionRequest, context: ServerCallContext): Promise<Empty> => {
                 if (!this.abortController.signal.aborted) {
                     return rpcLocal.requestConnection(req, context)
                 } else {
-                    return { accepted: false }
+                    return {}
                 }
             }
         )
@@ -130,16 +120,16 @@ export class WebsocketConnector {
 
     private attachHandshaker(connection: IConnection) {
         const handshaker = new Handshaker(this.localPeerDescriptor!, connection)
-        handshaker.once('handshakeRequest', (localPeerDescriptor: PeerDescriptor, remotePeerDescriptor?: PeerDescriptor) => {
-            this.onServerSocketHandshakeRequest(localPeerDescriptor, connection, remotePeerDescriptor)
+        handshaker.once('handshakeRequest', (localPeerDescriptor: PeerDescriptor, sourceVersion: string, remotePeerDescriptor?: PeerDescriptor) => {
+            this.onServerSocketHandshakeRequest(localPeerDescriptor, connection, sourceVersion, remotePeerDescriptor)
         })
     }
 
     public async autoCertify(): Promise<void> {
         this.autoCertifierClient = new AutoCertifierClientFacade({
-            configFile: this.autoCertifierConfigFile,
-            transport: this.autoCertifierTransport,
-            url: this.autoCertifierUrl,
+            configFile: this.config.autoCertifierConfigFile,
+            transport: this.config.autoCertifierTransport,
+            url: this.config.autoCertifierUrl,
             wsServerPort: this.selectedPort!,
             setHost: (hostName: string) => this.setHost(hostName),
             updateCertificate: (certificate: string, privateKey: string) => this.websocketServer!.updateCertificate(certificate, privateKey)
@@ -183,17 +173,17 @@ export class WebsocketConnector {
             return noServerConnectivityResponse
         }
         for (const reattempt of range(ENTRY_POINT_CONNECTION_ATTEMPTS)) {
-            const entryPoint = sample(this.entrypoints)!
+            const entryPoint = sample(this.config.entrypoints)!
             try {
                 if (!this.websocketServer) {
                     return noServerConnectivityResponse
                 } else {
-                    if (!this.entrypoints || this.entrypoints.length === 0) {
+                    if (!this.config.entrypoints || this.config.entrypoints.length === 0) {
                         // return connectivity info given in config
                         const preconfiguredConnectivityResponse: ConnectivityResponse = {
                             host: this.host!,
                             natType: NatType.OPEN_INTERNET,
-                            websocket: { host: this.host!, port: this.selectedPort!, tls: this.tlsCertificate !== undefined }
+                            websocket: { host: this.host!, port: this.selectedPort!, tls: this.config.tlsCertificate !== undefined }
                         }
                         return preconfiguredConnectivityResponse
                     } else {
@@ -201,7 +191,7 @@ export class WebsocketConnector {
                         const connectivityRequest = {
                             port: this.selectedPort!,
                             host: this.host,
-                            tls: this.serverEnableTls,
+                            tls: this.config.serverEnableTls,
                             selfSigned
                         }
                         if (!this.abortController.signal.aborted) {
@@ -229,8 +219,8 @@ export class WebsocketConnector {
     }
 
     public connect(targetPeerDescriptor: PeerDescriptor): ManagedConnection {
-        const peerKey = keyFromPeerDescriptor(targetPeerDescriptor)
-        const existingConnection = this.connectingConnections.get(peerKey)
+        const nodeId = getNodeIdFromPeerDescriptor(targetPeerDescriptor)
+        const existingConnection = this.connectingConnections.get(nodeId)
         if (existingConnection) {
             return existingConnection
         }
@@ -251,11 +241,11 @@ export class WebsocketConnector {
             )
             managedConnection.setRemotePeerDescriptor(targetPeerDescriptor)
 
-            this.connectingConnections.set(keyFromPeerDescriptor(targetPeerDescriptor), managedConnection)
+            this.connectingConnections.set(getNodeIdFromPeerDescriptor(targetPeerDescriptor), managedConnection)
 
             const delFunc = () => {
-                if (this.connectingConnections.has(peerKey)) {
-                    this.connectingConnections.delete(peerKey)
+                if (this.connectingConnections.has(nodeId)) {
+                    this.connectingConnections.delete(nodeId)
                 }
                 socket.off('disconnected', delFunc)
                 managedConnection.off('handshakeCompleted', delFunc)
@@ -274,13 +264,15 @@ export class WebsocketConnector {
             const remoteConnector = new WebsocketConnectorRpcRemote(
                 localPeerDescriptor,
                 targetPeerDescriptor,
-                toProtoRpcClient(new WebsocketConnectorRpcClient(this.rpcCommunicator.getRpcClientTransport()))
+                'DUMMY',
+                this.rpcCommunicator,
+                WebsocketConnectorRpcClient
             )
-            remoteConnector.requestConnection().then((_response: WebsocketConnectionResponse) => {
-                logger.trace('Sent WebsocketConnectionRequest request to peer', { targetPeerDescriptor })
+            remoteConnector.requestConnection().then(() => {
+                logger.trace('Sent WebsocketConnectionRequest notification to peer', { targetPeerDescriptor })
                 return
             }, (err) => {
-                logger.debug('Failed to send WebsocketConnectionRequest request to peer of failed to get the response ', {
+                logger.debug('Failed to send WebsocketConnectionRequest notification to peer ', {
                     error: err, targetPeerDescriptor
                 })
             })
@@ -292,24 +284,28 @@ export class WebsocketConnector {
             undefined,
             targetPeerDescriptor
         )
-        managedConnection.on('disconnected', () => this.ongoingConnectRequests.delete(keyFromPeerDescriptor(targetPeerDescriptor)))
+        managedConnection.on('disconnected', () => this.ongoingConnectRequests.delete(getNodeIdFromPeerDescriptor(targetPeerDescriptor)))
         managedConnection.setRemotePeerDescriptor(targetPeerDescriptor)
-        this.ongoingConnectRequests.set(keyFromPeerDescriptor(targetPeerDescriptor), managedConnection)
+        this.ongoingConnectRequests.set(getNodeIdFromPeerDescriptor(targetPeerDescriptor), managedConnection)
         return managedConnection
     }
 
     private onServerSocketHandshakeRequest(
         sourcePeerDescriptor: PeerDescriptor,
         serverWebsocket: IConnection,
+        sourceVersion: string,
         targetPeerDescriptor?: PeerDescriptor
     ) {
-        const peerId = peerIdFromPeerDescriptor(sourcePeerDescriptor)
-
-        if (this.ongoingConnectRequests.has(peerId.toKey())) {
-            const ongoingConnectRequest = this.ongoingConnectRequests.get(peerId.toKey())!
-            ongoingConnectRequest.attachImplementation(serverWebsocket)
-            ongoingConnectRequest.acceptHandshake()
-            this.ongoingConnectRequests.delete(peerId.toKey())
+        const nodeId = getNodeIdFromPeerDescriptor(sourcePeerDescriptor)
+        if (this.ongoingConnectRequests.has(nodeId)) {
+            const ongoingConnectRequest = this.ongoingConnectRequests.get(nodeId)!
+            if (!isCompatibleVersion(sourceVersion, version)) {
+                ongoingConnectRequest.rejectHandshake(HandshakeError.UNSUPPORTED_VERSION)
+            } else {
+                ongoingConnectRequest.attachImplementation(serverWebsocket)
+                ongoingConnectRequest.acceptHandshake()
+            }
+            this.ongoingConnectRequests.delete(nodeId)
         } else {
             const managedConnection = new ManagedConnection(
                 this.localPeerDescriptor!,
@@ -318,12 +314,12 @@ export class WebsocketConnector {
                 serverWebsocket,
                 targetPeerDescriptor
             )
-
             managedConnection.setRemotePeerDescriptor(sourcePeerDescriptor)
-
-            if (targetPeerDescriptor && !areEqualPeerDescriptors(this.localPeerDescriptor!, targetPeerDescriptor)) {
+            if (!isCompatibleVersion(sourceVersion, version)) {
+                managedConnection.rejectHandshake(HandshakeError.UNSUPPORTED_VERSION)
+            } else if (targetPeerDescriptor && !areEqualPeerDescriptors(this.localPeerDescriptor!, targetPeerDescriptor)) {
                 managedConnection.rejectHandshake(HandshakeError.INVALID_TARGET_PEER_DESCRIPTOR)
-            } else if (this.onNewConnection(managedConnection)) {
+            } else if (this.config.onNewConnection(managedConnection)) {
                 managedConnection.acceptHandshake()
             } else {
                 managedConnection.rejectHandshake(HandshakeError.DUPLICATE_CONNECTION)

package/src/connection/websocket/WebsocketConnectorRpcLocal.ts

@@ -1,12 +1,12 @@
 import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
 import {
     PeerDescriptor,
-    WebsocketConnectionRequest,
-    WebsocketConnectionResponse
+    WebsocketConnectionRequest
 } from '../../proto/packages/dht/protos/DhtRpc'
 import { IWebsocketConnectorRpc } from '../../proto/packages/dht/protos/DhtRpc.server'
 import { DhtCallContext } from '../../rpc-protocol/DhtCallContext'
 import { ManagedConnection } from '../ManagedConnection'
+import { Empty } from '../../proto/google/protobuf/empty'
 
 interface WebsocketConnectorRpcLocalConfig {
     connect: (targetPeerDescriptor: PeerDescriptor) => ManagedConnection
@@ -23,17 +23,15 @@ export class WebsocketConnectorRpcLocal implements IWebsocketConnectorRpc {
         this.config = config
     }
 
-    public async requestConnection(_request: WebsocketConnectionRequest, context: ServerCallContext): Promise<WebsocketConnectionResponse> {
+    public async requestConnection(_request: WebsocketConnectionRequest, context: ServerCallContext): Promise<Empty> {
+        if (this.config.abortSignal.aborted) {
+            return {}
+        }
         const senderPeerDescriptor = (context as DhtCallContext).incomingSourceDescriptor!
-        setImmediate(() => {
-            if (this.config.abortSignal.aborted) {
-                return
-            }
-            if (!this.config.hasConnection(senderPeerDescriptor)) {
-                const connection = this.config.connect(senderPeerDescriptor)
-                this.config.onNewConnection(connection)
-            }
-        })
-        return { accepted: true }
+        if (!this.config.hasConnection(senderPeerDescriptor)) {
+            const connection = this.config.connect(senderPeerDescriptor)
+            this.config.onNewConnection(connection)
+        }
+        return {}
     }
 }

package/src/connection/websocket/WebsocketConnectorRpcRemote.ts

@@ -1,27 +1,16 @@
 import {
-    PeerDescriptor,
-    WebsocketConnectionRequest,
-    WebsocketConnectionResponse
+    WebsocketConnectionRequest
 } from '../../proto/packages/dht/protos/DhtRpc'
-import { IWebsocketConnectorRpcClient } from '../../proto/packages/dht/protos/DhtRpc.client'
 import { Logger } from '@streamr/utils'
-import { ProtoRpcClient } from '@streamr/proto-rpc'
 import { getNodeIdFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
 import { RpcRemote } from '../../dht/contact/RpcRemote'
+import { WebsocketConnectorRpcClient } from '../../proto/packages/dht/protos/DhtRpc.client'
 
 const logger = new Logger(module)
 
-export class WebsocketConnectorRpcRemote extends RpcRemote<IWebsocketConnectorRpcClient> {
+export class WebsocketConnectorRpcRemote extends RpcRemote<WebsocketConnectorRpcClient> {
 
-    constructor(
-        localPeerDescriptor: PeerDescriptor,
-        remotePeerDescriptor: PeerDescriptor,
-        client: ProtoRpcClient<IWebsocketConnectorRpcClient>
-    ) {
-        super(localPeerDescriptor, remotePeerDescriptor, 'DUMMY', client)
-    }
-
-    async requestConnection(): Promise<WebsocketConnectionResponse> {
+    async requestConnection(): Promise<void> {
         logger.trace(`Requesting WebSocket connection from ${getNodeIdFromPeerDescriptor(this.getLocalPeerDescriptor())}`)
         const request: WebsocketConnectionRequest = {}
         const options = this.formDhtRpcOptions()

package/src/connection/websocket/WebsocketServer.ts

@@ -33,24 +33,18 @@ export class WebsocketServer extends EventEmitter<ConnectionSourceEvents> {
     private httpServer?: HttpServer | HttpsServer
     private wsServer?: WsServer
     private readonly abortController = new AbortController()
-    private readonly portRange: PortRange
-    private readonly tlsCertificate?: TlsCertificate
-    private readonly enableTls: boolean
-    private readonly maxMessageSize: number
+    private readonly config: WebsocketServerConfig
 
     constructor(config: WebsocketServerConfig) {
         super()
-        this.portRange = config.portRange
-        this.enableTls = config.enableTls
-        this.tlsCertificate = config.tlsCertificate
-        this.maxMessageSize = config.maxMessageSize ?? 1048576
+        this.config = config
     }
 
     public async start(): Promise<number> {
-        const ports = range(this.portRange.min, this.portRange.max + 1)
+        const ports = range(this.config.portRange.min, this.config.portRange.max + 1)
         for (const port of ports) {
             try {
-                await asAbortable(this.startServer(port, this.enableTls), this.abortController.signal)
+                await asAbortable(this.startServer(port, this.config.enableTls), this.abortController.signal)
                 return port
             } catch (err) {
                 if (err.originalError?.code === 'EADDRINUSE') {
@@ -60,7 +54,9 @@ export class WebsocketServer extends EventEmitter<ConnectionSourceEvents> {
                 }
             }
         }
-        throw new WebsocketServerStartError(`Failed to start WebSocket server on any port in range: ${this.portRange.min}-${this.portRange.min}`)
+        throw new WebsocketServerStartError(
+            `Failed to start WebSocket server on any port in range: ${this.config.portRange.min}-${this.config.portRange.min}`
+        )
     }
 
     // If tlsCertificate has been given the tls boolean is ignored
@@ -72,14 +68,15 @@ export class WebsocketServer extends EventEmitter<ConnectionSourceEvents> {
             response.end()
         }
         return new Promise((resolve, reject) => {
-            if (this.tlsCertificate) {
+            if (this.config.tlsCertificate) {
                 this.httpServer = createHttpsServer({
-                    key: fs.readFileSync(this.tlsCertificate.privateKeyFileName),
-                    cert: fs.readFileSync(this.tlsCertificate.certFileName)
+                    key: fs.readFileSync(this.config.tlsCertificate.privateKeyFileName),
+                    cert: fs.readFileSync(this.config.tlsCertificate.certFileName)
                 }, requestListener)
             } else if (!tls) {
                 this.httpServer = createHttpServer(requestListener)
             } else {
+                // TODO use config option or named constant?
                 const certificate = createSelfSignedCertificate('streamr-self-signed-' + new UUID().toString(), 1000)
                 this.httpServer = createHttpsServer({
                     key: certificate.serverKey,
@@ -159,19 +156,19 @@ export class WebsocketServer extends EventEmitter<ConnectionSourceEvents> {
     }
 
     private createWsServer(httpServer: HttpServer | HttpsServer): WsServer {
+        const maxReceivedMessageSize = this.config.maxMessageSize ?? 1048576
         // Use the real nodejs WebSocket server in Electron tests
-
         if (typeof NodeJsWsServer !== 'undefined') {
             return new NodeJsWsServer({
                 httpServer,
                 autoAcceptConnections: false,
-                maxReceivedMessageSize: this.maxMessageSize
+                maxReceivedMessageSize
             })
         } else {
             return this.wsServer = new WsServer({
                 httpServer,
                 autoAcceptConnections: false,
-                maxReceivedMessageSize: this.maxMessageSize
+                maxReceivedMessageSize
             })
         }
     }