@streamr/trackerless-network 100.2.4-beta.0 → 100.2.5-beta.0

package/src/logic/ContentDeliveryManager.ts

@@ -19,12 +19,14 @@ import {
 import { EventEmitter } from 'eventemitter3'
 import { sampleSize } from 'lodash'
 import { ProxyDirection, StreamMessage, StreamPartitionInfo } from '../proto/packages/trackerless-network/protos/NetworkRpc'
-import { EntryPointDiscovery, NETWORK_SPLIT_AVOIDANCE_LIMIT } from './EntryPointDiscovery'
+import { ENTRYPOINT_STORE_LIMIT, EntryPointDiscovery } from './EntryPointDiscovery'
 import { Layer0Node } from './Layer0Node'
 import { Layer1Node } from './Layer1Node'
 import { ContentDeliveryLayerNode } from './ContentDeliveryLayerNode'
 import { createContentDeliveryLayerNode } from './createContentDeliveryLayerNode'
 import { ProxyClient } from './proxy/ProxyClient'
+import { StreamPartReconnect } from './StreamPartReconnect'
+import { MIN_NEIGHBOR_COUNT as NETWORK_SPLIT_AVOIDANCE_MIN_NEIGHBOR_COUNT, StreamPartNetworkSplitAvoidance } from './StreamPartNetworkSplitAvoidance'
 
 export type StreamPartDelivery = {
     broadcast: (msg: StreamMessage) => void
@@ -34,6 +36,7 @@ export type StreamPartDelivery = {
     layer1Node: Layer1Node
     node: ContentDeliveryLayerNode
     entryPointDiscovery: EntryPointDiscovery
+    networkSplitAvoidance: StreamPartNetworkSplitAvoidance
 } | {
     proxied: true
     client: ProxyClient
@@ -136,23 +139,30 @@ export class ContentDeliveryManager extends EventEmitter<Events> {
         const entryPointDiscovery = new EntryPointDiscovery({
             streamPartId,
             localPeerDescriptor: this.getPeerDescriptor(),
-            layer1Node,
             fetchEntryPointData: (key) => this.layer0Node!.fetchDataFromDht(key),
             storeEntryPointData: (key, data) => this.layer0Node!.storeDataToDht(key, data),
             deleteEntryPointData: async (key) => this.layer0Node!.deleteDataFromDht(key, false)
         })
+        const networkSplitAvoidance = new StreamPartNetworkSplitAvoidance({
+            layer1Node,
+            discoverEntryPoints: async () => entryPointDiscovery.discoverEntryPoints()
+        })
         const node = this.createContentDeliveryLayerNode(
             streamPartId,
             layer1Node, 
             () => entryPointDiscovery.isLocalNodeEntryPoint()
         )
+        const streamPartReconnect = new StreamPartReconnect(layer1Node, entryPointDiscovery)
         streamPart = {
             proxied: false,
             layer1Node,
             node,
             entryPointDiscovery,
+            networkSplitAvoidance,
             broadcast: (msg: StreamMessage) => node.broadcast(msg),
             stop: async () => {
+                streamPartReconnect.destroy()
+                networkSplitAvoidance.destroy()
                 await entryPointDiscovery.destroy()
                 node.stop()
                 await layer1Node.stop()
@@ -166,9 +176,17 @@ export class ContentDeliveryManager extends EventEmitter<Events> {
             if (this.destroyed || entryPointDiscovery.isLocalNodeEntryPoint() || this.knownStreamPartEntryPoints.has(streamPartId)) {
                 return
             }
-            const entryPoints = await entryPointDiscovery.discoverEntryPointsFromDht(0)
-            await entryPointDiscovery.storeSelfAsEntryPointIfNecessary(entryPoints.discoveredEntryPoints.length)
+            const entryPoints = await entryPointDiscovery.discoverEntryPoints()
+            if (entryPoints.length < ENTRYPOINT_STORE_LIMIT) {
+                await entryPointDiscovery.storeAndKeepLocalNodeAsEntryPoint()
+            }
         }
+        layer1Node.on('manualRejoinRequired', async () => {
+            if (!streamPartReconnect.isRunning() && !networkSplitAvoidance.isRunning()) {
+                logger.debug('Manual rejoin required for stream part', { streamPartId })
+                await streamPartReconnect.reconnect()
+            }
+        })
         node.on('entryPointLeaveDetected', () => handleEntryPointLeave())
         setImmediate(async () => {
             try {
@@ -188,29 +206,39 @@ export class ContentDeliveryManager extends EventEmitter<Events> {
         }
         await streamPart.layer1Node.start()
         await streamPart.node.start()
-        let entryPoints = this.knownStreamPartEntryPoints.get(streamPartId) ?? []
-        const discoveryResult = await entryPointDiscovery.discoverEntryPointsFromDht(
-            entryPoints.length
-        )
-        entryPoints = entryPoints.concat(discoveryResult.discoveredEntryPoints)
-        await Promise.all([
-            streamPart.layer1Node.joinDht(sampleSize(entryPoints, NETWORK_SPLIT_AVOIDANCE_LIMIT)),
-            streamPart.layer1Node.joinRing()
-        ])
-        if (discoveryResult.entryPointsFromDht) {
-            await entryPointDiscovery.storeSelfAsEntryPointIfNecessary(entryPoints.length)
+        const knownEntryPoints = this.knownStreamPartEntryPoints.get(streamPartId)
+        if (knownEntryPoints !== undefined) {
+            await Promise.all([
+                streamPart.layer1Node.joinDht(knownEntryPoints),
+                streamPart.layer1Node.joinRing()
+            ])
+        } else {
+            const entryPoints = await entryPointDiscovery.discoverEntryPoints()
+            await Promise.all([
+                streamPart.layer1Node.joinDht(sampleSize(entryPoints, NETWORK_SPLIT_AVOIDANCE_MIN_NEIGHBOR_COUNT)),
+                streamPart.layer1Node.joinRing()
+            ])
+            if (entryPoints.length < ENTRYPOINT_STORE_LIMIT) {
+                await entryPointDiscovery.storeAndKeepLocalNodeAsEntryPoint()
+                if (streamPart.layer1Node.getNeighborCount() < NETWORK_SPLIT_AVOIDANCE_MIN_NEIGHBOR_COUNT) {
+                    setImmediate(() => streamPart.networkSplitAvoidance.avoidNetworkSplit())
+                }
+            }
         }
     }
 
     private createLayer1Node(streamPartId: StreamPartID, entryPoints: PeerDescriptor[]): Layer1Node {
         return new DhtNode({
             transport: this.layer0Node!,
+            connectionsView: this.layer0Node!.getConnectionsView(),
             serviceId: 'layer1::' + streamPartId,
             peerDescriptor: this.layer0Node!.getLocalPeerDescriptor(),
             entryPoints,
             numberOfNodesPerKBucket: 4,  // TODO use config option or named constant?
             rpcRequestTimeout: EXISTING_CONNECTION_TIMEOUT,
-            dhtJoinTimeout: 20000  // TODO use config option or named constant?
+            dhtJoinTimeout: 20000,  // TODO use config option or named constant?
+            periodicallyPingNeighbors: true,
+            periodicallyPingRingContacts: true
         })
     }
 

package/src/logic/EntryPointDiscovery.ts

@@ -3,14 +3,12 @@ import {
     DhtAddress,
     PeerDescriptor,
     areEqualPeerDescriptors,
-    getDhtAddressFromRaw,
-    getNodeIdFromPeerDescriptor
+    getDhtAddressFromRaw
 } from '@streamr/dht'
 import { StreamPartID } from '@streamr/protocol'
-import { Logger, scheduleAtInterval, wait } from '@streamr/utils'
+import { Logger, scheduleAtInterval } from '@streamr/utils'
 import { createHash } from 'crypto'
 import { Any } from '../proto/google/protobuf/any'
-import { Layer1Node } from './Layer1Node'
 
 export const streamPartIdToDataKey = (streamPartId: StreamPartID): DhtAddress => {
     return getDhtAddressFromRaw(new Uint8Array((createHash('sha1').update(streamPartId).digest())))
@@ -20,46 +18,13 @@ const parseEntryPointData = (dataEntries: DataEntry[]): PeerDescriptor[] => {
     return dataEntries.filter((entry) => !entry.deleted).map((entry) => Any.unpack(entry.data!, PeerDescriptor))
 }
 
-interface FindEntryPointsResult {
-    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}`)  // TODO Do we need logging?
-        }
-    }
-}
-
 const logger = new Logger(module)
 
 export const ENTRYPOINT_STORE_LIMIT = 8
-export const NETWORK_SPLIT_AVOIDANCE_LIMIT = 4
 
 interface EntryPointDiscoveryConfig {
     streamPartId: StreamPartID
     localPeerDescriptor: PeerDescriptor
-    layer1Node: Layer1Node
     fetchEntryPointData: (key: DhtAddress) => Promise<DataEntry[]>
     storeEntryPointData: (key: DhtAddress, data: Any) => Promise<PeerDescriptor[]>
     deleteEntryPointData: (key: DhtAddress) => Promise<void>
@@ -67,74 +32,39 @@ interface EntryPointDiscoveryConfig {
 }
 
 export class EntryPointDiscovery {
+
     private readonly abortController: AbortController
     private readonly config: EntryPointDiscoveryConfig
     private readonly storeInterval: number
-    private readonly networkSplitAvoidedNodes: Set<DhtAddress> = new Set()
     private isLocalNodeStoredAsEntryPoint = false
+    
     constructor(config: EntryPointDiscoveryConfig) {
         this.config = config
         this.abortController = new AbortController()
         this.storeInterval = this.config.storeInterval ?? 60000
     }
 
-    async discoverEntryPointsFromDht(knownEntryPointCount: number): Promise<FindEntryPointsResult> {
-        if (knownEntryPointCount > 0) {
-            return {
-                entryPointsFromDht: false,
-                discoveredEntryPoints: []
-            }
-        }
-        const discoveredEntryPoints = await this.discoverEntryPoints()
-        if (discoveredEntryPoints.length === 0) {
-            discoveredEntryPoints.push(this.config.localPeerDescriptor)
-        }
-        return {
-            discoveredEntryPoints,
-            entryPointsFromDht: true
-        }
-    }
-
-    private async discoverEntryPoints(): Promise<PeerDescriptor[]> {
+    async discoverEntryPoints(): Promise<PeerDescriptor[]> {
         const dataKey = streamPartIdToDataKey(this.config.streamPartId)
-        const discoveredEntryPoints = await this.queryEntrypoints(dataKey)
-        const filtered = discoveredEntryPoints.filter((node) => 
-            !this.networkSplitAvoidedNodes.has(getNodeIdFromPeerDescriptor(node)))
-        // If all discovered entry points have previously been detected as offline, try again
-        if (filtered.length > 0) {
-            return filtered
-        } else {
-            return discoveredEntryPoints
-        }
-    }
-
-    private async queryEntrypoints(key: DhtAddress): Promise<PeerDescriptor[]> {
-        logger.trace(`Finding data from dht node ${getNodeIdFromPeerDescriptor(this.config.localPeerDescriptor)}`)
+        logger.trace(`Discovering entry points for key ${dataKey}`)
         try {
-            const result = await this.config.fetchEntryPointData(key)
+            const result = await this.config.fetchEntryPointData(dataKey)
             return parseEntryPointData(result)
         } catch (err) {
             return []
-        }
+        }    
     }
 
-    async storeSelfAsEntryPointIfNecessary(currentEntrypointCount: number): Promise<void> {
+    async storeAndKeepLocalNodeAsEntryPoint(): Promise<void> {
         if (this.abortController.signal.aborted) {
             return
         }
-        const possibleNetworkSplitDetected = this.config.layer1Node.getNeighborCount() < NETWORK_SPLIT_AVOIDANCE_LIMIT
-        if ((currentEntrypointCount < ENTRYPOINT_STORE_LIMIT) || possibleNetworkSplitDetected) {
-            this.isLocalNodeStoredAsEntryPoint = true
-            await this.storeSelfAsEntryPoint()
-            await this.keepSelfAsEntryPoint()
-        }
-        if (possibleNetworkSplitDetected) {
-            // TODO should we catch possible promise rejection?
-            setImmediate(() => this.avoidNetworkSplit())
-        }
+        this.isLocalNodeStoredAsEntryPoint = true
+        await this.storeLocalNodeAsEntryPoint()
+        await this.keepSelfAsEntryPoint()
     }
 
-    private async storeSelfAsEntryPoint(): Promise<void> {
+    private async storeLocalNodeAsEntryPoint(): Promise<void> {
         const localPeerDescriptor = this.config.localPeerDescriptor
         const dataToStore = Any.pack(localPeerDescriptor, PeerDescriptor)
         try {
@@ -151,7 +81,7 @@ export class EntryPointDiscovery {
                 const discovered = await this.discoverEntryPoints()
                 if (discovered.length < ENTRYPOINT_STORE_LIMIT 
                     || discovered.some((peerDescriptor) => areEqualPeerDescriptors(peerDescriptor, this.config.localPeerDescriptor))) {
-                    await this.storeSelfAsEntryPoint()
+                    await this.storeLocalNodeAsEntryPoint()
                 }
             } catch (err) {
                 logger.debug(`Failed to keep self as entrypoint for ${this.config.streamPartId}`)
@@ -159,24 +89,6 @@ export class EntryPointDiscovery {
         }, this.storeInterval, false, this.abortController.signal)
     }
 
-    private async avoidNetworkSplit(): Promise<void> {
-        await exponentialRunOff(async () => {
-            const rediscoveredEntrypoints = await this.discoverEntryPoints()
-            await this.config.layer1Node.joinDht(rediscoveredEntrypoints, false, false)
-            if (this.config.layer1Node.getNeighborCount() < NETWORK_SPLIT_AVOIDANCE_LIMIT) {
-                // Filter out nodes that are not neighbors as those nodes are assumed to be offline
-                const nodesToAvoid = rediscoveredEntrypoints
-                    .filter((peer) => !this.config.layer1Node.getNeighbors()
-                        .some((neighbor) => areEqualPeerDescriptors(neighbor, peer)))
-                    .map((peer) => getNodeIdFromPeerDescriptor(peer))
-                nodesToAvoid.forEach((node) => this.networkSplitAvoidedNodes.add(node))
-                throw new Error(`Network split is still possible`)
-            }
-        }, 'avoid network split', this.abortController.signal)
-        this.networkSplitAvoidedNodes.clear()
-        logger.trace(`Network split avoided`)
-    }
-
     public isLocalNodeEntryPoint(): boolean {
         return this.isLocalNodeStoredAsEntryPoint
     }

package/src/logic/Layer0Node.ts

@@ -1,4 +1,4 @@
-import { DataEntry, DhtAddress, ITransport, PeerDescriptor } from '@streamr/dht'
+import { ConnectionsView, DataEntry, DhtAddress, ITransport, PeerDescriptor } from '@streamr/dht'
 import { Any } from '../proto/google/protobuf/any'
 
 export interface Layer0Node extends ITransport {
@@ -11,7 +11,7 @@ export interface Layer0Node extends ITransport {
     waitForNetworkConnectivity(): Promise<void>
     getTransport(): ITransport
     getNeighbors(): PeerDescriptor[]
-    getConnections(): PeerDescriptor[]
+    getConnectionsView(): ConnectionsView
     start(): Promise<void>
     stop(): Promise<void>
 }

package/src/logic/Layer1Node.ts

@@ -1,8 +1,9 @@
 import { DhtAddress, PeerDescriptor, RingContacts } from '@streamr/dht'
 
 export interface Layer1NodeEvents {
-    closestContactAdded: (peerDescriptor: PeerDescriptor) => void
-    closestContactRemoved: (peerDescriptor: PeerDescriptor) => void
+    manualRejoinRequired: () => void
+    nearbyContactAdded: (peerDescriptor: PeerDescriptor) => void
+    nearbyContactRemoved: (peerDescriptor: PeerDescriptor) => void
     randomContactAdded: (peerDescriptor: PeerDescriptor) => void
     randomContactRemoved: (peerDescriptor: PeerDescriptor) => void
     ringContactAdded: (peerDescriptor: PeerDescriptor) => void
@@ -13,9 +14,12 @@ export interface Layer1Node {
     on<T extends keyof Layer1NodeEvents>(eventName: T, listener: (peerDescriptor: PeerDescriptor) => void): void
     once<T extends keyof Layer1NodeEvents>(eventName: T, listener: (peerDescriptor: PeerDescriptor) => void): void
     off<T extends keyof Layer1NodeEvents>(eventName: T, listener: (peerDescriptor: PeerDescriptor) => void): void
+    on<T extends keyof Layer1NodeEvents>(eventName: T, listener: () => void): void
+    once<T extends keyof Layer1NodeEvents>(eventName: T, listener: () => void): void
+    off<T extends keyof Layer1NodeEvents>(eventName: T, listener: () => void): void
     removeContact: (nodeId: DhtAddress) => void
     getClosestContacts: (maxCount?: number) => PeerDescriptor[]
-    getRandomContacts: () => PeerDescriptor[]
+    getRandomContacts: (maxCount?: number) => PeerDescriptor[]
     getRingContacts: () => RingContacts
     getNeighbors: () => PeerDescriptor[]
     getNeighborCount(): number

package/src/logic/StreamPartNetworkSplitAvoidance.ts

@@ -0,0 +1,89 @@
+import { areEqualPeerDescriptors, DhtAddress, getNodeIdFromPeerDescriptor, PeerDescriptor } from '@streamr/dht'
+import { Logger, wait } from '@streamr/utils'
+import { Layer1Node } from './Layer1Node'
+
+/*
+ * Tries to find new neighbors if we currently have less than MIN_NEIGHBOR_COUNT neigbors. It does so by
+ * rejoining the stream's control layer network.
+ * 
+ * This way we can avoid some network split scenarios. The functionality is most relevant for small stream
+ * networks.
+ */
+
+const logger = new Logger(module)
+
+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.debug(`${description} failed, retrying in ${delay} ms`)
+        }
+        try { // Abort controller throws unexpected errors in destroy?
+            await wait(delay, abortSignal)
+        } catch (err) {
+            logger.trace(`${err}`)  // TODO Do we need logging?
+        }
+    }
+}
+
+export const MIN_NEIGHBOR_COUNT = 4
+
+export interface StreamPartNetworkSplitAvoidanceConfig {
+    layer1Node: Layer1Node
+    discoverEntryPoints: (excludedNodes?: Set<DhtAddress>) => Promise<PeerDescriptor[]>
+    exponentialRunOfBaseDelay?: number
+}
+
+export class StreamPartNetworkSplitAvoidance {
+
+    private readonly abortController: AbortController
+    private readonly config: StreamPartNetworkSplitAvoidanceConfig
+    private readonly excludedNodes: Set<DhtAddress> = new Set()
+    private running = false
+
+    constructor(config: StreamPartNetworkSplitAvoidanceConfig) {
+        this.config = config
+        this.abortController = new AbortController()
+    }
+
+    public async avoidNetworkSplit(): Promise<void> {
+        this.running = true
+        await exponentialRunOff(async () => {
+            const discoveredEntrypoints = await this.config.discoverEntryPoints()
+            const filteredEntryPoints = discoveredEntrypoints.filter((peer) => !this.excludedNodes.has(getNodeIdFromPeerDescriptor(peer)))
+            await this.config.layer1Node.joinDht(filteredEntryPoints, false, false)
+            if (this.config.layer1Node.getNeighborCount() < MIN_NEIGHBOR_COUNT) {
+                // Filter out nodes that are not neighbors as those nodes are assumed to be offline
+                const newExcludes = filteredEntryPoints
+                    .filter((peer) => !this.config.layer1Node.getNeighbors()
+                        .some((neighbor) => areEqualPeerDescriptors(neighbor, peer)))
+                    .map((peer) => getNodeIdFromPeerDescriptor(peer))
+                newExcludes.forEach((node) => this.excludedNodes.add(node))
+                throw new Error(`Network split is still possible`)
+            }
+        }, 'avoid network split', this.abortController.signal, this.config.exponentialRunOfBaseDelay)
+        this.running = false
+        this.excludedNodes.clear()
+        logger.trace(`Network split avoided`)
+    }
+
+    public isRunning(): boolean {
+        return this.running
+    }
+
+    destroy(): void {
+        this.abortController.abort()
+    }
+}

package/src/logic/StreamPartReconnect.ts

@@ -0,0 +1,37 @@
+import { scheduleAtInterval } from '@streamr/utils'
+import { EntryPointDiscovery } from './EntryPointDiscovery'
+import { Layer1Node } from './Layer1Node'
+
+const DEFAULT_RECONNECT_INTERVAL = 30 * 1000
+export class StreamPartReconnect {
+    private abortController?: AbortController
+    private readonly layer1Node: Layer1Node
+    private readonly entryPointDiscovery: EntryPointDiscovery
+
+    constructor(layer1Node: Layer1Node, entryPointDiscovery: EntryPointDiscovery) {
+        this.layer1Node = layer1Node
+        this.entryPointDiscovery = entryPointDiscovery
+    }
+
+    async reconnect(timeout = DEFAULT_RECONNECT_INTERVAL): Promise<void> {
+        this.abortController = new AbortController()
+        await scheduleAtInterval(async () => {
+            const entryPoints = await this.entryPointDiscovery.discoverEntryPoints()
+            await this.layer1Node.joinDht(entryPoints)
+            if (this.entryPointDiscovery.isLocalNodeEntryPoint()) {
+                await this.entryPointDiscovery.storeAndKeepLocalNodeAsEntryPoint()
+            }
+            if (this.layer1Node.getNeighborCount() > 0) {
+                this.abortController!.abort()
+            }
+        }, timeout, true, this.abortController.signal)
+    }
+
+    isRunning(): boolean {
+        return this.abortController ? !this.abortController.signal.aborted : false
+    }
+
+    destroy(): void {
+        this.abortController?.abort()
+    }
+}

package/src/proto/google/protobuf/any.ts

@@ -73,10 +73,6 @@ import { MessageType } from "@protobuf-ts/runtime";
  *     if (any.is(Foo.class)) {
  *       foo = any.unpack(Foo.class);
  *     }
- *     // or ...
- *     if (any.isSameTypeAs(Foo.getDefaultInstance())) {
- *       foo = any.unpack(Foo.getDefaultInstance());
- *     }
  *
  *  Example 3: Pack and unpack a message in Python.
  *
@@ -91,13 +87,10 @@ import { MessageType } from "@protobuf-ts/runtime";
  *  Example 4: Pack and unpack a message in Go
  *
  *      foo := &pb.Foo{...}
- *      any, err := anypb.New(foo)
- *      if err != nil {
- *        ...
- *      }
+ *      any, err := ptypes.MarshalAny(foo)
  *      ...
  *      foo := &pb.Foo{}
- *      if err := any.UnmarshalTo(foo); err != nil {
+ *      if err := ptypes.UnmarshalAny(any, foo); err != nil {
  *        ...
  *      }
  *
@@ -107,6 +100,7 @@ import { MessageType } from "@protobuf-ts/runtime";
  * in the type URL, for example "foo.bar.com/x/y.z" will yield type
  * name "y.z".
  *
+ *
  * JSON
  * ====
  * The JSON representation of an `Any` value uses the regular
@@ -163,8 +157,7 @@ export interface Any {
      *
      * Note: this functionality is not currently available in the official
      * protobuf release, and it is not used for type URLs beginning with
-     * type.googleapis.com. As of May 2023, there are no widely used type server
-     * implementations and no plans to implement one.
+     * type.googleapis.com.
      *
      * Schemes other than `http`, `https` (or the empty scheme) might be
      * used with implementation specific semantics.

package/src/proto/google/protobuf/empty.ts

@@ -49,6 +49,7 @@ import { MessageType } from "@protobuf-ts/runtime";
  *       rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty);
  *     }
  *
+ * The JSON representation for `Empty` is empty JSON object `{}`.
  *
  * @generated from protobuf message google.protobuf.Empty
  */

package/src/proto/google/protobuf/timestamp.ts

@@ -97,15 +97,8 @@ import { MessageType } from "@protobuf-ts/runtime";
  *     Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000)
  *         .setNanos((int) ((millis % 1000) * 1000000)).build();
  *
- * Example 5: Compute Timestamp from Java `Instant.now()`.
  *
- *     Instant now = Instant.now();
- *
- *     Timestamp timestamp =
- *         Timestamp.newBuilder().setSeconds(now.getEpochSecond())
- *             .setNanos(now.getNano()).build();
- *
- * Example 6: Compute Timestamp from current time in Python.
+ * Example 5: Compute Timestamp from current time in Python.
  *
  *     timestamp = Timestamp()
  *     timestamp.GetCurrentTime()
@@ -134,10 +127,11 @@ import { MessageType } from "@protobuf-ts/runtime";
  * [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with
  * the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use
  * the Joda Time's [`ISODateTimeFormat.dateTime()`](
- * http://joda-time.sourceforge.net/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime()
+ * http://www.joda.org/joda-time/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime%2D%2D
  * ) to obtain a formatter capable of generating timestamps in this format.
  *
  *
+ *
  * @generated from protobuf message google.protobuf.Timestamp
  */
 export interface Timestamp {

package/src/proto/packages/dht/protos/DhtRpc.ts

@@ -351,9 +351,9 @@ export interface ConnectivityRequest {
      */
     host?: string;
     /**
-     * @generated from protobuf field: bool selfSigned = 4;
+     * @generated from protobuf field: bool allowSelfSignedCertificate = 4;
      */
-    selfSigned: boolean;
+    allowSelfSignedCertificate: boolean;
 }
 /**
  * @generated from protobuf message dht.ConnectivityResponse
@@ -962,7 +962,7 @@ class ConnectivityRequest$Type extends MessageType<ConnectivityRequest> {
             { no: 1, name: "port", kind: "scalar", T: 13 /*ScalarType.UINT32*/ },
             { no: 2, name: "tls", kind: "scalar", T: 8 /*ScalarType.BOOL*/ },
             { no: 3, name: "host", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ },
-            { no: 4, name: "selfSigned", kind: "scalar", T: 8 /*ScalarType.BOOL*/ }
+            { no: 4, name: "allowSelfSignedCertificate", kind: "scalar", T: 8 /*ScalarType.BOOL*/ }
         ]);
     }
 }

package/test/benchmark/first-message.ts

@@ -159,7 +159,7 @@ run().then(() => {
     console.log(foundData)
     const layer0Node = currentNode.stack.getLayer0Node() as DhtNode
     console.log(layer0Node.getNeighbors().length)
-    console.log(layer0Node.getConnectionCount())
+    console.log(layer0Node.getConnectionsView().getConnectionCount())
     const streamPartDelivery = contentDeliveryManager
         .getStreamPartDelivery(streamParts[0])! as { layer1Node: Layer1Node, node: ContentDeliveryLayerNode }
     console.log(streamPartDelivery.layer1Node.getNeighbors())

package/test/integration/ContentDeliveryLayerNode-Layer1Node-Latencies.test.ts

@@ -29,11 +29,13 @@ describe('ContentDeliveryLayerNode-DhtNode-Latencies', () => {
 
         entryPointLayer1Node = new DhtNode({
             transport: entrypointCm,
+            connectionsView: entrypointCm,
             peerDescriptor: entrypointDescriptor,
             serviceId: streamPartId
         })
         otherLayer1Nodes = range(otherNodeCount).map((i) => new DhtNode({
             transport: cms[i],
+            connectionsView: cms[i],
             peerDescriptor: peerDescriptors[i],
             serviceId: streamPartId
         }))

package/test/integration/ContentDeliveryLayerNode-Layer1Node.test.ts

@@ -44,12 +44,14 @@ describe('ContentDeliveryLayerNode-DhtNode', () => {
 
         entryPointLayer1Node = new DhtNode({
             transport: entrypointCm,
+            connectionsView: entrypointCm,
             peerDescriptor: entrypointDescriptor,
             serviceId: streamPartId
         })
 
         otherLayer1Nodes = range(otherNodeCount).map((i) => new DhtNode({
             transport: cms[i],
+            connectionsView: cms[i],
             peerDescriptor: peerDescriptors[i],
             serviceId: streamPartId
         }))

package/test/integration/ContentDeliveryManager.test.ts

@@ -44,11 +44,13 @@ describe('ContentDeliveryManager', () => {
         await transport2.start()
         layer0Node1 = new DhtNode({
             transport: transport1,
+            connectionsView: transport1,
             peerDescriptor: peerDescriptor1,
             entryPoints: [peerDescriptor1]
         })
         layer0Node2 = new DhtNode({
             transport: transport2,
+            connectionsView: transport2,
             peerDescriptor: peerDescriptor2,
             entryPoints: [peerDescriptor1]
         })

package/test/integration/Inspect.test.ts

@@ -30,7 +30,8 @@ describe('inspect', () => {
             layer0: {
                 entryPoints: [publisherDescriptor],
                 peerDescriptor,
-                transport
+                transport,
+                connectionsView: transport
             }
         })
         await node.start()