@streamr/trackerless-network 0.0.1-tatum.0

package/src/logic/StreamEntryPointDiscovery.ts

@@ -0,0 +1,221 @@
+import { createHash } from 'crypto'
+import {
+    isSamePeerDescriptor,
+    PeerDescriptor,
+    RecursiveFindResult,
+    DataEntry
+} from '@streamr/dht'
+import { Any } from '../proto/google/protobuf/any'
+import { Logger, setAbortableTimeout, wait } from '@streamr/utils'
+import { StreamObject } from './StreamrNode'
+
+export const streamPartIdToDataKey = (streamPartId: string): Uint8Array => {
+    return new Uint8Array(createHash('md5').update(streamPartId).digest())
+}
+
+const parseEntryPointData = (dataEntries: DataEntry[]): PeerDescriptor[] => {
+    return dataEntries!.filter((entry) => !entry.deleted).map((entry) => Any.unpack(entry.data!, PeerDescriptor))
+}
+
+interface FindEntryPointsResult {
+    joiningEmptyStream: boolean
+    entryPointsFromDht: boolean
+    discoveredEntryPoints: PeerDescriptor[]
+}
+
+const exponentialRunOff = async (
+    task: () => Promise<void>,
+    description: string,
+    abortSignal: AbortSignal,
+    baseDelay = 500,
+    maxAttempts = 6
+): Promise<void> => {
+    for (let i = 1; i <= maxAttempts; i++) {
+        if (abortSignal.aborted) {
+            return
+        }
+        const factor = 2 ** i
+        const delay = baseDelay * factor
+        try {
+            await task()
+        } catch (e: any) {
+            logger.trace(`${description} failed, retrying in ${delay} ms`)
+        }
+        try { // Abort controller throws unexpected errors in destroy?
+            await wait(delay, abortSignal)
+        } catch (err) {
+            logger.trace(`${err}`)
+        }
+    }
+}
+
+const logger = new Logger(module)
+
+const ENTRYPOINT_STORE_LIMIT = 8
+
+interface StreamEntryPointDiscoveryConfig {
+    streams: Map<string, StreamObject>
+    ownPeerDescriptor: PeerDescriptor
+    getEntryPointData: (key: Uint8Array) => Promise<RecursiveFindResult>
+    getEntryPointDataViaPeer: (key: Uint8Array, peer: PeerDescriptor) => Promise<DataEntry[]>
+    storeEntryPointData: (key: Uint8Array, data: Any) => Promise<PeerDescriptor[]>
+    deleteEntryPointData: (key: Uint8Array) => Promise<void>
+    cacheInterval?: number
+}
+
+export class StreamEntryPointDiscovery {
+    private readonly abortController: AbortController
+    private readonly config: StreamEntryPointDiscoveryConfig
+    private readonly servicedStreams: Map<string, NodeJS.Timeout>
+    private readonly cacheInterval: number
+
+    constructor(config: StreamEntryPointDiscoveryConfig) {
+        this.config = config
+        this.abortController = new AbortController()
+        this.cacheInterval = this.config.cacheInterval ?? 60000
+        this.servicedStreams = new Map()
+    }
+
+    async discoverEntryPointsFromDht(
+        streamPartID: string,
+        knownEntryPointCount: number,
+        forwardingPeer?: PeerDescriptor
+    ): Promise<FindEntryPointsResult> {
+        if (knownEntryPointCount > 0) {
+            return {
+                joiningEmptyStream: false,
+                entryPointsFromDht: false,
+                discoveredEntryPoints: []
+            }
+        }
+        let joiningEmptyStream = false
+        const discoveredEntryPoints = await this.discoverEntryPoints(streamPartID, forwardingPeer)
+        if (discoveredEntryPoints.length === 0) {
+            joiningEmptyStream = true
+            discoveredEntryPoints.push(this.config.ownPeerDescriptor)
+        }
+        return {
+            joiningEmptyStream,
+            discoveredEntryPoints,
+            entryPointsFromDht: true
+        }
+    }
+
+    private async discoverEntryPoints(streamPartId: string, forwardingPeer?: PeerDescriptor): Promise<PeerDescriptor[]> {
+        const dataKey = streamPartIdToDataKey(streamPartId)
+        return forwardingPeer ? 
+            this.queryEntryPointsViaPeer(dataKey, forwardingPeer) : await this.queryEntrypoints(dataKey)
+    }
+
+    private async queryEntrypoints(key: Uint8Array): Promise<PeerDescriptor[]> {
+        logger.trace(`Finding data from dht peer ${this.config.ownPeerDescriptor!.nodeName}`)
+        try {
+            const results = await this.config.getEntryPointData(key)
+            if (results.dataEntries) {
+                return parseEntryPointData(results.dataEntries)
+            } else {
+                return []
+            }
+        } catch (err) {
+            return []
+        }
+    }
+
+    private async queryEntryPointsViaPeer(key: Uint8Array, peer: PeerDescriptor): Promise<PeerDescriptor[]> {
+        logger.trace(`Finding data via peer ${this.config.ownPeerDescriptor!.nodeName}`)
+        try {
+            const results = await this.config.getEntryPointDataViaPeer(key, peer)
+            if (results) {
+                return parseEntryPointData(results)
+            } else {
+                return []
+            }
+        } catch (err) {
+            return []
+        }
+    }
+
+    async storeSelfAsEntryPointIfNecessary(
+        streamPartID: string,
+        joiningEmptyStream: boolean,
+        entryPointsFromDht: boolean,
+        currentEntrypointCount: number
+    ): Promise<void> {
+        if (joiningEmptyStream) {
+            await this.storeSelfAsEntryPoint(streamPartID)
+            setImmediate(() => this.avoidNetworkSplit(streamPartID))
+        } else if (entryPointsFromDht && currentEntrypointCount < ENTRYPOINT_STORE_LIMIT) {
+            try {
+                await this.storeSelfAsEntryPoint(streamPartID)
+            } catch (err) {
+                logger.trace(`Failed to store self as entrypoint on stream `)
+            }
+        }
+    }
+
+    private async storeSelfAsEntryPoint(streamPartId: string): Promise<void> {
+        const ownPeerDescriptor = this.config.ownPeerDescriptor
+        const dataToStore = Any.pack(ownPeerDescriptor, PeerDescriptor)
+        try {
+            await this.config.storeEntryPointData(streamPartIdToDataKey(streamPartId), dataToStore)
+            this.keepSelfAsEntryPoint(streamPartId)
+        } catch (err) {
+            logger.warn(`Failed to store self as entrypoint for ${streamPartId}`)
+        }
+    }
+
+    private keepSelfAsEntryPoint(streamPartId: string): void {
+        if (!this.config.streams.has(streamPartId) || this.servicedStreams.has(streamPartId)) {
+            return
+        }
+        this.servicedStreams.set(streamPartId, setTimeout(async () => {
+            if (!this.config.streams.has(streamPartId)) {
+                this.servicedStreams.delete(streamPartId)
+                return
+            }
+            logger.trace(`Attempting to keep self as entrypoint for ${streamPartId}`)
+            try {
+                const discovered = await this.discoverEntryPoints(streamPartId)
+                if (discovered.length < ENTRYPOINT_STORE_LIMIT 
+                    || discovered.some((peer) => isSamePeerDescriptor(peer, this.config.ownPeerDescriptor))) {
+                    await this.storeSelfAsEntryPoint(streamPartId)
+                    this.servicedStreams.delete(streamPartId)
+                    this.keepSelfAsEntryPoint(streamPartId)
+                } else {
+                    this.servicedStreams.delete(streamPartId)
+                }
+            } catch (err) {
+                logger.debug(`Failed to keep self as entrypoint for ${streamPartId}`)
+            }
+        }, this.cacheInterval))
+    }
+
+    private async avoidNetworkSplit(streamPartID: string): Promise<void> {
+        await exponentialRunOff(async () => {
+            if (this.config.streams.has(streamPartID)) {
+                const stream = this.config.streams.get(streamPartID)
+                const rediscoveredEntrypoints = await this.discoverEntryPoints(streamPartID)
+                await stream!.layer1!.joinDht(rediscoveredEntrypoints, false)
+                if (stream!.layer1!.getBucketSize() < 4) {
+                    throw new Error(`Network split is still possible`)
+                }
+            }
+        }, 'avoid network split', this.abortController.signal)
+        logger.trace(`Network split avoided`)
+    }
+
+    removeSelfAsEntryPoint(streamPartId: string): void {
+        if (this.servicedStreams.has(streamPartId)) {
+            setAbortableTimeout(() => this.config.deleteEntryPointData(streamPartIdToDataKey(streamPartId)), 0, this.abortController.signal)
+            clearTimeout(this.servicedStreams.get(streamPartId)!)
+            this.servicedStreams.delete(streamPartId)
+        }
+    }
+
+    async destroy(): Promise<void> {
+        this.servicedStreams.forEach((_, streamPartId) => this.removeSelfAsEntryPoint(streamPartId))
+        this.servicedStreams.clear()
+        this.abortController.abort()
+    }
+
+}

package/src/logic/StreamNodeServer.ts

@@ -0,0 +1,44 @@
+import { keyFromPeerDescriptor, ListeningRpcCommunicator, PeerDescriptor, DhtCallContext, PeerIDKey } from '@streamr/dht'
+import { Empty } from '../proto/google/protobuf/empty'
+import {
+    LeaveStreamNotice,
+    MessageRef,
+    StreamMessage
+} from '../proto/packages/trackerless-network/protos/NetworkRpc'
+import { INetworkRpc } from '../proto/packages/trackerless-network/protos/NetworkRpc.server'
+import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
+
+export interface StreamNodeServerConfig {
+    ownPeerDescriptor: PeerDescriptor
+    randomGraphId: string
+    markAndCheckDuplicate: (messageRef: MessageRef, previousMessageRef?: MessageRef) => boolean
+    broadcast: (message: StreamMessage, previousPeer?: string) => void
+    onLeaveNotice(notice: LeaveStreamNotice): void
+    markForInspection(senderId: PeerIDKey, messageRef: MessageRef): void
+    rpcCommunicator: ListeningRpcCommunicator
+}
+
+export class StreamNodeServer implements INetworkRpc {
+    
+    private readonly config: StreamNodeServerConfig
+
+    constructor(config: StreamNodeServerConfig) {
+        this.config = config
+    }
+
+    async sendData(message: StreamMessage, context: ServerCallContext): Promise<Empty> {
+        const previousPeer = keyFromPeerDescriptor((context as DhtCallContext).incomingSourceDescriptor!)
+        this.config.markForInspection(previousPeer, message.messageRef!)
+        if (this.config.markAndCheckDuplicate(message.messageRef!, message.previousMessageRef)) {
+            this.config.broadcast(message, previousPeer)
+        }
+        return Empty
+    }
+
+    async leaveStreamNotice(message: LeaveStreamNotice, _context: ServerCallContext): Promise<Empty> {
+        if (message.randomGraphId === this.config.randomGraphId) {
+            this.config.onLeaveNotice(message)
+        }
+        return Empty
+    }
+}

package/src/logic/StreamrNode.ts

@@ -0,0 +1,416 @@
+import { RandomGraphNode } from './RandomGraphNode'
+import {
+    PeerDescriptor,
+    ConnectionLocker,
+    DhtNode,
+    ITransport,
+    keyFromPeerDescriptor
+} from '@streamr/dht'
+import { StreamMessage } from '../proto/packages/trackerless-network/protos/NetworkRpc'
+import { EventEmitter } from 'eventemitter3'
+import {
+    Logger,
+    MetricsContext,
+    RateMetric,
+    Metric,
+    MetricsDefinition,
+    waitForEvent3
+} from '@streamr/utils'
+import { uniq } from 'lodash'
+import { StreamPartID, StreamPartIDUtils } from '@streamr/protocol'
+import { sampleSize } from 'lodash'
+import { StreamEntryPointDiscovery } from './StreamEntryPointDiscovery'
+import { ILayer0 } from './ILayer0'
+import { createRandomGraphNode } from './createRandomGraphNode'
+import { ProxyDirection } from '../proto/packages/trackerless-network/protos/NetworkRpc'
+import { IStreamNode } from './IStreamNode'
+import { ProxyStreamConnectionClient } from './proxy/ProxyStreamConnectionClient'
+import { PeerIDKey } from '@streamr/dht/src/exports'
+
+export enum StreamNodeType {
+    RANDOM_GRAPH = 'random-graph',
+    PROXY = 'proxy'
+}
+
+export interface NeighborCounterEvents {
+    targetReached: () => void
+}
+
+class NeighborCounter {
+
+    private counter = 0
+    private readonly emitter = new EventEmitter<NeighborCounterEvents>()
+    private readonly randomGraphNode: RandomGraphNode
+    private readonly targetNumberOfNeighbors: number
+
+    constructor(randomGraphNode: RandomGraphNode, targetNumberOfNeighbors: number) {
+        this.randomGraphNode = randomGraphNode
+        this.targetNumberOfNeighbors = targetNumberOfNeighbors
+        this.counter = randomGraphNode.getTargetNeighborStringIds().length
+        this.randomGraphNode.on('targetNeighborConnected', this.onTargetNeighborConnected)
+    }
+
+    private onTargetNeighborConnected = () => {
+        this.counter++
+        if (this.counter == this.targetNumberOfNeighbors) {
+            this.randomGraphNode.off('targetNeighborConnected', this.onTargetNeighborConnected)
+            this.emitter.emit('targetReached')
+        }
+    }
+
+    public async waitForTargetReached(timeout = 5000): Promise<void> {
+        if (this.counter >= this.targetNumberOfNeighbors) {
+            return
+        } else {
+            await waitForEvent3<NeighborCounterEvents>(this.emitter, 'targetReached', timeout)
+        }
+    }
+}
+
+export interface StreamObject {
+    layer1?: DhtNode
+    layer2: IStreamNode
+    type: StreamNodeType
+}
+
+export interface Events {
+    newMessage: (msg: StreamMessage) => void
+}
+
+const logger = new Logger(module)
+
+let cleanUp: () => Promise<void> = async () => { }
+
+interface Metrics extends MetricsDefinition {
+    publishMessagesPerSecond: Metric
+    publishBytesPerSecond: Metric
+}
+
+export interface StreamrNodeConfig {
+    metricsContext?: MetricsContext
+    id?: string
+    streamPartitionNumOfNeighbors?: number
+    streamPartitionMinPropagationTargets?: number
+    nodeName?: string
+    firstConnectionTimeout?: number
+    acceptProxyConnections?: boolean
+}
+
+export class StreamrNode extends EventEmitter<Events> {
+    private P2PTransport?: ITransport
+    private connectionLocker?: ConnectionLocker
+    private layer0?: ILayer0
+    private streamEntryPointDiscovery?: StreamEntryPointDiscovery
+    private readonly metricsContext: MetricsContext
+    private readonly metrics: Metrics
+    public config: StreamrNodeConfig
+    private readonly streams: Map<string, StreamObject>
+    private readonly knownStreamEntryPoints: Map<string, PeerDescriptor[]> = new Map()
+    protected extraMetadata: Record<string, unknown> = {}
+    private started = false
+    private destroyed = false
+
+    constructor(config: StreamrNodeConfig) {
+        super()
+        this.config = config
+        this.streams = new Map()
+        this.metricsContext = config.metricsContext ?? new MetricsContext()
+        this.metrics = {
+            publishMessagesPerSecond: new RateMetric(),
+            publishBytesPerSecond: new RateMetric()
+        }
+        this.metricsContext.addMetrics('node', this.metrics)
+    }
+
+    async start(startedAndJoinedLayer0: ILayer0, transport: ITransport, connectionLocker: ConnectionLocker): Promise<void> {
+        if (this.started || this.destroyed) {
+            return
+        }
+        logger.info(`Starting new StreamrNode with id ${keyFromPeerDescriptor(startedAndJoinedLayer0.getPeerDescriptor())}`)
+        this.started = true
+        this.layer0 = startedAndJoinedLayer0
+        this.P2PTransport = transport
+        this.connectionLocker = connectionLocker
+        this.streamEntryPointDiscovery = new StreamEntryPointDiscovery({
+            ownPeerDescriptor: this.getPeerDescriptor(),
+            streams: this.streams,
+            getEntryPointData: (key) => this.layer0!.getDataFromDht(key),
+            getEntryPointDataViaPeer: (peerDescriptor, key) => this.layer0!.findDataViaPeer(peerDescriptor, key),
+            storeEntryPointData: (key, data) => this.layer0!.storeDataToDht(key, data),
+            deleteEntryPointData: (key) => this.layer0!.deleteDataFromDht(key)
+        })
+        cleanUp = () => this.destroy()
+    }
+
+    async destroy(): Promise<void> {
+        if (!this.started || this.destroyed) {
+            return
+        }
+        logger.trace('Destroying StreamrNode...')
+        this.destroyed = true
+        this.streams.forEach((stream) => {
+            stream.layer2.stop()
+            stream.layer1?.stop()
+        })
+        await this.streamEntryPointDiscovery!.destroy()
+        this.streams.clear()
+        this.removeAllListeners()
+        await this.layer0!.stop()
+        await this.P2PTransport!.stop()
+        this.layer0 = undefined
+        this.P2PTransport = undefined
+        this.streamEntryPointDiscovery = undefined
+        this.connectionLocker = undefined
+    }
+
+    subscribeToStream(streamPartID: string): void {
+        if (!this.streams.has(streamPartID)) {
+            this.joinStream(streamPartID)
+                .catch((err) => {
+                    logger.warn(`Failed to subscribe to stream ${streamPartID} with error: ${err}`)
+                })
+        }
+    }
+
+    publishToStream(streamPartID: string, msg: StreamMessage): void {
+        if (this.streams.has(streamPartID)) {
+            this.streams.get(streamPartID)!.layer2.broadcast(msg)
+        } else {
+            this.joinStream(streamPartID)
+                .catch((err) => {
+                    logger.warn(`Failed to publish to stream ${streamPartID} with error: ${err}`)
+                })
+            this.streams.get(streamPartID)!.layer2.broadcast(msg)
+        }
+        this.metrics.publishMessagesPerSecond.record(1)
+        this.metrics.publishBytesPerSecond.record(msg.content.length)
+    }
+
+    unsubscribeFromStream(streamPartID: string): void {
+        this.leaveStream(streamPartID)
+    }
+
+    leaveStream(streamPartID: string): void {
+        const stream = this.streams.get(streamPartID)
+        if (stream) {
+            stream.layer2.stop()
+            stream.layer1?.stop()
+            this.streams.delete(streamPartID)
+        }
+        this.streamEntryPointDiscovery!.removeSelfAsEntryPoint(streamPartID)
+    }
+
+    async joinStream(streamPartId: string): Promise<void> {
+        if (this.streams.has(streamPartId)) {
+            return
+        }
+        logger.debug(`Joining stream ${streamPartId}`)
+        const knownEntryPoints = this.knownStreamEntryPoints.get(streamPartId) ?? []
+        let entryPoints = knownEntryPoints.concat(knownEntryPoints)
+        const [layer1, layer2] = this.createStream(streamPartId, knownEntryPoints)
+        await layer1.start()
+        await layer2.start()
+        const forwardingPeer = this.layer0!.isJoinOngoing() ? this.layer0!.getKnownEntryPoints()[0] : undefined
+        const discoveryResult = await this.streamEntryPointDiscovery!.discoverEntryPointsFromDht(
+            streamPartId,
+            knownEntryPoints.length,
+            forwardingPeer
+        )
+        entryPoints = knownEntryPoints.concat(discoveryResult.discoveredEntryPoints)
+        await layer1.joinDht(sampleSize(entryPoints, 4))
+        await this.streamEntryPointDiscovery!.storeSelfAsEntryPointIfNecessary(
+            streamPartId,
+            discoveryResult.joiningEmptyStream,
+            discoveryResult.entryPointsFromDht,
+            entryPoints.length
+        )
+    }
+
+    private createStream(streamPartID: string, entryPoints: PeerDescriptor[]): [DhtNode, RandomGraphNode] {
+        const layer1 = this.createLayer1Node(streamPartID, entryPoints)
+        const layer2 = this.createRandomGraphNode(streamPartID, layer1)
+        this.streams.set(streamPartID, {
+            type: StreamNodeType.RANDOM_GRAPH,
+            layer1,
+            layer2
+        })
+        layer2.on('message', (message: StreamMessage) => {
+            this.emit('newMessage', message)
+        })
+        return [layer1, layer2]
+    }
+
+    private createLayer1Node = (streamPartID: string, entryPoints: PeerDescriptor[]) => {
+        return new DhtNode({
+            transportLayer: this.layer0!,
+            serviceId: 'layer1::' + streamPartID,
+            peerDescriptor: this.layer0!.getPeerDescriptor(),
+            entryPoints: entryPoints,
+            numberOfNodesPerKBucket: 4,
+            rpcRequestTimeout: 15000,
+            dhtJoinTimeout: 60000,
+            nodeName: this.config.nodeName + ':layer1'
+        })
+    }
+
+    private createRandomGraphNode = (streamPartID: string, layer1: DhtNode) => {
+        return createRandomGraphNode({
+            randomGraphId: streamPartID,
+            P2PTransport: this.P2PTransport!,
+            layer1: layer1,
+            connectionLocker: this.connectionLocker!,
+            ownPeerDescriptor: this.layer0!.getPeerDescriptor(),
+            minPropagationTargets: this.config.streamPartitionMinPropagationTargets,
+            numOfTargetNeighbors: this.config.streamPartitionNumOfNeighbors,
+            name: this.config.nodeName,
+            acceptProxyConnections: this.config.acceptProxyConnections
+        })
+    }
+
+    async waitForJoinAndPublish(
+        streamPartId: string,
+        msg: StreamMessage,
+        timeout?: number
+    ): Promise<number> {
+        if (this.getStream(streamPartId)?.type === StreamNodeType.PROXY) {
+            return 0
+        }
+        await this.joinStream(streamPartId)
+        if (this.getStream(streamPartId)!.layer1!.getBucketSize() > 0) {
+            const neighborCounter = new NeighborCounter(this.getStream(streamPartId)!.layer2 as RandomGraphNode, 1)
+            await neighborCounter.waitForTargetReached(timeout)
+        }
+        this.publishToStream(streamPartId, msg)
+        return this.getStream(streamPartId)?.layer2.getTargetNeighborStringIds().length ?? 0
+    }
+
+    async waitForJoinAndSubscribe(
+        streamPartId: string,
+        timeout?: number,
+        expectedNeighbors = 1
+    ): Promise<number> {
+        if (this.getStream(streamPartId)?.type === StreamNodeType.PROXY) {
+            return 0
+        }
+        await this.joinStream(streamPartId)
+        if (this.getStream(streamPartId)!.layer1!.getBucketSize() > 0) {
+            const neighborCounter = new NeighborCounter(this.getStream(streamPartId)!.layer2 as RandomGraphNode, expectedNeighbors)
+            await neighborCounter.waitForTargetReached(timeout)
+        }
+        this.subscribeToStream(streamPartId)
+        return this.getStream(streamPartId)?.layer2.getTargetNeighborStringIds().length ?? 0
+    }
+
+    async setProxies(
+        streamPartId: string,
+        contactPeerDescriptors: PeerDescriptor[],
+        direction: ProxyDirection,
+        getUserId: () => Promise<string>,
+        connectionCount?: number
+    ): Promise<void> {
+        const userId = await getUserId()
+        if (this.streams.get(streamPartId)?.type === StreamNodeType.PROXY && contactPeerDescriptors.length > 0) {
+            const proxyClient = this.streams.get(streamPartId)!.layer2 as ProxyStreamConnectionClient
+            await proxyClient.setProxies(streamPartId, contactPeerDescriptors, direction, userId, connectionCount)
+        } else if (this.streams.get(streamPartId)?.type === StreamNodeType.PROXY && contactPeerDescriptors.length === 0) {
+            this.streams.get(streamPartId)!.layer2.stop()
+            this.streams.delete(streamPartId)
+        } else {
+            const proxyClient = this.createProxyStream(streamPartId, userId)
+            await proxyClient.start()
+            await proxyClient.setProxies(streamPartId, contactPeerDescriptors, direction, userId, connectionCount)
+        }
+    }
+
+    private createProxyStream(streamPartId: string, userId: string): ProxyStreamConnectionClient {
+        const layer2 = this.createProxyStreamConnectionClient(streamPartId, userId)
+        this.streams.set(streamPartId, {
+            type: StreamNodeType.PROXY,
+            layer2
+        })
+        layer2.on('message', (message: StreamMessage) => {
+            this.emit('newMessage', message)
+        })
+        return layer2
+    }
+
+    private createProxyStreamConnectionClient(streamPartId: string, userId: string): ProxyStreamConnectionClient {
+        return new ProxyStreamConnectionClient({
+            P2PTransport: this.P2PTransport!,
+            ownPeerDescriptor: this.layer0!.getPeerDescriptor(),
+            streamPartId: streamPartId,
+            connectionLocker: this.connectionLocker!,
+            nodeName: this.config.nodeName,
+            userId: userId
+        })
+    }
+
+    async inspect(peerDescriptor: PeerDescriptor, streamPartId: string): Promise<boolean> {
+        if (this.streams.get(streamPartId)?.type === StreamNodeType.RANDOM_GRAPH) {
+            const streamNode = this.streams.get(streamPartId)!.layer2 as RandomGraphNode
+            return streamNode.inspect(peerDescriptor)
+        }
+        return false
+    }
+
+    setStreamPartEntryPoints(streamPartId: string, entryPoints: PeerDescriptor[]): void {
+        this.knownStreamEntryPoints.set(streamPartId, entryPoints)
+    }
+
+    isProxiedStreamPart(streamId: string, direction: ProxyDirection): boolean {
+        return this.streams.get(streamId)?.type === StreamNodeType.PROXY 
+            && (this.streams.get(streamId)!.layer2 as ProxyStreamConnectionClient).getDirection() === direction
+    }
+
+    hasProxyConnection(streamId: string, peerKey: PeerIDKey, direction: ProxyDirection): boolean {
+        return this.streams.has(streamId) && this.streams.get(streamId)!.layer2.hasProxyConnection(peerKey, direction)
+    }
+
+    getStream(streamPartId: string): StreamObject | undefined {
+        return this.streams.get(streamPartId)
+    }
+
+    hasStream(streamPartId: string): boolean {
+        return this.streams.has(streamPartId)
+    }
+
+    getPeerDescriptor(): PeerDescriptor {
+        return this.layer0!.getPeerDescriptor()
+    }
+
+    getNodeId(): string {
+        return this.layer0!.getNodeId().toKey()
+    }
+
+    getNodeStringId(): string {
+        return this.layer0!.getNodeId().toString()
+    }
+
+    getNeighbors(): string[] {
+        const neighbors: string[] = []
+        this.streams.forEach((stream) =>
+            stream.layer2.getTargetNeighborStringIds().forEach((neighbor) => neighbors.push(neighbor))
+        )
+        return uniq(neighbors)
+    }
+
+    getStreamParts(): StreamPartID[] {
+        return Array.from(this.streams.keys()).map((stringId) => StreamPartIDUtils.parse(stringId))
+    }
+
+    setExtraMetadata(metadata: Record<string, unknown>): void {
+        this.extraMetadata = metadata
+    }
+
+    isJoinRequired(streamPartId: StreamPartID): boolean {
+        return !this.streams.has(streamPartId) && Array.from(this.streams.values()).every((stream) => stream.type === StreamNodeType.PROXY)
+    }
+
+}
+
+[`exit`, `SIGINT`, `SIGUSR1`, `SIGUSR2`, `uncaughtException`, `unhandledRejection`, `SIGTERM`].forEach((term) => {
+    process.on(term, async () => {
+        await cleanUp()
+        process.exit()
+    })
+})