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

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/unit/EntrypointDiscovery.test.ts

@@ -1,11 +1,9 @@
 import { PeerDescriptor, areEqualPeerDescriptors } from '@streamr/dht'
 import { StreamPartIDUtils } from '@streamr/protocol'
 import { wait } from '@streamr/utils'
-import { range } from 'lodash'
 import { EntryPointDiscovery } from '../../src/logic/EntryPointDiscovery'
 import { Any } from '../../src/proto/google/protobuf/any'
 import { DataEntry } from '../../src/proto/packages/dht/protos/DhtRpc'
-import { MockLayer1Node } from '../utils/mock/MockLayer1Node'
 import { createMockPeerDescriptor } from '../utils/utils'
 
 const STREAM_PART_ID = StreamPartIDUtils.parse('stream#0')
@@ -52,24 +50,11 @@ describe('EntryPointDiscovery', () => {
 
     const fakeDeleteEntryPointData = async (): Promise<void> => {}
 
-    const addNodesToStreamPart = (layer1: MockLayer1Node, count: number) => {
-        range(count).forEach(() => {
-            layer1.addNewRandomPeerToKBucket()
-            layer1.addNewRandomPeerToKBucket()
-            layer1.addNewRandomPeerToKBucket()
-            layer1.addNewRandomPeerToKBucket()
-        })
-    } 
-
-    let layer1Node: MockLayer1Node
-
     beforeEach(() => {
         storeCalled = 0
-        layer1Node = new MockLayer1Node()
         entryPointDiscoveryWithData = new EntryPointDiscovery({
             localPeerDescriptor: peerDescriptor,
             streamPartId: STREAM_PART_ID,
-            layer1Node,
             fetchEntryPointData: fakeFetchEntryPointData,
             storeEntryPointData: fakeStoreEntryPointData,
             deleteEntryPointData: fakeDeleteEntryPointData,
@@ -78,7 +63,6 @@ describe('EntryPointDiscovery', () => {
         entryPointDiscoveryWithoutData = new EntryPointDiscovery({
             localPeerDescriptor: peerDescriptor,
             streamPartId: STREAM_PART_ID,
-            layer1Node,
             fetchEntryPointData: fakeEmptyFetchEntryPointData,
             storeEntryPointData: fakeStoreEntryPointData,
             deleteEntryPointData: fakeDeleteEntryPointData,
@@ -90,40 +74,25 @@ describe('EntryPointDiscovery', () => {
         entryPointDiscoveryWithData.destroy()
     })
 
-    it('discoverEntryPointsFromDht has known entrypoints', async () => {
-        const res = await entryPointDiscoveryWithData.discoverEntryPointsFromDht(1)
-        expect(res.entryPointsFromDht).toEqual(false)
-        expect(res.discoveredEntryPoints).toEqual([])
-    })
-
-    it('discoverEntryPointsFromDht does not have known entrypoints', async () => {
-        const res = await entryPointDiscoveryWithData.discoverEntryPointsFromDht(0)
-        expect(res.discoveredEntryPoints.length).toBe(1)
-        expect(areEqualPeerDescriptors(res.discoveredEntryPoints[0], peerDescriptor)).toBe(true)
+    it('discoverEntryPoints filters deleted data', async () => {
+        const res = await entryPointDiscoveryWithData.discoverEntryPoints()
+        expect(res.length).toBe(1)
+        expect(areEqualPeerDescriptors(res[0], peerDescriptor)).toBe(true)
     })
 
-    it('discoverEntryPointsfromDht on an empty stream', async () => {
-        const res = await entryPointDiscoveryWithoutData.discoverEntryPointsFromDht(0)
-        expect(res.entryPointsFromDht).toEqual(true)
-        expect(res.discoveredEntryPoints.length).toBe(1)
-        expect(areEqualPeerDescriptors(res.discoveredEntryPoints[0], peerDescriptor)).toBe(true)  // localPeerDescriptor
-    })
-
-    it('store on empty stream', async () => {
-        await entryPointDiscoveryWithData.storeSelfAsEntryPointIfNecessary(0)
-        expect(storeCalled).toEqual(1)
-        expect(entryPointDiscoveryWithData.isLocalNodeEntryPoint()).toEqual(true)
+    it('discoverEntryPoints without results', async () => {
+        const res = await entryPointDiscoveryWithoutData.discoverEntryPoints()
+        expect(res.length).toBe(0)
     })
 
     it('store on stream without saturated entrypoint count', async () => {
-        addNodesToStreamPart(layer1Node, 4)
-        await entryPointDiscoveryWithData.storeSelfAsEntryPointIfNecessary(0)
+        await entryPointDiscoveryWithData.storeAndKeepLocalNodeAsEntryPoint()
         expect(storeCalled).toEqual(1)
         expect(entryPointDiscoveryWithData.isLocalNodeEntryPoint()).toEqual(true)
     })
 
     it('will keep stored until destroyed', async () => {
-        await entryPointDiscoveryWithData.storeSelfAsEntryPointIfNecessary(0)
+        await entryPointDiscoveryWithData.storeAndKeepLocalNodeAsEntryPoint()
         expect(storeCalled).toEqual(1)
         expect(entryPointDiscoveryWithData.isLocalNodeEntryPoint()).toEqual(true)
         await wait(4500)

package/test/unit/StreamPartNetworkSplitAvoidance.test.ts

@@ -0,0 +1,32 @@
+import { MIN_NEIGHBOR_COUNT } from '../../src/logic/StreamPartNetworkSplitAvoidance'
+import { StreamPartNetworkSplitAvoidance } from '../../src/logic/StreamPartNetworkSplitAvoidance'
+import { MockLayer1Node } from '../utils/mock/MockLayer1Node'
+
+describe('StreamPartNetworkSplitAvoidance', () => {
+
+    let avoidance: StreamPartNetworkSplitAvoidance
+    let layer1Node: MockLayer1Node
+    
+    beforeEach(() => {
+        layer1Node = new MockLayer1Node()
+        avoidance = new StreamPartNetworkSplitAvoidance({
+            layer1Node,
+            discoverEntryPoints: async () => { 
+                layer1Node.addNewRandomPeerToKBucket() 
+                return layer1Node.getNeighbors()
+            },
+            exponentialRunOfBaseDelay: 1
+        })
+    })
+
+    afterEach(() => {
+        layer1Node.stop()
+        avoidance.destroy()
+    })
+
+    it('runs avoidance until number of neighbors is above MIN_NEIGHBOR_COUNT', async () => {
+        await avoidance.avoidNetworkSplit()
+        expect(layer1Node.getNeighborCount()).toBeGreaterThan(MIN_NEIGHBOR_COUNT)
+    })
+
+})

package/test/utils/fake/FakeEntryPointDiscovery.ts

@@ -1,5 +1,5 @@
 import { PeerDescriptor } from '@streamr/dht'
-import { EntryPointDiscovery, FindEntryPointsResult } from '../../../src/logic/EntryPointDiscovery'
+import { EntryPointDiscovery } from '../../../src/logic/EntryPointDiscovery'
 
 export const createFakeEntryPointDiscovery = (): EntryPointDiscovery => {
     return new FakeEntryPointDiscovery() as unknown as EntryPointDiscovery
@@ -13,15 +13,12 @@ class FakeEntryPointDiscovery {
         this.entryPoints = nodes
     } 
 
-    async discoverEntryPointsFromDht(): Promise<FindEntryPointsResult> {
-        return {
-            entryPointsFromDht: true,
-            discoveredEntryPoints: this.entryPoints
-        }
+    async discoverEntryPoints(): Promise<PeerDescriptor[]> {
+        return this.entryPoints
     }
 
     // eslint-disable-next-line class-methods-use-this
-    async storeSelfAsEntryPointIfNecessary(): Promise<void> {
+    async storeAndKeepLocalNodeAsEntryPoint(): Promise<void> {
     }
 
     // eslint-disable-next-line class-methods-use-this