@livestore/webmesh 0.0.0-snapshot-aed277ba0960f72b8d464508961ab4aec1881230 → 0.0.0-snapshot-7bcbc24bb8873481e482d982636957f0c1f791f6

package/src/channel/message-channel-internal.ts

@@ -90,6 +90,9 @@ export const makeMessageChannelInternal = ({
     const deferred = yield* makeDeferredResult()
 
     const span = yield* OtelTracer.currentOtelSpan.pipe(Effect.catchAll(() => Effect.succeed(undefined)))
+    // const span = {
+    //   addEvent: (...msg: any[]) => console.log(`${nodeName}→${channelName}→${target}[${channelVersion}]`, ...msg),
+    // }
 
     const schema = {
       send: Schema.Union(schema_.send, MeshSchema.MessageChannelPing, MeshSchema.MessageChannelPong),
@@ -111,8 +114,10 @@ export const makeMessageChannelInternal = ({
           packetChannelVersion: Predicate.hasProperty('channelVersion')(packet) ? packet.channelVersion : undefined,
         })
 
+        // const reqIdStr =
+        //   Predicate.hasProperty('reqId')(packet) && packet.reqId !== undefined ? ` for ${packet.reqId}` : ''
         // yield* Effect.log(
-        //   `${nodeName}→${channelName}→${target}:process packet ${packet._tag} [${channelVersion}], channel state: ${channelState._tag}`,
+        //   `${nodeName}→${channelName}→${target}[${channelVersion}]:process packet ${packet._tag} [${packet.id}${reqIdStr}], channel state: ${channelState._tag}`,
         // )
 
         if (channelState._tag === 'Initial') return shouldNeverHappen()
@@ -222,6 +227,8 @@ export const makeMessageChannelInternal = ({
 
               channelStateRef.current = { _tag: 'winner:ResponseSent', channel, otherSourceId: packet.sourceId }
 
+              // span?.addEvent(`winner side: waiting for ping`)
+
               // Now we wait for the other side to respond via the channel
               yield* channel.listen.pipe(
                 Stream.flatten(),
@@ -230,6 +237,8 @@ export const makeMessageChannelInternal = ({
                 Stream.runDrain,
               )
 
+              // span?.addEvent(`winner side: sending pong`)
+
               yield* channel.send(MeshSchema.MessageChannelPong.make({}))
 
               span?.addEvent(`winner side: established`)
@@ -266,7 +275,17 @@ export const makeMessageChannelInternal = ({
               Effect.fork,
             )
 
-            yield* channel.send(MeshSchema.MessageChannelPing.make({}))
+            // span?.addEvent(`loser side: sending ping`)
+
+            // There seems to be some scenario where the initial ping message is lost.
+            // As a workaround until we find the root cause, we're retrying the ping a few times.
+            // TODO write a test that reproduces this issue and fix the root cause ()
+            // https://github.com/livestorejs/livestore/issues/262
+            yield* channel
+              .send(MeshSchema.MessageChannelPing.make({}))
+              .pipe(Effect.timeout(10), Effect.retry({ times: 2 }))
+
+            // span?.addEvent(`loser side: waiting for pong`)
 
             yield* waitForPongFiber
 

package/src/channel/message-channel.ts

@@ -4,6 +4,7 @@ import {
   Effect,
   Either,
   Exit,
+  Option,
   Queue,
   Schema,
   Scope,
@@ -55,8 +56,9 @@ export const makeMessageChannel = ({
       const debugInfo = {
         pendingSends: 0,
         totalSends: 0,
-        connectCounter: 1,
+        connectCounter: 0,
         isConnected: false,
+        innerChannelRef: { current: undefined as WebChannel.WebChannel<any, any> | undefined },
       }
 
       // #region reconnect-loop
@@ -112,26 +114,33 @@ export const makeMessageChannel = ({
             newConnectionAvailablePubSub,
             sendPacket,
             scope: makeMessageChannelScope,
-          }).pipe(Scope.extend(makeMessageChannelScope), Effect.forkIn(makeMessageChannelScope))
+          }).pipe(
+            Scope.extend(makeMessageChannelScope),
+            Effect.forkIn(makeMessageChannelScope),
+            // Given we only call `Effect.exit` later when joining the fiber,
+            // we don't want Effect to produce a "unhandled error" log message
+            Effect.withUnhandledErrorLogLevel(Option.none()),
+          )
 
-          const res = yield* Effect.raceFirst(makeChannel, waitForNewConnectionFiber.pipe(Effect.disconnect))
+          const raceResult = yield* Effect.raceFirst(makeChannel, waitForNewConnectionFiber.pipe(Effect.disconnect))
 
-          if (res === 'new-connection') {
+          if (raceResult === 'new-connection') {
             yield* Scope.close(makeMessageChannelScope, Exit.fail('new-connection'))
             // We'll try again
           } else {
-            const result = yield* res.pipe(Effect.exit)
-            if (result._tag === 'Failure') {
-              yield* Scope.close(makeMessageChannelScope, result)
+            const channelExit = yield* raceResult.pipe(Effect.exit)
+            if (channelExit._tag === 'Failure') {
+              yield* Scope.close(makeMessageChannelScope, channelExit)
 
               if (
-                Cause.isFailType(result.cause) &&
-                Schema.is(WebmeshSchema.MessageChannelResponseNoTransferables)(result.cause.error)
+                Cause.isFailType(channelExit.cause) &&
+                Schema.is(WebmeshSchema.MessageChannelResponseNoTransferables)(channelExit.cause.error)
               ) {
+                // Only retry when there is a new connection available
                 yield* waitForNewConnectionFiber.pipe(Effect.exit)
               }
             } else {
-              const channel = result.value
+              const channel = channelExit.value
 
               yield* Deferred.succeed(resultDeferred, { channel, makeMessageChannelScope, channelVersion })
               break
@@ -144,6 +153,7 @@ export const makeMessageChannel = ({
 
         yield* Effect.spanEvent(`Connected#${channelVersion}`)
         debugInfo.isConnected = true
+        debugInfo.innerChannelRef.current = channel
 
         yield* Deferred.succeed(initialConnectionDeferred, void 0)
 
@@ -176,6 +186,7 @@ export const makeMessageChannel = ({
 
         yield* Effect.spanEvent(`Disconnected#${channelVersion}`)
         debugInfo.isConnected = false
+        debugInfo.innerChannelRef.current = undefined
       }).pipe(
         Effect.scoped, // Additionally scoping here to clean up finalizers after each loop run
         Effect.forever,

package/src/node.test.ts

@@ -106,80 +106,79 @@ const propTestTimeout = IS_CI ? 60_000 : 20_000
 // TODO also make work without `Vitest.scopedLive` (i.e. with `Vitest.scoped`)
 // probably requires controlling the clocks
 Vitest.describe('webmesh node', { timeout: testTimeout }, () => {
-  Vitest.describe('A <> B', () => {
-    Vitest.describe('prop tests', { timeout: propTestTimeout }, () => {
-      const Delay = Schema.UndefinedOr(Schema.Literal(0, 1, 10, 50))
-      // NOTE for message channels, we test both with and without transferables (i.e. proxying)
-      const ChannelType = Schema.Literal('messagechannel', 'messagechannel.proxy', 'proxy')
-      const NodeNames = Schema.Union(
-        Schema.Tuple(Schema.Literal('A'), Schema.Literal('B')),
-        Schema.Tuple(Schema.Literal('B'), Schema.Literal('A')),
-      )
+  const Delay = Schema.UndefinedOr(Schema.Literal(0, 1, 10, 50))
+  // NOTE for message channels, we test both with and without transferables (i.e. proxying)
+  const ChannelType = Schema.Literal('messagechannel', 'messagechannel.proxy', 'proxy')
+  const NodeNames = Schema.Union(
+    Schema.Tuple(Schema.Literal('A'), Schema.Literal('B')),
+    Schema.Tuple(Schema.Literal('B'), Schema.Literal('A')),
+  )
 
-      const fromChannelType = (
-        channelType: typeof ChannelType.Type,
-      ): {
-        mode: 'messagechannel' | 'proxy'
-        connectNodes: typeof connectNodesViaMessageChannel | typeof connectNodesViaBroadcastChannel
-      } => {
-        switch (channelType) {
-          case 'proxy': {
-            return { mode: 'proxy', connectNodes: connectNodesViaBroadcastChannel }
-          }
-          case 'messagechannel': {
-            return { mode: 'messagechannel', connectNodes: connectNodesViaMessageChannel }
-          }
-          case 'messagechannel.proxy': {
-            return { mode: 'proxy', connectNodes: connectNodesViaMessageChannel }
-          }
-        }
+  const fromChannelType = (
+    channelType: typeof ChannelType.Type,
+  ): {
+    mode: 'messagechannel' | 'proxy'
+    connectNodes: typeof connectNodesViaMessageChannel | typeof connectNodesViaBroadcastChannel
+  } => {
+    switch (channelType) {
+      case 'proxy': {
+        return { mode: 'proxy', connectNodes: connectNodesViaBroadcastChannel }
       }
+      case 'messagechannel': {
+        return { mode: 'messagechannel', connectNodes: connectNodesViaMessageChannel }
+      }
+      case 'messagechannel.proxy': {
+        return { mode: 'proxy', connectNodes: connectNodesViaMessageChannel }
+      }
+    }
+  }
+
+  const exchangeMessages = ({
+    nodeX,
+    nodeY,
+    channelType,
+    // numberOfMessages = 1,
+    delays,
+  }: {
+    nodeX: MeshNode
+    nodeY: MeshNode
+    channelType: 'messagechannel' | 'proxy' | 'messagechannel.proxy'
+    numberOfMessages?: number
+    delays?: { x?: number; y?: number; connect?: number }
+  }) =>
+    Effect.gen(function* () {
+      const nodeLabel = { x: nodeX.nodeName, y: nodeY.nodeName }
+      const { mode, connectNodes } = fromChannelType(channelType)
+
+      const nodeXCode = Effect.gen(function* () {
+        const channelXToY = yield* createChannel(nodeX, nodeY.nodeName, { mode })
+
+        yield* channelXToY.send({ message: `${nodeLabel.x}1` })
+        // console.log('channelXToY', channelXToY.debugInfo)
+        expect(yield* getFirstMessage(channelXToY)).toEqual({ message: `${nodeLabel.y}1` })
+        // expect(channelXToY.debugInfo.connectCounter).toBe(1)
+      })
 
-      const exchangeMessages = ({
-        nodeX,
-        nodeY,
-        channelType,
-        // numberOfMessages = 1,
-        delays,
-      }: {
-        nodeX: MeshNode
-        nodeY: MeshNode
-        channelType: 'messagechannel' | 'proxy' | 'messagechannel.proxy'
-        numberOfMessages?: number
-        delays?: { x?: number; y?: number; connect?: number }
-      }) =>
-        Effect.gen(function* () {
-          const nodeLabel = { x: nodeX.nodeName, y: nodeY.nodeName }
-          const { mode, connectNodes } = fromChannelType(channelType)
-
-          const nodeXCode = Effect.gen(function* () {
-            const channelXToY = yield* createChannel(nodeX, nodeY.nodeName, { mode })
-
-            yield* channelXToY.send({ message: `${nodeLabel.x}1` })
-            // console.log('channelXToY', channelXToY.debugInfo)
-            expect(yield* getFirstMessage(channelXToY)).toEqual({ message: `${nodeLabel.y}1` })
-            // expect(channelXToY.debugInfo.connectCounter).toBe(1)
-          })
-
-          const nodeYCode = Effect.gen(function* () {
-            const channelYToX = yield* createChannel(nodeY, nodeX.nodeName, { mode })
-
-            yield* channelYToX.send({ message: `${nodeLabel.y}1` })
-            // console.log('channelYToX', channelYToX.debugInfo)
-            expect(yield* getFirstMessage(channelYToX)).toEqual({ message: `${nodeLabel.x}1` })
-            // expect(channelYToX.debugInfo.connectCounter).toBe(1)
-          })
+      const nodeYCode = Effect.gen(function* () {
+        const channelYToX = yield* createChannel(nodeY, nodeX.nodeName, { mode })
 
-          yield* Effect.all(
-            [
-              connectNodes(nodeX, nodeY).pipe(maybeDelay(delays?.connect, 'connectNodes')),
-              nodeXCode.pipe(maybeDelay(delays?.x, `node${nodeLabel.x}Code`)),
-              nodeYCode.pipe(maybeDelay(delays?.y, `node${nodeLabel.y}Code`)),
-            ],
-            { concurrency: 'unbounded' },
-          ).pipe(Effect.withSpan(`exchangeMessages(${nodeLabel.x}↔${nodeLabel.y})`))
-        })
+        yield* channelYToX.send({ message: `${nodeLabel.y}1` })
+        // console.log('channelYToX', channelYToX.debugInfo)
+        expect(yield* getFirstMessage(channelYToX)).toEqual({ message: `${nodeLabel.x}1` })
+        // expect(channelYToX.debugInfo.connectCounter).toBe(1)
+      })
 
+      yield* Effect.all(
+        [
+          connectNodes(nodeX, nodeY).pipe(maybeDelay(delays?.connect, 'connectNodes')),
+          nodeXCode.pipe(maybeDelay(delays?.x, `node${nodeLabel.x}Code`)),
+          nodeYCode.pipe(maybeDelay(delays?.y, `node${nodeLabel.y}Code`)),
+        ],
+        { concurrency: 'unbounded' },
+      ).pipe(Effect.withSpan(`exchangeMessages(${nodeLabel.x}↔${nodeLabel.y})`))
+    })
+  Vitest.describe('A <> B', () => {
+    Vitest.describe('prop tests', { timeout: propTestTimeout }, () => {
       // const delayX = 40
       // const delayY = undefined
       // const connectDelay = undefined
@@ -455,6 +454,40 @@ Vitest.describe('webmesh node', { timeout: testTimeout }, () => {
       })
     })
 
+    Vitest.describe('message channel specific tests', () => {
+      Vitest.scopedLive('differing initial connection counter', (test) =>
+        Effect.gen(function* () {
+          const nodeA = yield* makeMeshNode('A')
+          const nodeB = yield* makeMeshNode('B')
+
+          yield* connectNodesViaMessageChannel(nodeA, nodeB)
+
+          const messageCount = 3
+
+          const bFiber = yield* Effect.gen(function* () {
+            const channelBToA = yield* createChannel(nodeB, 'A')
+            yield* channelBToA.listen.pipe(
+              Stream.flatten(),
+              Stream.tap((msg) => channelBToA.send({ message: `resp:${msg.message}` })),
+              Stream.take(messageCount),
+              Stream.runDrain,
+            )
+          }).pipe(Effect.scoped, Effect.fork)
+
+          // yield* createChannel(nodeA, 'B').pipe(Effect.andThen(WebChannel.shutdown))
+          // // yield* createChannel(nodeA, 'B').pipe(Effect.andThen(WebChannel.shutdown))
+          // // yield* createChannel(nodeA, 'B').pipe(Effect.andThen(WebChannel.shutdown))
+          yield* Effect.gen(function* () {
+            const channelAToB = yield* createChannel(nodeA, 'B')
+            yield* channelAToB.send({ message: 'A' })
+            expect(yield* getFirstMessage(channelAToB)).toEqual({ message: 'resp:A' })
+          }).pipe(Effect.scoped, Effect.repeatN(messageCount))
+
+          yield* bFiber
+        }).pipe(withCtx(test)),
+      )
+    })
+
     Vitest.scopedLive('manual debug test', (test) =>
       Effect.gen(function* () {
         const nodeA = yield* makeMeshNode('A')
@@ -587,7 +620,7 @@ Vitest.describe('webmesh node', { timeout: testTimeout }, () => {
       }).pipe(withCtx(test)),
     )
 
-    Vitest.scopedLive('should fail', (test) =>
+    Vitest.scopedLive('should fail with timeout due to missing connection', (test) =>
       Effect.gen(function* () {
         const nodeA = yield* makeMeshNode('A')
         const nodeB = yield* makeMeshNode('B')
@@ -610,6 +643,27 @@ Vitest.describe('webmesh node', { timeout: testTimeout }, () => {
       }).pipe(withCtx(test)),
     )
 
+    Vitest.scopedLive('should fail with timeout due no transferable', (test) =>
+      Effect.gen(function* () {
+        const nodeA = yield* makeMeshNode('A')
+        const nodeB = yield* makeMeshNode('B')
+
+        yield* connectNodesViaBroadcastChannel(nodeA, nodeB)
+
+        const nodeACode = Effect.gen(function* () {
+          const err = yield* createChannel(nodeA, 'B').pipe(Effect.timeout(200), Effect.flip)
+          expect(err._tag).toBe('TimeoutException')
+        })
+
+        const nodeBCode = Effect.gen(function* () {
+          const err = yield* createChannel(nodeB, 'A').pipe(Effect.timeout(200), Effect.flip)
+          expect(err._tag).toBe('TimeoutException')
+        })
+
+        yield* Effect.all([nodeACode, nodeBCode], { concurrency: 'unbounded' })
+      }).pipe(withCtx(test)),
+    )
+
     Vitest.scopedLive('reconnect with re-created node', (test) =>
       Effect.gen(function* () {
         const nodeCgen1Scope = yield* Scope.make()
@@ -705,7 +759,6 @@ Vitest.describe('webmesh node', { timeout: testTimeout }, () => {
       }).pipe(withCtx(test)),
     )
 
-    // TODO this currently fails but should work. probably needs some more guarding internally.
     Vitest.scopedLive('should work for messagechannels', (test) =>
       Effect.gen(function* () {
         const nodeA = yield* makeMeshNode('A')

package/src/node.ts

@@ -156,6 +156,8 @@ export const makeMeshNode = (nodeName: MeshNodeName): Effect.Effect<MeshNode, ne
 
     const sendPacket = (packet: typeof MeshSchema.Packet.Type) =>
       Effect.gen(function* () {
+        // yield* Effect.log(`${nodeName}: sendPacket:${packet._tag} [${packet.id}]`)
+
         if (Schema.is(MeshSchema.NetworkConnectionAdded)(packet)) {
           yield* Effect.spanEvent('NetworkConnectionAdded', { packet, nodeName })
           yield* PubSub.publish(newConnectionAvailablePubSub, packet.target)