@libp2p/utils 4.0.7-effcfaa8e → 5.0.0

package/src/stream-to-ma-conn.ts

@@ -1,14 +1,11 @@
-import { logger } from '@libp2p/logger'
-import type { AbortOptions } from '@libp2p/interface'
-import type { MultiaddrConnection, Stream } from '@libp2p/interface/connection'
+import type { ComponentLogger, MultiaddrConnection, Stream } from '@libp2p/interface'
 import type { Multiaddr } from '@multiformats/multiaddr'
 
-const log = logger('libp2p:stream:converter')
-
 export interface StreamProperties {
   stream: Stream
   remoteAddr: Multiaddr
   localAddr: Multiaddr
+  logger: ComponentLogger
 }
 
 /**
@@ -16,49 +13,75 @@ export interface StreamProperties {
  * https://github.com/libp2p/interface-transport#multiaddrconnection
  */
 export function streamToMaConnection (props: StreamProperties): MultiaddrConnection {
-  const { stream, remoteAddr } = props
-  const { sink, source } = stream
+  const { stream, remoteAddr, logger } = props
+  const log = logger.forComponent('libp2p:stream:converter')
+
+  let closedRead = false
+  let closedWrite = false
+
+  // piggyback on `stream.close` invocations to close maconn
+  const streamClose = stream.close.bind(stream)
+  stream.close = async (options) => {
+    await streamClose(options)
+    close(true)
+  }
 
-  const mapSource = (async function * () {
-    for await (const list of source) {
-      if (list instanceof Uint8Array) {
-        yield list
-      } else {
-        yield * list
+  // piggyback on `stream.abort` invocations to close maconn
+  const streamAbort = stream.abort.bind(stream)
+  stream.abort = (err) => {
+    streamAbort(err)
+    close(true)
+  }
+
+  // piggyback on `stream.sink` invocations to close maconn
+  const streamSink = stream.sink.bind(stream)
+  stream.sink = async (source) => {
+    try {
+      await streamSink(source)
+    } catch (err: any) {
+      // If aborted we can safely ignore
+      if (err.type !== 'aborted') {
+        // If the source errored the socket will already have been destroyed by
+        // toIterable.duplex(). If the socket errored it will already be
+        // destroyed. There's nothing to do here except log the error & return.
+        log(err)
       }
+    } finally {
+      closedWrite = true
+      close()
     }
-  }())
+  }
 
   const maConn: MultiaddrConnection = {
-    async sink (source) {
+    log,
+    sink: stream.sink,
+    source: (async function * () {
       try {
-        await sink(source)
-        close()
-      } catch (err: any) {
-        // If aborted we can safely ignore
-        if (err.type !== 'aborted') {
-          // If the source errored the socket will already have been destroyed by
-          // toIterable.duplex(). If the socket errored it will already be
-          // destroyed. There's nothing to do here except log the error & return.
-          log(err)
+        for await (const list of stream.source) {
+          if (list instanceof Uint8Array) {
+            yield list
+          } else {
+            yield * list
+          }
         }
+      } finally {
+        closedRead = true
+        close()
       }
-    },
-    source: mapSource,
+    }()),
     remoteAddr,
     timeline: { open: Date.now(), close: undefined },
-    async close (options?: AbortOptions) {
-      close()
-      await stream.close(options)
-    },
-    abort (err: Error): void {
-      close()
-      stream.abort(err)
-    }
+    close: stream.close,
+    abort: stream.abort
   }
 
-  function close (): void {
-    if (maConn.timeline.close == null) {
+  function close (force?: boolean): void {
+    if (force === true) {
+      closedRead = true
+      closedWrite = true
+    }
+
+    if (closedRead && closedWrite && maConn.timeline.close == null) {
       maConn.timeline.close = Date.now()
     }
   }

package/src/tracked-map.ts

@@ -0,0 +1,65 @@
+import type { Metric, Metrics } from '@libp2p/interface'
+
+export interface TrackedMapInit {
+  name: string
+  metrics: Metrics
+}
+
+class TrackedMap<K, V> extends Map<K, V> {
+  private readonly metric: Metric
+
+  constructor (init: TrackedMapInit) {
+    super()
+
+    const { name, metrics } = init
+
+    this.metric = metrics.registerMetric(name)
+    this.updateComponentMetric()
+  }
+
+  set (key: K, value: V): this {
+    super.set(key, value)
+    this.updateComponentMetric()
+    return this
+  }
+
+  delete (key: K): boolean {
+    const deleted = super.delete(key)
+    this.updateComponentMetric()
+    return deleted
+  }
+
+  clear (): void {
+    super.clear()
+    this.updateComponentMetric()
+  }
+
+  private updateComponentMetric (): void {
+    this.metric.update(this.size)
+  }
+}
+
+export interface CreateTrackedMapInit {
+  /**
+   * The metric name to use
+   */
+  name: string
+
+  /**
+   * A metrics implementation
+   */
+  metrics?: Metrics
+}
+
+export function trackedMap <K, V> (config: CreateTrackedMapInit): Map<K, V> {
+  const { name, metrics } = config
+  let map: Map<K, V>
+
+  if (metrics != null) {
+    map = new TrackedMap<K, V>({ name, metrics })
+  } else {
+    map = new Map<K, V>()
+  }
+
+  return map
+}