@streamr/trackerless-network 100.0.0-testnet-three.0 → 100.0.0-testnet-three.1

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

@@ -1,4 +1,4 @@
-// @generated by protobuf-ts 2.9.1 with parameter server_generic,generate_dependencies,long_type_number
+// @generated by protobuf-ts 2.9.3 with parameter server_generic,generate_dependencies,long_type_number
 // @generated from protobuf file "google/protobuf/timestamp.proto" (package "google.protobuf", syntax proto3)
 // tslint:disable
 //
@@ -40,7 +40,6 @@ import type { IBinaryReader } from "@protobuf-ts/runtime";
 import { UnknownFieldHandler } from "@protobuf-ts/runtime";
 import type { PartialMessage } from "@protobuf-ts/runtime";
 import { reflectionMergePartial } from "@protobuf-ts/runtime";
-import { MESSAGE_TYPE } from "@protobuf-ts/runtime";
 import { typeofJsonValue } from "@protobuf-ts/runtime";
 import type { JsonValue } from "@protobuf-ts/runtime";
 import type { JsonReadOptions } from "@protobuf-ts/runtime";
@@ -234,8 +233,9 @@ class Timestamp$Type extends MessageType<Timestamp> {
         return target;
     }
     create(value?: PartialMessage<Timestamp>): Timestamp {
-        const message = { seconds: 0, nanos: 0 };
-        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.seconds = 0;
+        message.nanos = 0;
         if (value !== undefined)
             reflectionMergePartial<Timestamp>(this, message, value);
         return message;

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

@@ -339,6 +339,10 @@ export interface ConnectivityResponse {
      * @generated from protobuf field: uint32 ipAddress = 4;
      */
     ipAddress: number;
+    /**
+     * @generated from protobuf field: string version = 5;
+     */
+    version: string;
 }
 /**
  * @generated from protobuf message dht.HandshakeRequest
@@ -943,7 +947,8 @@ class ConnectivityResponse$Type extends MessageType$<ConnectivityResponse> {
             { no: 1, name: "host", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
             { no: 2, name: "natType", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
             { no: 3, name: "websocket", kind: "message", T: () => ConnectivityMethod },
-            { no: 4, name: "ipAddress", kind: "scalar", T: 13 /*ScalarType.UINT32*/ }
+            { no: 4, name: "ipAddress", kind: "scalar", T: 13 /*ScalarType.UINT32*/ },
+            { no: 5, name: "version", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
         ]);
     }
 }

package/src/proto/packages/trackerless-network/protos/NetworkRpc.client.ts

@@ -5,6 +5,7 @@ import { NodeInfoRpc } from "./NetworkRpc";
 import type { NodeInfoResponse } from "./NetworkRpc";
 import type { NodeInfoRequest } from "./NetworkRpc";
 import { TemporaryConnectionRpc } from "./NetworkRpc";
+import type { CloseTemporaryConnection } from "./NetworkRpc";
 import type { TemporaryConnectionResponse } from "./NetworkRpc";
 import type { TemporaryConnectionRequest } from "./NetworkRpc";
 import { NeighborUpdateRpc } from "./NetworkRpc";
@@ -160,6 +161,10 @@ export interface ITemporaryConnectionRpcClient {
      * @generated from protobuf rpc: openConnection(TemporaryConnectionRequest) returns (TemporaryConnectionResponse);
      */
     openConnection(input: TemporaryConnectionRequest, options?: RpcOptions): UnaryCall<TemporaryConnectionRequest, TemporaryConnectionResponse>;
+    /**
+     * @generated from protobuf rpc: closeConnection(CloseTemporaryConnection) returns (google.protobuf.Empty);
+     */
+    closeConnection(input: CloseTemporaryConnection, options?: RpcOptions): UnaryCall<CloseTemporaryConnection, Empty>;
 }
 /**
  * @generated from protobuf service TemporaryConnectionRpc
@@ -177,6 +182,13 @@ export class TemporaryConnectionRpcClient implements ITemporaryConnectionRpcClie
         const method = this.methods[0], opt = this._transport.mergeOptions(options);
         return stackIntercept<TemporaryConnectionRequest, TemporaryConnectionResponse>("unary", this._transport, method, opt, input);
     }
+    /**
+     * @generated from protobuf rpc: closeConnection(CloseTemporaryConnection) returns (google.protobuf.Empty);
+     */
+    closeConnection(input: CloseTemporaryConnection, options?: RpcOptions): UnaryCall<CloseTemporaryConnection, Empty> {
+        const method = this.methods[1], opt = this._transport.mergeOptions(options);
+        return stackIntercept<CloseTemporaryConnection, Empty>("unary", this._transport, method, opt, input);
+    }
 }
 /**
  * @generated from protobuf service NodeInfoRpc

package/src/proto/packages/trackerless-network/protos/NetworkRpc.server.ts

@@ -3,6 +3,7 @@
 // tslint:disable
 import { NodeInfoResponse } from "./NetworkRpc";
 import { NodeInfoRequest } from "./NetworkRpc";
+import { CloseTemporaryConnection } from "./NetworkRpc";
 import { TemporaryConnectionResponse } from "./NetworkRpc";
 import { TemporaryConnectionRequest } from "./NetworkRpc";
 import { NeighborUpdate } from "./NetworkRpc";
@@ -68,6 +69,10 @@ export interface ITemporaryConnectionRpc<T = ServerCallContext> {
      * @generated from protobuf rpc: openConnection(TemporaryConnectionRequest) returns (TemporaryConnectionResponse);
      */
     openConnection(request: TemporaryConnectionRequest, context: T): Promise<TemporaryConnectionResponse>;
+    /**
+     * @generated from protobuf rpc: closeConnection(CloseTemporaryConnection) returns (google.protobuf.Empty);
+     */
+    closeConnection(request: CloseTemporaryConnection, context: T): Promise<Empty>;
 }
 /**
  * @generated from protobuf service NodeInfoRpc

package/src/proto/packages/trackerless-network/protos/NetworkRpc.ts

@@ -273,6 +273,11 @@ export interface TemporaryConnectionResponse {
      */
     accepted: boolean;
 }
+/**
+ * @generated from protobuf message CloseTemporaryConnection
+ */
+export interface CloseTemporaryConnection {
+}
 /**
  * @generated from protobuf message StreamPartitionInfo
  */
@@ -616,6 +621,16 @@ class TemporaryConnectionResponse$Type extends MessageType<TemporaryConnectionRe
  */
 export const TemporaryConnectionResponse = new TemporaryConnectionResponse$Type();
 // @generated message type with reflection information, may provide speed optimized methods
+class CloseTemporaryConnection$Type extends MessageType<CloseTemporaryConnection> {
+    constructor() {
+        super("CloseTemporaryConnection", []);
+    }
+}
+/**
+ * @generated MessageType for protobuf message CloseTemporaryConnection
+ */
+export const CloseTemporaryConnection = new CloseTemporaryConnection$Type();
+// @generated message type with reflection information, may provide speed optimized methods
 class StreamPartitionInfo$Type extends MessageType<StreamPartitionInfo> {
     constructor() {
         super("StreamPartitionInfo", [
@@ -696,7 +711,8 @@ export const NeighborUpdateRpc = new ServiceType("NeighborUpdateRpc", [
  * @generated ServiceType for protobuf service TemporaryConnectionRpc
  */
 export const TemporaryConnectionRpc = new ServiceType("TemporaryConnectionRpc", [
-    { name: "openConnection", options: {}, I: TemporaryConnectionRequest, O: TemporaryConnectionResponse }
+    { name: "openConnection", options: {}, I: TemporaryConnectionRequest, O: TemporaryConnectionResponse },
+    { name: "closeConnection", options: {}, I: CloseTemporaryConnection, O: Empty }
 ]);
 /**
  * @generated ServiceType for protobuf service NodeInfoRpc

package/test/unit/NeighborUpdateRpcLocal.test.ts

@@ -0,0 +1,125 @@
+import { ListeningRpcCommunicator, getNodeIdFromPeerDescriptor } from '@streamr/dht'
+import { NeighborFinder } from '../../src/logic/neighbor-discovery/NeighborFinder'
+import { NeighborUpdateRpcLocal } from '../../src/logic/neighbor-discovery/NeighborUpdateRpcLocal'
+import { createMockPeerDescriptor } from '../utils/utils'
+import { NodeList } from '../../src/logic/NodeList'
+import { StreamPartIDUtils } from '@streamr/protocol'
+import { MockTransport } from '../utils/mock/Transport'
+import { DeliveryRpcClient } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc.client'
+import { DeliveryRpcRemote } from '../../src/logic/DeliveryRpcRemote'
+import { range } from 'lodash'
+
+describe('NeighborUpdateRpcLocal', () => {
+
+    const streamPartId = StreamPartIDUtils.parse('stream#0')
+    const localPeerDescriptor = createMockPeerDescriptor()
+    const neighborCount = 4
+
+    let rpcLocal: NeighborUpdateRpcLocal
+    let neighbors: NodeList
+    let nearbyNodeView: NodeList
+    let neighborFinder: NeighborFinder
+    let rpcCommunicator: ListeningRpcCommunicator
+
+    const addNeighbors = (count: number) => {
+        for (let i = 0; i < count; i++) {
+            neighbors.add(new DeliveryRpcRemote(
+                localPeerDescriptor,
+                createMockPeerDescriptor(),
+                rpcCommunicator,
+                DeliveryRpcClient
+            ))
+        }
+    }
+
+    beforeEach(() => {
+        rpcCommunicator = new ListeningRpcCommunicator('mock', new MockTransport())
+        neighbors = new NodeList(getNodeIdFromPeerDescriptor(localPeerDescriptor), neighborCount + 1)
+        nearbyNodeView = new NodeList(getNodeIdFromPeerDescriptor(localPeerDescriptor), neighborCount)
+        neighborFinder = {
+            start: jest.fn()
+        } as any
+
+        rpcLocal = new NeighborUpdateRpcLocal({
+            localPeerDescriptor,
+            neighbors,
+            nearbyNodeView,
+            neighborFinder,
+            streamPartId,
+            rpcCommunicator,
+            neighborCount
+        })
+    })
+
+    afterEach(() => {
+        rpcCommunicator.destroy()
+    })
+
+    it('response contains neighbor list of expected size', async () => {
+        addNeighbors(neighborCount)
+        const res = await rpcLocal.neighborUpdate({
+            streamPartId,
+            neighborDescriptors: [localPeerDescriptor],
+            removeMe: false
+        }, { incomingSourceDescriptor: createMockPeerDescriptor() } as any)
+        expect(res.neighborDescriptors.length).toEqual(neighborCount)
+    })
+
+    it('updates contacts based on callers neighbors', async () => {
+        addNeighbors(neighborCount)
+        expect(nearbyNodeView.size()).toEqual(0)
+        await rpcLocal.neighborUpdate({
+            streamPartId,
+            neighborDescriptors: range(neighborCount).map(() => createMockPeerDescriptor()),
+            removeMe: false
+        }, { incomingSourceDescriptor: createMockPeerDescriptor() } as any)
+        expect(nearbyNodeView.size()).toEqual(4)
+    })
+
+    it('does not ask to be removed if caller is a neighbor', async () => {
+        const caller = createMockPeerDescriptor()
+        const neighbor = new DeliveryRpcRemote(
+            localPeerDescriptor,
+            caller,
+            rpcCommunicator,
+            DeliveryRpcClient
+        )
+        neighbors.add(neighbor)
+        const res = await rpcLocal.neighborUpdate({
+            streamPartId,
+            neighborDescriptors: [localPeerDescriptor],
+            removeMe: false
+        }, { incomingSourceDescriptor: caller } as any)
+        expect(res.removeMe).toEqual(false)
+    })
+
+    it('asks to be removed if caller is not a neighbor', async () => {
+        const caller = createMockPeerDescriptor()
+        const res = await rpcLocal.neighborUpdate({
+            streamPartId,
+            neighborDescriptors: [localPeerDescriptor],
+            removeMe: false
+        }, { incomingSourceDescriptor: caller } as any)
+        expect(res.removeMe).toEqual(true)
+    })
+
+    it('asks to be removed if caller is a neighbor and both have too many neighbors', async () => {
+        const caller = createMockPeerDescriptor()
+        const neighbor = new DeliveryRpcRemote(
+            localPeerDescriptor,
+            caller,
+            rpcCommunicator,
+            DeliveryRpcClient
+        )
+        neighbors.add(neighbor)
+        addNeighbors(neighborCount)
+        const res = await rpcLocal.neighborUpdate({
+            streamPartId,
+            neighborDescriptors: [localPeerDescriptor, ...range(neighborCount).map(() => createMockPeerDescriptor())],
+            removeMe: false
+        }, { incomingSourceDescriptor: caller } as any)
+        expect(res.removeMe).toEqual(true)
+        expect(neighbors.has(getNodeIdFromPeerDescriptor(caller))).toEqual(false)
+    })
+
+})

package/test/unit/TemporaryConnectionRpcLocal.test.ts

@@ -0,0 +1,32 @@
+import { TemporaryConnectionRpcLocal } from '../../src/logic/temporary-connection/TemporaryConnectionRpcLocal'
+import { MockTransport } from '../utils/mock/Transport'
+import { createMockPeerDescriptor } from '../utils/utils'
+import { ListeningRpcCommunicator, getDhtAddressFromRaw } from '@streamr/dht'
+
+describe('TemporaryConnectionRpcLocal', () => {
+
+    const peerDescriptor = createMockPeerDescriptor()
+    let rpcCommunicator: ListeningRpcCommunicator
+    let rpcLocal: TemporaryConnectionRpcLocal
+
+    beforeEach(() => {
+        rpcCommunicator = new ListeningRpcCommunicator('mock', new MockTransport())
+        rpcLocal = new TemporaryConnectionRpcLocal({
+            localPeerDescriptor: peerDescriptor,
+            rpcCommunicator
+        })
+    })
+
+    afterEach(() => {
+        rpcCommunicator.destroy()
+    })
+
+    it('Open and Close Connection', async () => {
+        const caller = createMockPeerDescriptor()
+        await rpcLocal.openConnection({}, { incomingSourceDescriptor: caller } as any)
+        expect(rpcLocal.getNodes().get(getDhtAddressFromRaw(caller.nodeId))).toBeDefined()
+        await rpcLocal.closeConnection({}, { incomingSourceDescriptor: caller } as any)
+        expect(rpcLocal.getNodes().get(getDhtAddressFromRaw(caller.nodeId))).toBeUndefined()
+    })
+
+})