@streamr/trackerless-network 102.0.0-beta.0 → 102.0.0-beta.2

package/src/logic/proxy/ProxyClient.ts

@@ -1,287 +0,0 @@
-import {
-    ConnectionLocker,
-    DhtAddress,
-    ITransport,
-    ListeningRpcCommunicator,
-    PeerDescriptor,
-    toNodeId
-} from '@streamr/dht'
-import { Logger, StreamPartID, UserID, addManagedEventListener, wait } from '@streamr/utils'
-import { EventEmitter } from 'eventemitter3'
-import { sampleSize } from 'lodash'
-import {
-    LeaveStreamPartNotice,
-    MessageID,
-    MessageRef,
-    ProxyDirection,
-    StreamMessage
-} from '../../proto/packages/trackerless-network/protos/NetworkRpc'
-import { ContentDeliveryRpcClient, ProxyConnectionRpcClient } from '../../proto/packages/trackerless-network/protos/NetworkRpc.client'
-import { ContentDeliveryRpcLocal } from '../ContentDeliveryRpcLocal'
-import { ContentDeliveryRpcRemote } from '../ContentDeliveryRpcRemote'
-import { DuplicateMessageDetector } from '../DuplicateMessageDetector'
-import { NodeList } from '../NodeList'
-import { formStreamPartContentDeliveryServiceId } from '../formStreamPartDeliveryServiceId'
-import { Propagation } from '../propagation/Propagation'
-import { markAndCheckDuplicate } from '../utils'
-import { ProxyConnectionRpcRemote } from './ProxyConnectionRpcRemote'
-
-// TODO use options option or named constant?
-export const retry = async <T>(task: () => Promise<T>, description: string, abortSignal: AbortSignal, delay = 10000): Promise<T> => {
-    // eslint-disable-next-line no-constant-condition
-    while (true) {
-        try {
-            const result = await task()
-            return result
-        } catch {
-            logger.warn(`Failed ${description} (retrying after delay)`, {
-                delayInMs: delay
-            })
-        }
-        await wait(delay, abortSignal)
-    }
-}
-
-interface ProxyClientOptions {
-    transport: ITransport
-    localPeerDescriptor: PeerDescriptor
-    streamPartId: StreamPartID
-    connectionLocker: ConnectionLocker
-    minPropagationTargets?: number // TODO could be required option if we apply all defaults somewhere at higher level
-}
-
-interface ProxyDefinition {
-    nodes: Map<DhtAddress, PeerDescriptor>
-    connectionCount: number
-    direction: ProxyDirection
-    userId: UserID
-}
-
-interface ProxyConnection {
-    peerDescriptor: PeerDescriptor
-    direction: ProxyDirection
-}
-
-interface Events {
-    message: (message: StreamMessage) => void
-}
-
-const logger = new Logger(module)
-
-const SERVICE_ID = 'system/proxy-client'
-
-export class ProxyClient extends EventEmitter<Events> {
-
-    private readonly rpcCommunicator: ListeningRpcCommunicator
-    private readonly contentDeliveryRpcLocal: ContentDeliveryRpcLocal
-    private readonly options: ProxyClientOptions
-    private readonly duplicateDetectors: Map<string, DuplicateMessageDetector> = new Map()
-    private definition?: ProxyDefinition
-    private readonly connections: Map<DhtAddress, ProxyConnection> = new Map()
-    private readonly propagation: Propagation
-    private readonly neighbors: NodeList
-    private readonly abortController: AbortController
-
-    constructor(options: ProxyClientOptions) {
-        super()
-        this.options = options
-        this.rpcCommunicator = new ListeningRpcCommunicator(formStreamPartContentDeliveryServiceId(options.streamPartId), options.transport)
-        // TODO use options option or named constant?
-        this.neighbors = new NodeList(toNodeId(this.options.localPeerDescriptor), 1000)
-        this.contentDeliveryRpcLocal = new ContentDeliveryRpcLocal({
-            localPeerDescriptor: this.options.localPeerDescriptor,
-            streamPartId: this.options.streamPartId,
-            markAndCheckDuplicate: (msg: MessageID, prev?: MessageRef) => markAndCheckDuplicate(this.duplicateDetectors, msg, prev),
-            broadcast: (message: StreamMessage, previousNode?: DhtAddress) => this.broadcast(message, previousNode),
-            onLeaveNotice: (remoteNodeId: DhtAddress) => {
-                const contact = this.neighbors.get(remoteNodeId)
-                if (contact) {
-                    // TODO should we catch possible promise rejection?
-                    setImmediate(() => this.onNodeDisconnected(contact.getPeerDescriptor()))
-                }
-            },
-            rpcCommunicator: this.rpcCommunicator,
-            markForInspection: () => {}
-        })
-        this.propagation = new Propagation({
-            // TODO use options option or named constant?
-            minPropagationTargets: options.minPropagationTargets ?? 2,
-            sendToNeighbor: async (neighborId: DhtAddress, msg: StreamMessage): Promise<void> => {
-                const remote = this.neighbors.get(neighborId)
-                if (remote) {
-                    await remote.sendStreamMessage(msg)
-                } else {
-                    throw new Error('Propagation target not found')
-                }
-            }
-        })
-        this.abortController = new AbortController()
-    }
-
-    private registerDefaultServerMethods(): void {
-        this.rpcCommunicator.registerRpcNotification(StreamMessage, 'sendStreamMessage',
-            (msg: StreamMessage, context) => this.contentDeliveryRpcLocal.sendStreamMessage(msg, context))
-        this.rpcCommunicator.registerRpcNotification(LeaveStreamPartNotice, 'leaveStreamPartNotice',
-            (req: LeaveStreamPartNotice, context) => this.contentDeliveryRpcLocal.leaveStreamPartNotice(req, context))
-    }
-
-    async setProxies(
-        nodes: PeerDescriptor[],
-        direction: ProxyDirection,
-        userId: UserID,
-        connectionCount?: number
-    ): Promise<void> {
-        logger.trace('Setting proxies', { streamPartId: this.options.streamPartId, peerDescriptors: nodes, direction, userId, connectionCount })
-        if (connectionCount !== undefined && connectionCount > nodes.length) {
-            throw new Error('Cannot set connectionCount above the size of the configured array of nodes')
-        }
-        const nodesIds = new Map<DhtAddress, PeerDescriptor>()
-        nodes.forEach((peerDescriptor) => {
-            nodesIds.set(toNodeId(peerDescriptor), peerDescriptor)
-        })
-        this.definition = {
-            nodes: nodesIds,
-            userId,
-            direction,
-            connectionCount: connectionCount ?? nodes.length
-        }
-        await this.updateConnections()
-    }
-
-    private async updateConnections(): Promise<void> {
-        await Promise.all(this.getInvalidConnections().map(async (id) => {
-            await this.closeConnection(id)
-        }))
-        const connectionCountDiff = this.definition!.connectionCount - this.connections.size
-        if (connectionCountDiff > 0) {
-            await this.openRandomConnections(connectionCountDiff)
-        } else if (connectionCountDiff < 0) {
-            await this.closeRandomConnections(-connectionCountDiff)
-        }
-    }
-
-    private getInvalidConnections(): DhtAddress[] {
-        return Array.from(this.connections.keys()).filter((id) => {
-            return !this.definition!.nodes.has(id)
-                || this.definition!.direction !== this.connections.get(id)!.direction
-        })
-    }
-
-    private async openRandomConnections(connectionCount: number): Promise<void> {
-        const proxiesToAttempt = sampleSize(Array.from(this.definition!.nodes.keys()).filter((id) =>
-            !this.connections.has(id)
-        ), connectionCount)
-        await Promise.all(proxiesToAttempt.map((id) =>
-            this.attemptConnection(id, this.definition!.direction, this.definition!.userId)
-        ))
-    }
-
-    private async attemptConnection(nodeId: DhtAddress, direction: ProxyDirection, userId: UserID): Promise<void> {
-        const peerDescriptor = this.definition!.nodes.get(nodeId)!
-        const rpcRemote = new ProxyConnectionRpcRemote(
-            this.options.localPeerDescriptor,
-            peerDescriptor,
-            this.rpcCommunicator,
-            ProxyConnectionRpcClient
-        )
-        const accepted = await rpcRemote.requestConnection(direction, userId)
-        if (accepted) {
-            this.options.connectionLocker.lockConnection(peerDescriptor, SERVICE_ID)
-            this.connections.set(nodeId, { peerDescriptor, direction })
-            const remote = new ContentDeliveryRpcRemote(
-                this.options.localPeerDescriptor,
-                peerDescriptor,
-                this.rpcCommunicator,
-                ContentDeliveryRpcClient
-            )
-            this.neighbors.add(remote)
-            this.propagation.onNeighborJoined(nodeId)
-            logger.info('Open proxy connection', {
-                nodeId,
-                streamPartId: this.options.streamPartId
-            })
-        } else {
-            logger.warn('Unable to open proxy connection', {
-                nodeId,
-                streamPartId: this.options.streamPartId
-            })
-        }
-    }
-
-    private async closeRandomConnections(connectionCount: number): Promise<void> {
-        const proxiesToDisconnect = sampleSize(Array.from(this.connections.keys()), connectionCount)
-        await Promise.allSettled(proxiesToDisconnect.map((node) => this.closeConnection(node)))
-    }
-
-    private async closeConnection(nodeId: DhtAddress): Promise<void> {
-        if (this.connections.has(nodeId)) {
-            logger.info('Close proxy connection', {
-                nodeId
-            })
-            const server = this.neighbors.get(nodeId)
-            server?.leaveStreamPartNotice(this.options.streamPartId, false)
-            this.removeConnection(this.connections.get(nodeId)!.peerDescriptor)
-        }
-    }
-
-    private removeConnection(peerDescriptor: PeerDescriptor): void {
-        const nodeId = toNodeId(peerDescriptor)
-        this.connections.delete(nodeId)
-        this.neighbors.remove(nodeId)
-        this.options.connectionLocker.unlockConnection(peerDescriptor, SERVICE_ID)
-    }
-
-    broadcast(msg: StreamMessage, previousNode?: DhtAddress): void {
-        if (!previousNode) {
-            markAndCheckDuplicate(this.duplicateDetectors, msg.messageId!, msg.previousMessageRef)
-        }
-        this.emit('message', msg)
-        this.propagation.feedUnseenMessage(msg, this.neighbors.getIds(), previousNode ?? null)
-    }
-
-    hasConnection(nodeId: DhtAddress, direction: ProxyDirection): boolean {
-        return this.connections.has(nodeId) && this.connections.get(nodeId)!.direction === direction
-    }
-
-    getDirection(): ProxyDirection {
-        return this.definition!.direction
-    }
-
-    private async onNodeDisconnected(peerDescriptor: PeerDescriptor): Promise<void> {
-        const nodeId = toNodeId(peerDescriptor)
-        if (this.connections.has(nodeId)) {
-            this.options.connectionLocker.unlockConnection(peerDescriptor, SERVICE_ID)
-            this.removeConnection(peerDescriptor)
-            await retry(() => this.updateConnections(), 'updating proxy connections', this.abortController.signal)
-        }
-    }
-
-    async start(): Promise<void> {
-        this.registerDefaultServerMethods()
-        addManagedEventListener(
-            this.options.transport,
-            'disconnected',
-            // TODO should we catch possible promise rejection?
-            (peerDescriptor: PeerDescriptor) => this.onNodeDisconnected(peerDescriptor),
-            this.abortController.signal
-        )
-    }
-
-    public getDiagnosticInfo(): Record<string, unknown> {
-        return {
-            neighbors: this.neighbors.getAll().map((neighbor) => neighbor.getPeerDescriptor()),
-        }
-    }
-
-    stop(): void {
-        this.neighbors.getAll().forEach((remote) => {
-            this.options.connectionLocker.unlockConnection(remote.getPeerDescriptor(), SERVICE_ID)
-            remote.leaveStreamPartNotice(this.options.streamPartId, false)
-        })
-        this.neighbors.stop()
-        this.rpcCommunicator.destroy()
-        this.connections.clear()
-        this.abortController.abort()
-    }
-
-}

package/src/logic/proxy/ProxyConnectionRpcLocal.ts

@@ -1,106 +0,0 @@
-import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
-import { DhtAddress, DhtCallContext, ListeningRpcCommunicator, PeerDescriptor, toNodeId } from '@streamr/dht'
-import { Logger, StreamPartID, UserID, binaryToHex, toEthereumAddress } from '@streamr/utils'
-import { EventEmitter } from 'eventemitter3'
-import {
-    ProxyConnectionRequest,
-    ProxyConnectionResponse,
-    ProxyDirection,
-    StreamMessage
-} from '../../proto/packages/trackerless-network/protos/NetworkRpc'
-import { ContentDeliveryRpcClient } from '../../proto/packages/trackerless-network/protos/NetworkRpc.client'
-import { IProxyConnectionRpc } from '../../proto/packages/trackerless-network/protos/NetworkRpc.server'
-import { ContentDeliveryRpcRemote } from '../ContentDeliveryRpcRemote'
-
-const logger = new Logger(module)
-
-interface ProxyConnection {
-    direction: ProxyDirection // Direction is from the client's point of view
-    userId: UserID
-    remote: ContentDeliveryRpcRemote
-}
-
-interface ProxyConnectionRpcLocalOptions {
-    localPeerDescriptor: PeerDescriptor
-    streamPartId: StreamPartID
-    rpcCommunicator: ListeningRpcCommunicator
-}
-
-export interface Events {
-    newConnection: (nodeId: DhtAddress) => void
-}
-
-export class ProxyConnectionRpcLocal extends EventEmitter<Events> implements IProxyConnectionRpc {
-
-    private readonly options: ProxyConnectionRpcLocalOptions
-    private readonly connections: Map<DhtAddress, ProxyConnection> = new Map()
-
-    constructor(options: ProxyConnectionRpcLocalOptions) {
-        super()
-        this.options = options
-        this.options.rpcCommunicator.registerRpcMethod(ProxyConnectionRequest, ProxyConnectionResponse, 'requestConnection',
-            (msg: ProxyConnectionRequest, context) => this.requestConnection(msg, context))
-    }
-
-    getConnection(nodeId: DhtAddress): ProxyConnection | undefined {
-        return this.connections.get(nodeId)
-    }
-
-    hasConnection(nodeId: DhtAddress): boolean {
-        return this.connections.has(nodeId)
-    }
-
-    removeConnection(nodeId: DhtAddress): void {
-        this.connections.delete(nodeId)
-    }
-
-    stop(): void {
-        this.connections.forEach((connection) => connection.remote.leaveStreamPartNotice(this.options.streamPartId, false))
-        this.connections.clear()
-        this.removeAllListeners()
-    }
-
-    getPropagationTargets(msg: StreamMessage): DhtAddress[] {
-        if (msg.body.oneofKind === 'groupKeyRequest') {
-            try {
-                const recipientId = msg.body.groupKeyRequest.recipientId
-                return this.getNodeIdsForUserId(toEthereumAddress(binaryToHex(recipientId, true)))
-            } catch (err) {
-                logger.trace(`Could not parse GroupKeyRequest`, { err })
-                return []
-            }
-        } else {
-            return this.getSubscribers()
-        }
-    }
-
-    private getNodeIdsForUserId(userId: UserID): DhtAddress[] {
-        return Array.from(this.connections.keys()).filter((nodeId) => this.connections.get(nodeId)!.userId === userId)
-    }
-
-    private getSubscribers(): DhtAddress[] {
-        return Array.from(this.connections.keys()).filter((key) => this.connections.get(key)!.direction === ProxyDirection.SUBSCRIBE)
-    }
-
-    // IProxyConnectionRpc server method
-    async requestConnection(request: ProxyConnectionRequest, context: ServerCallContext): Promise<ProxyConnectionResponse> {
-        const senderPeerDescriptor = (context as DhtCallContext).incomingSourceDescriptor!
-        const remoteNodeId = toNodeId(senderPeerDescriptor)
-        this.connections.set(remoteNodeId, {
-            direction: request.direction,
-            userId: toEthereumAddress(binaryToHex(request.userId, true)),
-            remote: new ContentDeliveryRpcRemote(
-                this.options.localPeerDescriptor,
-                senderPeerDescriptor,
-                this.options.rpcCommunicator,
-                ContentDeliveryRpcClient
-            )
-        })
-        const response: ProxyConnectionResponse = {
-            accepted: true
-        }
-        logger.trace(`Accepted connection request from ${remoteNodeId} to ${this.options.streamPartId}`)
-        this.emit('newConnection', remoteNodeId)
-        return response
-    }
-}

package/src/logic/proxy/ProxyConnectionRpcRemote.ts

@@ -1,26 +0,0 @@
-import { EXISTING_CONNECTION_TIMEOUT, RpcRemote } from '@streamr/dht'
-import { Logger, UserID, hexToBinary } from '@streamr/utils'
-import { ProxyConnectionRequest, ProxyDirection } from '../../proto/packages/trackerless-network/protos/NetworkRpc'
-import { ProxyConnectionRpcClient } from '../../proto/packages/trackerless-network/protos/NetworkRpc.client'
-
-const logger = new Logger(module)
-
-export class ProxyConnectionRpcRemote extends RpcRemote<ProxyConnectionRpcClient> {
-
-    async requestConnection(direction: ProxyDirection, userId: UserID): Promise<boolean> {
-        const request: ProxyConnectionRequest = {
-            direction,
-            userId: hexToBinary(userId)
-        }
-        const options = this.formDhtRpcOptions({
-            timeout: EXISTING_CONNECTION_TIMEOUT
-        })
-        try {
-            const res = await this.getClient().requestConnection(request, options)
-            return res.accepted
-        } catch (err) {
-            logger.debug(`ProxyConnectionRequest failed with error`, { err })
-            return false
-        }
-    }
-}

package/src/logic/temporary-connection/TemporaryConnectionRpcLocal.ts

@@ -1,73 +0,0 @@
-import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
-import { ConnectionLocker, DhtAddress, DhtCallContext, ListeningRpcCommunicator, toNodeId } from '@streamr/dht'
-import { StreamPartID } from '@streamr/utils'
-import { Empty } from '../../proto/google/protobuf/empty'
-import { PeerDescriptor } from '../../proto/packages/dht/protos/DhtRpc'
-import {
-    CloseTemporaryConnection,
-    TemporaryConnectionRequest,
-    TemporaryConnectionResponse
-} from '../../proto/packages/trackerless-network/protos/NetworkRpc'
-import { ContentDeliveryRpcClient } from '../../proto/packages/trackerless-network/protos/NetworkRpc.client'
-import { ITemporaryConnectionRpc } from '../../proto/packages/trackerless-network/protos/NetworkRpc.server'
-import { ContentDeliveryRpcRemote } from '../ContentDeliveryRpcRemote'
-import { NodeList } from '../NodeList'
-
-interface TemporaryConnectionRpcLocalOptions {
-    rpcCommunicator: ListeningRpcCommunicator
-    localPeerDescriptor: PeerDescriptor
-    streamPartId: StreamPartID
-    connectionLocker: ConnectionLocker
-} 
-
-const LOCK_ID_BASE = 'system/content-delivery/temporary-connection/'
-
-export class TemporaryConnectionRpcLocal implements ITemporaryConnectionRpc {
-
-    private readonly options: TemporaryConnectionRpcLocalOptions
-    private readonly temporaryNodes: NodeList
-    private readonly lockId: string
-    constructor(options: TemporaryConnectionRpcLocalOptions) {
-        this.options = options
-        // TODO use options option or named constant?
-        this.temporaryNodes = new NodeList(toNodeId(options.localPeerDescriptor), 10)
-        this.lockId = LOCK_ID_BASE + options.streamPartId
-    }
-
-    getNodes(): NodeList {
-        return this.temporaryNodes
-    }
-
-    hasNode(node: DhtAddress): boolean {
-        return this.temporaryNodes.has(node)
-    }
-
-    removeNode(nodeId: DhtAddress): void {
-        this.temporaryNodes.remove(nodeId)
-        this.options.connectionLocker.weakUnlockConnection(nodeId, this.lockId)
-    }
-
-    async openConnection(
-        _request: TemporaryConnectionRequest,
-        context: ServerCallContext
-    ): Promise<TemporaryConnectionResponse> {
-        const sender = (context as DhtCallContext).incomingSourceDescriptor!
-        const remote = new ContentDeliveryRpcRemote(
-            this.options.localPeerDescriptor,
-            sender,
-            this.options.rpcCommunicator,
-            ContentDeliveryRpcClient
-        )
-        this.temporaryNodes.add(remote)
-        this.options.connectionLocker.weakLockConnection(toNodeId(sender), this.lockId)
-        return {
-            accepted: true
-        }
-    }
-
-    async closeConnection(_request: CloseTemporaryConnection, context: ServerCallContext): Promise<Empty> {
-        const remoteNodeId = toNodeId((context as DhtCallContext).incomingSourceDescriptor!)
-        this.removeNode(remoteNodeId)
-        return {}
-    }
-}

package/src/logic/temporary-connection/TemporaryConnectionRpcRemote.ts

@@ -1,29 +0,0 @@
-import { RpcRemote, toNodeId } from '@streamr/dht'
-import { Logger } from '@streamr/utils'
-import { TemporaryConnectionRpcClient } from '../../proto/packages/trackerless-network/protos/NetworkRpc.client'
-
-const logger = new Logger(module)
-
-export class TemporaryConnectionRpcRemote extends RpcRemote<TemporaryConnectionRpcClient> {
-
-    async openConnection(): Promise<boolean> {
-        try {
-            const response = await this.getClient().openConnection({}, this.formDhtRpcOptions())
-            return response.accepted
-        } catch (err: any) {
-            logger.debug(`temporaryConnection to ${toNodeId(this.getPeerDescriptor())} failed`, { err })
-            return false
-        }
-    }
-
-    async closeConnection(): Promise<void> {
-        try {
-            await this.getClient().closeConnection({}, this.formDhtRpcOptions({
-                connect: false,
-                notification: true
-            }))
-        } catch (err) {
-            logger.trace(`closeConnection to ${toNodeId(this.getPeerDescriptor())} failed`, { err })
-        }
-    }
-}

package/src/logic/utils.ts

@@ -1,18 +0,0 @@
-import { DuplicateMessageDetector, NumberPair } from './DuplicateMessageDetector' 
-import { MessageID, MessageRef } from '../proto/packages/trackerless-network/protos/NetworkRpc'
-import { binaryToHex } from '@streamr/utils'
-
-export const markAndCheckDuplicate = (
-    duplicateDetectors: Map<string, DuplicateMessageDetector>,
-    currentMessage: MessageID, 
-    previousMessageRef?: MessageRef
-): boolean => {
-    const detectorKey = `${binaryToHex(currentMessage.publisherId)}-${currentMessage.messageChainId}`
-    const previousNumberPair = previousMessageRef ?
-        new NumberPair(Number(previousMessageRef.timestamp), previousMessageRef.sequenceNumber) : null
-    const currentNumberPair = new NumberPair(Number(currentMessage.timestamp), currentMessage.sequenceNumber)
-    if (!duplicateDetectors.has(detectorKey)) {
-        duplicateDetectors.set(detectorKey, new DuplicateMessageDetector())
-    }
-    return duplicateDetectors.get(detectorKey)!.markAndCheck(previousNumberPair, currentNumberPair)
-}