@streamr/trackerless-network 102.0.0-beta.1 → 102.0.0-beta.3

package/dist/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@streamr/trackerless-network",
-    "version": "102.0.0-beta.1",
+    "version": "102.0.0-beta.3",
     "description": "Minimal and extendable implementation of the Streamr Network node.",
     "repository": {
         "type": "git",
@@ -30,9 +30,9 @@
     "dependencies": {
         "@protobuf-ts/runtime": "^2.8.2",
         "@protobuf-ts/runtime-rpc": "^2.8.2",
-        "@streamr/dht": "102.0.0-beta.1",
-        "@streamr/proto-rpc": "102.0.0-beta.1",
-        "@streamr/utils": "102.0.0-beta.1",
+        "@streamr/dht": "102.0.0-beta.3",
+        "@streamr/proto-rpc": "102.0.0-beta.3",
+        "@streamr/utils": "102.0.0-beta.3",
         "eventemitter3": "^5.0.0",
         "lodash": "^4.17.21",
         "ts-essentials": "^10.0.4",
@@ -41,7 +41,7 @@
     },
     "devDependencies": {
         "@streamr/browser-test-runner": "^0.0.1",
-        "@streamr/test-utils": "102.0.0-beta.1",
+        "@streamr/test-utils": "102.0.0-beta.3",
         "@types/lodash": "^4.17.14",
         "@types/yallist": "^4.0.1",
         "expect": "^29.6.2",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@streamr/trackerless-network",
-  "version": "102.0.0-beta.1",
+  "version": "102.0.0-beta.3",
   "description": "Minimal and extendable implementation of the Streamr Network node.",
   "repository": {
     "type": "git",
@@ -30,9 +30,9 @@
   "dependencies": {
     "@protobuf-ts/runtime": "^2.8.2",
     "@protobuf-ts/runtime-rpc": "^2.8.2",
-    "@streamr/dht": "102.0.0-beta.1",
-    "@streamr/proto-rpc": "102.0.0-beta.1",
-    "@streamr/utils": "102.0.0-beta.1",
+    "@streamr/dht": "102.0.0-beta.3",
+    "@streamr/proto-rpc": "102.0.0-beta.3",
+    "@streamr/utils": "102.0.0-beta.3",
     "eventemitter3": "^5.0.0",
     "lodash": "^4.17.21",
     "ts-essentials": "^10.0.4",
@@ -41,7 +41,7 @@
   },
   "devDependencies": {
     "@streamr/browser-test-runner": "^0.0.1",
-    "@streamr/test-utils": "102.0.0-beta.1",
+    "@streamr/test-utils": "102.0.0-beta.3",
     "@types/lodash": "^4.17.14",
     "@types/yallist": "^4.0.1",
     "expect": "^29.6.2",

package/src/NetworkNode.ts

@@ -1,142 +0,0 @@
-import { IMessageType } from '@protobuf-ts/runtime'
-import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
-import { DhtAddress, PeerDescriptor } from '@streamr/dht'
-import { ProtoRpcClient } from '@streamr/proto-rpc'
-import { MetricsContext, StreamPartID, UserID } from '@streamr/utils'
-import { ExternalNetworkRpc, ExternalRpcClient, ExternalRpcClientClass } from './logic/ExternalNetworkRpc'
-import { NetworkOptions, NetworkStack } from './NetworkStack'
-import { ProxyDirection, StreamMessage } from '../generated/packages/trackerless-network/protos/NetworkRpc'
-import { NodeInfo } from './types'
-
-export const createNetworkNode = (opts: NetworkOptions): NetworkNode => {
-    return new NetworkNode(new NetworkStack(opts))
-}
-
-/**
- * Convenience wrapper for building client-facing functionality. Used by client.
- */
-export class NetworkNode {
-
-    readonly stack: NetworkStack
-    private stopped = false
-    private externalNetworkRpc?: ExternalNetworkRpc
-
-    /** @internal */
-    constructor(stack: NetworkStack) {
-        this.stack = stack
-    }
-
-    async start(doJoin?: boolean): Promise<void> {
-        await this.stack.start(doJoin)
-        this.externalNetworkRpc = new ExternalNetworkRpc(this.stack.getControlLayerNode().getTransport())
-    }
-
-    async inspect(node: PeerDescriptor, streamPartId: StreamPartID): Promise<boolean> {
-        return this.stack.getContentDeliveryManager().inspect(node, streamPartId)
-    }
-
-    async broadcast(msg: StreamMessage): Promise<void> {
-        await this.stack.broadcast(msg)
-    }
-
-    async join(streamPartId: StreamPartID, neighborRequirement?: { minCount: number, timeout: number }): Promise<void> {
-        await this.stack.joinStreamPart(streamPartId, neighborRequirement)
-    }
-
-    async setProxies(
-        streamPartId: StreamPartID,
-        nodes: PeerDescriptor[],
-        direction: ProxyDirection,
-        userId: UserID,
-        connectionCount?: number
-    ): Promise<void> {
-        await this.stack.getContentDeliveryManager().setProxies(streamPartId, nodes, direction, userId, connectionCount)
-    }
-
-    isProxiedStreamPart(streamPartId: StreamPartID): boolean {
-        return this.stack.getContentDeliveryManager().isProxiedStreamPart(streamPartId)
-    }
-
-    addMessageListener(listener: (msg: StreamMessage) => void): void {
-        this.stack.getContentDeliveryManager().on('newMessage', listener)
-    }
-
-    setStreamPartEntryPoints(streamPartId: StreamPartID, contactPeerDescriptors: PeerDescriptor[]): void {
-        this.stack.getContentDeliveryManager().setStreamPartEntryPoints(streamPartId, contactPeerDescriptors)
-    }
-
-    removeMessageListener(listener: (msg: StreamMessage) => void): void {
-        this.stack.getContentDeliveryManager().off('newMessage', listener)
-    }
-
-    async leave(streamPartId: StreamPartID): Promise<void> {
-        if (this.stopped) {
-            return
-        }
-        await this.stack.getContentDeliveryManager().leaveStreamPart(streamPartId)
-    }
-
-    getNeighbors(streamPartId: StreamPartID): readonly DhtAddress[] {
-        return this.stack.getContentDeliveryManager().getNeighbors(streamPartId)
-    }
-
-    hasStreamPart(streamPartId: StreamPartID): boolean {
-        return this.stack.getContentDeliveryManager().hasStreamPart(streamPartId)
-    }
-
-    async stop(): Promise<void> {
-        this.stopped = true
-        this.externalNetworkRpc!.destroy()
-        await this.stack.stop()
-    }
-
-    getPeerDescriptor(): PeerDescriptor {
-        return this.stack.getControlLayerNode().getLocalPeerDescriptor()
-    }
-
-    getMetricsContext(): MetricsContext {
-        return this.stack.getMetricsContext()
-    }
-
-    getNodeId(): DhtAddress {
-        return this.stack.getContentDeliveryManager().getNodeId()
-    }
-
-    getOptions(): NetworkOptions {
-        return this.stack.getOptions()
-    }
-
-    getStreamParts(): StreamPartID[] {
-        return this.stack.getContentDeliveryManager().getStreamParts()
-    }
-
-    async fetchNodeInfo(node: PeerDescriptor): Promise<NodeInfo> {
-        return this.stack.fetchNodeInfo(node)
-    }
-
-    getDiagnosticInfo(): Record<string, unknown> {
-        return {
-            controlLayer: this.stack.getControlLayerNode().getDiagnosticInfo(),
-            contentLayer: this.stack.getContentDeliveryManager().getDiagnosticInfo()
-        }
-    }
-
-    registerExternalNetworkRpcMethod<
-        RequestClass extends IMessageType<RequestType>,
-        ResponseClass extends IMessageType<ResponseType>,
-        RequestType extends object,
-        ResponseType extends object
-    >(
-        request: RequestClass,
-        response: ResponseClass,
-        name: string, 
-        fn: (req: RequestType, context: ServerCallContext) => Promise<ResponseType>
-    ): void {
-        this.externalNetworkRpc!.registerRpcMethod(request, response, name, fn)
-    }
-
-    createExternalRpcClient<T extends ExternalRpcClient>(clientClass: ExternalRpcClientClass<T> ): ProtoRpcClient<T> {
-        return this.externalNetworkRpc!.createRpcClient(clientClass)
-    }
-
-}

package/src/NetworkStack.ts

@@ -1,197 +0,0 @@
-import {
-    ConnectionManager,
-    DhtNode,
-    DhtNodeOptions,
-    ListeningRpcCommunicator,
-    PeerDescriptor,
-    areEqualPeerDescriptors,
-    toNodeId
-} from '@streamr/dht'
-import { Logger, MetricsContext, StreamID, StreamPartID, toStreamPartID, until } from '@streamr/utils'
-import { pull } from 'lodash'
-import { version as applicationVersion } from '../package.json'
-import { ContentDeliveryManager, ContentDeliveryManagerOptions } from './logic/ContentDeliveryManager'
-import { ControlLayerNode } from './logic/ControlLayerNode'
-import { NodeInfoClient } from './logic/node-info/NodeInfoClient'
-import { NODE_INFO_RPC_SERVICE_ID, NodeInfoRpcLocal } from './logic/node-info/NodeInfoRpcLocal'
-import { ProxyDirection, StreamMessage } from '../generated/packages/trackerless-network/protos/NetworkRpc'
-import { NodeInfo } from './types'
-
-export interface NetworkOptions {
-    layer0?: DhtNodeOptions
-    networkNode?: ContentDeliveryManagerOptions
-    metricsContext?: MetricsContext
-}
-
-const logger = new Logger(module)
-
-const instances: NetworkStack[] = []
-const stopInstances = async () => {
-    // make a clone so that it is ok for each instance.stop() to remove itself from the list (at line 139)
-    // while the map function is iterating the list
-    const clonedInstances = [...instances]
-    await Promise.all(clonedInstances.map((instance) => instance.stop()))
-}
-const EXIT_EVENTS = [`exit`, `SIGINT`, `SIGUSR1`, `SIGUSR2`, `uncaughtException`, `unhandledRejection`, `SIGTERM`]
-EXIT_EVENTS.forEach((event) => {
-    process.on(event, async (eventArg) => {
-        const isError = (event === 'uncaughtException') || (event === 'unhandledRejection')
-        if (isError) {
-            logger.error(`exit event: ${event}`, eventArg)
-        }
-        await stopInstances()
-        process.exit(isError ? 1 : 0)
-    })
-})
-declare let window: any
-if (typeof window === 'object') {
-    window.addEventListener('unload', async () => {
-        await stopInstances()
-    })
-}
-
-export class NetworkStack {
-
-    private controlLayerNode?: ControlLayerNode
-    private contentDeliveryManager?: ContentDeliveryManager
-    private stopped = false
-    private readonly metricsContext: MetricsContext
-    private readonly options: NetworkOptions
-    private nodeInfoRpcLocal?: NodeInfoRpcLocal
-    private nodeInfoClient?: NodeInfoClient
-
-    constructor(options: NetworkOptions) {
-        this.options = options
-        this.metricsContext = options.metricsContext ?? new MetricsContext()
-        this.controlLayerNode = new DhtNode({
-            ...options.layer0,
-            metricsContext: this.metricsContext,
-            allowIncomingPrivateConnections: options.networkNode?.acceptProxyConnections
-        })
-        this.contentDeliveryManager = new ContentDeliveryManager({
-            ...options.networkNode,
-            metricsContext: this.metricsContext
-        })
-        instances.push(this)
-    }
-
-    async joinStreamPart(streamPartId: StreamPartID, neighborRequirement?: { minCount: number, timeout: number }): Promise<void> {
-        if (this.getContentDeliveryManager().isProxiedStreamPart(streamPartId)) {
-            throw new Error(`Cannot join to ${streamPartId} as proxy connections have been set`)
-        }
-        await this.ensureConnectedToControlLayer()
-        this.getContentDeliveryManager().joinStreamPart(streamPartId)
-        if (neighborRequirement !== undefined) {
-            await until(() => {
-                return this.getContentDeliveryManager().getNeighbors(streamPartId).length >= neighborRequirement.minCount
-            }, neighborRequirement.timeout)
-        }
-    }
-
-    async broadcast(msg: StreamMessage): Promise<void> {
-        const streamPartId = toStreamPartID(msg.messageId!.streamId as StreamID, msg.messageId!.streamPartition)
-        if (
-            this.getContentDeliveryManager().isProxiedStreamPart(streamPartId, ProxyDirection.SUBSCRIBE) 
-            && (msg.body.oneofKind === 'contentMessage')
-        ) {
-            throw new Error(`Cannot broadcast to ${streamPartId} as proxy subscribe connections have been set`)
-        }
-        // TODO could combine these two calls to isProxiedStreamPart?
-        if (!this.contentDeliveryManager!.isProxiedStreamPart(streamPartId)) {
-            await this.ensureConnectedToControlLayer()
-        }
-        this.getContentDeliveryManager().broadcast(msg)
-    }
-
-    async start(doJoin = true): Promise<void> {
-        logger.info('Starting a Streamr Network Node')
-        await this.controlLayerNode!.start()
-        logger.info(`Node id is ${toNodeId(this.controlLayerNode!.getLocalPeerDescriptor())}`)
-        const connectionManager = this.controlLayerNode!.getTransport() as ConnectionManager
-        if ((this.options.layer0?.entryPoints?.some((entryPoint) => 
-            areEqualPeerDescriptors(entryPoint, this.controlLayerNode!.getLocalPeerDescriptor())
-        ))) {
-            await this.controlLayerNode?.joinDht(this.options.layer0.entryPoints)
-        } else if (doJoin) {
-            // in practice there aren't be existing connections and therefore this always connects
-            await this.ensureConnectedToControlLayer()
-        }
-        // TODO: remove undefined checks here. Assume that start is approproately awaited before stop is called.
-        await this.contentDeliveryManager?.start(this.controlLayerNode!, connectionManager, connectionManager)
-        if (this.contentDeliveryManager) {
-            const infoRpcCommunicator = new ListeningRpcCommunicator(NODE_INFO_RPC_SERVICE_ID, this.getConnectionManager())
-            this.nodeInfoRpcLocal = new NodeInfoRpcLocal(this, infoRpcCommunicator)
-            this.nodeInfoClient = new NodeInfoClient(
-                this.controlLayerNode!.getLocalPeerDescriptor(),
-                infoRpcCommunicator
-            )
-        }
-    }
-
-    private async ensureConnectedToControlLayer(): Promise<void> {
-        // TODO we could wrap joinDht with pOnce and call it here (no else-if needed in that case)
-        if (!this.controlLayerNode!.hasJoined()) {
-            setImmediate(async () => {
-                if (this.options.layer0?.entryPoints !== undefined) {
-                    // TODO should catch possible rejection?
-                    // the question mark is there to avoid problems when stop() is called before start()
-                    // -> TODO change to exlamation mark if we don't support that (and remove NetworkStackStoppedDuringStart.test)
-                    await this.controlLayerNode?.joinDht(this.options.layer0.entryPoints)
-                }
-            })
-            await this.controlLayerNode!.waitForNetworkConnectivity()
-        }
-    }
-
-    getContentDeliveryManager(): ContentDeliveryManager {
-        return this.contentDeliveryManager!
-    }
-
-    getControlLayerNode(): ControlLayerNode {
-        return this.controlLayerNode!
-    }
-
-    getMetricsContext(): MetricsContext {
-        return this.metricsContext
-    }
-
-    async fetchNodeInfo(node: PeerDescriptor): Promise<NodeInfo> {
-        if (!areEqualPeerDescriptors(node, this.getControlLayerNode().getLocalPeerDescriptor())) {
-            return this.nodeInfoClient!.getInfo(node)
-        } else {
-            return this.createNodeInfo()
-        }
-    }
-
-    createNodeInfo(): NodeInfo {
-        return {
-            peerDescriptor: this.getControlLayerNode().getLocalPeerDescriptor(),
-            controlLayer: {
-                connections: this.getControlLayerNode().getConnectionsView().getConnections(),
-                neighbors: this.getControlLayerNode().getNeighbors()
-            },
-            streamPartitions: this.getContentDeliveryManager().getNodeInfo(),
-            applicationVersion
-        }
-    }
-
-    getOptions(): NetworkOptions {
-        return this.options
-    }
-
-    private getConnectionManager(): ConnectionManager {
-        return this.controlLayerNode!.getTransport() as ConnectionManager
-    }
-
-    async stop(): Promise<void> {
-        if (!this.stopped) {
-            this.stopped = true
-            pull(instances, this)
-            await this.contentDeliveryManager!.destroy()
-            await this.controlLayerNode!.stop()
-            this.contentDeliveryManager = undefined
-            this.controlLayerNode = undefined
-        }
-    }
-
-}

package/src/exports.ts

@@ -1,18 +0,0 @@
-export { NetworkNode, createNetworkNode } from './NetworkNode'
-export { NetworkOptions, NetworkStack } from './NetworkStack'
-export { ContentDeliveryManagerOptions, streamPartIdToDataKey } from './logic/ContentDeliveryManager'
-export {
-    ContentType,
-    EncryptionType,
-    GroupKey,
-    GroupKeyRequest,
-    GroupKeyResponse,
-    MessageID,
-    MessageRef,
-    ProxyDirection,
-    SignatureType,
-    StreamMessage,
-    ControlLayerInfo
-} from '../generated/packages/trackerless-network/protos/NetworkRpc'
-export { ExternalRpcClient, ExternalRpcClientClass } from './logic/ExternalNetworkRpc'
-export { NodeInfo, StreamPartitionInfo, ContentDeliveryLayerNeighborInfo } from './types'