@libp2p/memory 1.1.14 → 2.0.0-049bfa0fa

package/src/connections.ts

@@ -1,55 +1,12 @@
-/**
- * @packageDocumentation
- *
- * A [libp2p transport](https://docs.libp2p.io/concepts/transports/overview/)
- * that operates in-memory only.
- *
- * This is intended for testing and can only be used to connect two libp2p nodes
- * that are running in the same process.
- *
- * @example
- *
- * ```TypeScript
- * import { createLibp2p } from 'libp2p'
- * import { memory } from '@libp2p/memory'
- * import { multiaddr } from '@multiformats/multiaddr'
- *
- * const listener = await createLibp2p({
- *   addresses: {
- *     listen: [
- *       '/memory/node-a'
- *     ]
- *   },
- *   transports: [
- *     memory()
- *   ]
- * })
- *
- * const dialer = await createLibp2p({
- *   transports: [
- *     memory()
- *   ]
- * })
- *
- * const ma = multiaddr('/memory/node-a')
- *
- * // dial the listener, timing out after 10s
- * const connection = await dialer.dial(ma, {
- *   signal: AbortSignal.timeout(10_000)
- * })
- *
- * // use connection...
- * ```
- */
-
 import { ConnectionFailedError } from '@libp2p/interface'
 import { multiaddr } from '@multiformats/multiaddr'
 import delay from 'delay'
-import map from 'it-map'
 import { pushable } from 'it-pushable'
 import { raceSignal } from 'race-signal'
+import { DEFAULT_MAX_MESSAGE_SIZE } from './constants.ts'
+import { pushableToMaConn } from './pushable-to-conn.ts'
 import type { MemoryTransportComponents, MemoryTransportInit } from './index.js'
-import type { MultiaddrConnection, PeerId } from '@libp2p/interface'
+import type { Logger, MultiaddrConnection, PeerId } from '@libp2p/interface'
 import type { Uint8ArrayList } from 'uint8arraylist'
 
 export const connections = new Map<string, MemoryConnection>()
@@ -63,106 +20,74 @@ interface MemoryConnectionInit extends MemoryTransportInit {
   address: string
 }
 
+let connectionId = 0
+
 export class MemoryConnection {
+  public readonly latency: number
+
   private readonly components: MemoryTransportComponents
   private readonly init: MemoryConnectionInit
   private readonly connections: Set<MultiaddrConnection>
-  private readonly latency: number
+  private readonly log: Logger
 
   constructor (components: MemoryTransportComponents, init: MemoryConnectionInit) {
     this.components = components
     this.init = init
     this.connections = new Set()
     this.latency = init.latency ?? 0
+    this.log = components.logger.forComponent('libp2p:memory')
   }
 
-  async dial (dialingPeerId: PeerId, signal: AbortSignal): Promise<MultiaddrConnection> {
-    const dialerPushable = pushable<Uint8Array | Uint8ArrayList>()
-    const listenerPushable = pushable<Uint8Array | Uint8ArrayList>()
+  async dial (dialingPeerId: PeerId, dialingPeerLog: Logger, signal: AbortSignal): Promise<MultiaddrConnection> {
     const self = this
 
-    const dialer: MultiaddrConnection = {
-      source: (async function * () {
-        yield * map(listenerPushable, async buf => {
-          if (self.latency > 0) {
-            await delay(self.latency)
-          }
-
-          return buf
-        })
-      })(),
-      sink: async (source) => {
-        for await (const buf of source) {
-          dialerPushable.push(buf)
+    let dialerEnded = false
+    let listenerEnded = false
+
+    const dialerPushable = pushable<Uint8Array | Uint8ArrayList>({
+      onEnd (err) {
+        dialerEnded = true
+        self.connections.delete(dialer)
+
+        if (!listenerEnded) {
+          listenerPushable.end(err)
         }
-      },
-      close: async () => {
-        dialerPushable.end()
-        this.connections.delete(dialer)
-        dialer.timeline.close = Date.now()
-
-        listenerPushable.end()
-        this.connections.delete(listener)
-        listener.timeline.close = Date.now()
-      },
-      abort: (err) => {
-        dialerPushable.end(err)
-        this.connections.delete(dialer)
-        dialer.timeline.close = Date.now()
-
-        listenerPushable.end(err)
-        this.connections.delete(listener)
-        listener.timeline.close = Date.now()
-      },
-      timeline: {
-        open: Date.now()
-      },
-      remoteAddr: multiaddr(`${this.init.address}/p2p/${this.components.peerId}`),
-      log: this.components.logger.forComponent('libp2p:memory')
-    }
-
-    const listener: MultiaddrConnection = {
-      source: (async function * () {
-        yield * map(dialerPushable, async buf => {
-          if (self.latency > 0) {
-            await delay(self.latency)
-          }
-
-          return buf
-        })
-      })(),
-      sink: async (source) => {
-        for await (const buf of source) {
-          listenerPushable.push(buf)
+      }
+    })
+    const listenerPushable = pushable<Uint8Array | Uint8ArrayList>({
+      onEnd (err) {
+        listenerEnded = true
+        self.connections.delete(listener)
+
+        if (!dialerEnded) {
+          dialerPushable.end(err)
         }
-      },
-      close: async () => {
-        listenerPushable.end()
-        this.connections.delete(listener)
-        listener.timeline.close = Date.now()
-
-        dialerPushable.end()
-        this.connections.delete(dialer)
-        dialer.timeline.close = Date.now()
-      },
-      abort: (err) => {
-        listenerPushable.end(err)
-        this.connections.delete(listener)
-        listener.timeline.close = Date.now()
-
-        dialerPushable.end(err)
-        this.connections.delete(dialer)
-        dialer.timeline.close = Date.now()
-      },
-      timeline: {
-        open: Date.now()
-      },
+      }
+    })
+
+    const dialer = pushableToMaConn({
+      connection: this,
+      remoteAddr: multiaddr(`${this.init.address}/p2p/${this.components.peerId}`),
+      direction: 'outbound',
+      localPushable: dialerPushable,
+      remotePushable: listenerPushable,
+      log: dialingPeerLog.newScope(`connection:${connectionId}`),
+      maxMessageSize: this.init.maxMessageSize ?? DEFAULT_MAX_MESSAGE_SIZE
+    })
+
+    const listener = pushableToMaConn({
+      connection: this,
       remoteAddr: multiaddr(`${this.init.address}-outgoing/p2p/${dialingPeerId}`),
-      log: this.components.logger.forComponent('libp2p:memory')
-    }
+      direction: 'inbound',
+      localPushable: listenerPushable,
+      remotePushable: dialerPushable,
+      log: this.log.newScope(`connection:${connectionId}`),
+      maxMessageSize: this.init.maxMessageSize ?? DEFAULT_MAX_MESSAGE_SIZE
+    })
 
     this.connections.add(dialer)
     this.connections.add(listener)
+    connectionId++
 
     await raceSignal(delay(this.latency), signal)
 

package/src/constants.ts

@@ -0,0 +1 @@
+export const DEFAULT_MAX_MESSAGE_SIZE = 65_536

package/src/index.ts

@@ -59,6 +59,13 @@ export interface MemoryTransportInit {
    * @default 0
    */
   latency?: number
+
+  /**
+   * Data messages larger than this will be chunked before sending
+   *
+   * @default 65_536
+   */
+  maxMessageSize?: number
 }
 
 export function memory (init?: MemoryTransportInit): (components: MemoryTransportComponents) => Transport {

package/src/listener.ts

@@ -28,7 +28,8 @@ export class MemoryTransportListener extends TypedEventEmitter<ListenerEvents> i
   }
 
   async listen (ma: Multiaddr): Promise<void> {
-    const [[, value]] = ma.stringTuples()
+    const components = ma.getComponents()
+    const value = components[0]?.value
 
     const address = `/memory/${value ?? nanoid()}`
 

package/src/memory.ts

@@ -1,4 +1,5 @@
 import { ConnectionFailedError, serviceCapabilities, transportSymbol } from '@libp2p/interface'
+import { CODE_P2P } from '@multiformats/multiaddr'
 import { Memory } from '@multiformats/multiaddr-matcher'
 import { connections } from './connections.js'
 import { MemoryTransportListener } from './listener.js'
@@ -26,13 +27,14 @@ export class MemoryTransport implements Transport {
   async dial (ma: Multiaddr, options: DialTransportOptions): Promise<Connection> {
     options.signal.throwIfAborted()
 
-    const memoryConnection = connections.get(`${ma.getPeerId() == null ? ma : ma.decapsulate('/p2p')}`)
+    const peerId = ma.getComponents().find(c => c.code === CODE_P2P)?.value
+    const memoryConnection = connections.get(`${peerId == null ? ma : ma.decapsulate('/p2p')}`)
 
     if (memoryConnection == null) {
       throw new ConnectionFailedError(`No memory listener found at ${ma}`)
     }
 
-    const maConn = await memoryConnection.dial(this.components.peerId, options.signal)
+    const maConn = await memoryConnection.dial(this.components.peerId, this.components.logger.forComponent('libp2p:memory'), options.signal)
 
     try {
       options.signal.throwIfAborted()

package/src/pushable-to-conn.ts

@@ -0,0 +1,78 @@
+import { StreamResetError } from '@libp2p/interface'
+import { AbstractMultiaddrConnection } from '@libp2p/utils'
+import delay from 'delay'
+import map from 'it-map'
+import { Uint8ArrayList } from 'uint8arraylist'
+import type { MemoryConnection } from './connections.ts'
+import type { MessageStreamDirection, MultiaddrConnection, AbortOptions } from '@libp2p/interface'
+import type { AbstractMultiaddrConnectionInit, SendResult } from '@libp2p/utils'
+import type { Multiaddr } from '@multiformats/multiaddr'
+import type { Pushable } from 'it-pushable'
+
+export interface MemoryMultiaddrConnectionInit extends Omit<AbstractMultiaddrConnectionInit, 'name' | 'stream'> {
+  localPushable: Pushable<Uint8Array | Uint8ArrayList>
+  remotePushable: Pushable<Uint8Array | Uint8ArrayList>
+  inactivityTimeout?: number
+  closeTimeout?: number
+  listeningAddr?: Multiaddr
+  connection: MemoryConnection
+  direction: MessageStreamDirection
+}
+
+class MemoryMultiaddrConnection extends AbstractMultiaddrConnection {
+  private localPushable: Pushable<Uint8Array | Uint8ArrayList>
+
+  constructor (init: MemoryMultiaddrConnectionInit) {
+    super(init)
+
+    this.localPushable = init.localPushable
+
+    Promise.resolve()
+      .then(async () => {
+        for await (const buf of map(init.remotePushable, async buf => {
+          if (init.connection.latency > 0) {
+            await delay(init.connection.latency)
+          }
+
+          return buf
+        })) {
+          this.onData(buf)
+        }
+
+        this.onTransportClosed()
+      })
+      .catch(err => {
+        this.abort(err)
+      })
+  }
+
+  sendReset (): void {
+    this.localPushable.end(new StreamResetError())
+  }
+
+  sendData (data: Uint8ArrayList): SendResult {
+    this.localPushable.push(data)
+
+    return {
+      sentBytes: data.byteLength,
+      canSendMore: true
+    }
+  }
+
+  async sendClose (options?: AbortOptions): Promise<void> {
+    this.localPushable.end()
+    options?.signal?.throwIfAborted()
+  }
+
+  sendPause (): void {
+    // read backpressure is not supported
+  }
+
+  sendResume (): void {
+    // read backpressure is not supported
+  }
+}
+
+export function pushableToMaConn (init: MemoryMultiaddrConnectionInit): MultiaddrConnection {
+  return new MemoryMultiaddrConnection(init)
+}

package/dist/typedoc-urls.json

@@ -1,8 +0,0 @@
-{
-  "MemoryTransportComponents": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_memory.MemoryTransportComponents.html",
-  ".:MemoryTransportComponents": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_memory.MemoryTransportComponents.html",
-  "MemoryTransportInit": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_memory.MemoryTransportInit.html",
-  ".:MemoryTransportInit": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_memory.MemoryTransportInit.html",
-  "memory": "https://libp2p.github.io/js-libp2p/functions/_libp2p_memory.memory.html",
-  ".:memory": "https://libp2p.github.io/js-libp2p/functions/_libp2p_memory.memory.html"
-}