jspurefix 5.8.5 → 5.9.2

package/src/transport/session/fix-session.ts

@@ -9,17 +9,44 @@ import * as events from 'events'
 import { SessionState } from './session-state'
 import { SegmentType } from '../../buffer/segment/segment-type'
 
+/**
+ * The set of listeners this session attached to one specific transport.
+ *
+ * The handlers must be kept as stable references - `EventEmitter.removeListener`
+ * matches on identity, so subscribing with a fresh closure and unsubscribing with
+ * a method reference silently leaves the listener attached (issue #153).  Holding
+ * the transport alongside the handlers also lets `unsubscribe` detach from the
+ * transport it actually subscribed to, even when `this.transport` has already
+ * moved on to a newer connection.
+ */
+interface ITransportSubscription {
+  readonly transport: MsgTransport
+  readonly rxOnMsg: (msgType: string, view: MsgView) => void
+  readonly rxOnError: (e: Error) => void
+  readonly rxOnDone: () => void
+  readonly rxOnEnd: () => void
+  readonly rxOnDecoded: (msgType: string, data: ElasticBuffer, ptr: number) => void
+  readonly txOnError: (e: Error) => void
+  readonly txOnEncoded: (msgType: string, data: string, hdr: ILooseObject) => void
+}
+
 export abstract class FixSession extends events.EventEmitter {
   public logReceivedMsgs: boolean = false
   protected timer: NodeJS.Timeout | null = null
   protected transport: MsgTransport | null = null
+  private subscription: ITransportSubscription | null = null
   public manageSession: boolean = true
   public checkMsgIntegrity: boolean = false
   protected readonly me: string
   protected readonly initiator: boolean
   protected readonly acceptor: boolean
   protected readonly sessionState: FixSessionState
-  protected readonly sessionLogger: IJsFixLogger
+  /**
+   * Not readonly: a wildcard acceptor does not know which counterparty it is
+   * serving until the Logon arrives, and every session on that listener would
+   * otherwise log under the same name.  Rebound once the identity is known.
+   */
+  protected sessionLogger: IJsFixLogger
   protected requestLogoutType: string
   protected respondLogoutType: string
   protected requestLogonType: string
@@ -120,7 +147,9 @@ export abstract class FixSession extends events.EventEmitter {
       }
       const onError = (e: Error): void => {
         cleanup()
-        logger.error(e)
+        // read the logger now, not the one captured when the run started - a
+        // wildcard acceptor rebinds it once it knows which peer it is serving
+        this.sessionLogger.error(e)
         reject(e)
       }
       const onDone = (): void => {
@@ -217,35 +246,90 @@ export abstract class FixSession extends events.EventEmitter {
     this.onEncoded(msgType, data)
   }
 
+  /**
+   * true when the event which has just fired came from the transport this session
+   * is currently running.  A half open socket can keep emitting long after the peer
+   * has reconnected on a fresh connection - those events must not be allowed to drive
+   * the live session (issue #153).
+   */
+  private isCurrentTransport (transport: MsgTransport, event: string): boolean {
+    if (this.subscription?.transport === transport && this.transport === transport) {
+      return true
+    }
+    const current = this.transport?.id ?? 'none'
+    this.sessionLogger.warning(`ignoring '${event}' from stale transport ${transport.id} - current transport is ${current}`)
+    return false
+  }
+
   protected unsubscribe (): void {
     const logger = this.sessionLogger
-    logger.info(`unsubscribe sessionState = [${this.sessionState.toString()}]`)
-    const transport = this.transport
-    const rx = transport?.receiver
-    const tx = transport?.transmitter
-
-    rx?.removeListener('msg', this.rxOnMsg)
-    rx?.removeListener('error', this.rxOnError)
-    rx?.removeListener('done', this.rxOnDone)
-    rx?.removeListener('end', this.rxOnEnd)
-    rx?.removeListener('decoded', this.rxOnDecoded)
-    tx?.removeListener('error', this.txOnError)
-    tx?.removeListener('encoded', this.txOnEncoded)
+    const subscription = this.subscription
+    if (!subscription) {
+      logger.debug('unsubscribe called with no active subscription')
+      return
+    }
+    const transport = subscription.transport
+    logger.info(`unsubscribe transport ${transport.id} sessionState = [${this.sessionState.toString()}]`)
+    const rx = transport.receiver
+    const tx = transport.transmitter
+
+    rx?.removeListener('msg', subscription.rxOnMsg)
+    rx?.removeListener('error', subscription.rxOnError)
+    rx?.removeListener('done', subscription.rxOnDone)
+    rx?.removeListener('end', subscription.rxOnEnd)
+    rx?.removeListener('decoded', subscription.rxOnDecoded)
+    tx?.removeListener('error', subscription.txOnError)
+    tx?.removeListener('encoded', subscription.txOnEncoded)
+    this.subscription = null
+    logger.debug(`unsubscribe complete - rx listeners now ${rx?.listenerCount('msg') ?? 0} msg, ${rx?.listenerCount('end') ?? 0} end`)
   }
 
   protected subscribe (): void {
     const transport = this.transport
-
-    const rx = transport?.receiver
-    const tx = transport?.transmitter
+    if (!transport) {
+      this.sessionLogger.warning('subscribe called with no transport')
+      return
+    }
+    // detach from any previous transport before attaching to this one
+    if (this.subscription) {
+      this.unsubscribe()
+    }
     const inst = this
-    rx?.on('msg', (msgType: string, view: MsgView) => { inst.rxOnMsg(msgType, view) })
-    rx?.on('error', (e: Error) => { inst.rxOnError(e) })
-    rx?.on('done', () => { inst.rxOnDone() })
-    rx?.on('end', () => { inst.rxOnEnd() })
-    rx?.on('decoded', (msgType: string, data: ElasticBuffer, ptr: number) => { inst.rxOnDecoded(msgType, data, ptr) })
-    tx?.on('error', (e: Error) => { inst.txOnError(e) })
-    tx?.on('encoded', (msgType: string, data: string, hdr: ILooseObject) => { inst.txOnEncoded(msgType, data, hdr) })
+    const subscription: ITransportSubscription = {
+      transport,
+      rxOnMsg: (msgType: string, view: MsgView) => {
+        if (inst.isCurrentTransport(transport, 'msg')) inst.rxOnMsg(msgType, view)
+      },
+      rxOnError: (e: Error) => {
+        if (inst.isCurrentTransport(transport, 'error')) inst.rxOnError(e)
+      },
+      rxOnDone: () => {
+        if (inst.isCurrentTransport(transport, 'done')) inst.rxOnDone()
+      },
+      rxOnEnd: () => {
+        if (inst.isCurrentTransport(transport, 'end')) inst.rxOnEnd()
+      },
+      rxOnDecoded: (msgType: string, data: ElasticBuffer, ptr: number) => {
+        if (inst.isCurrentTransport(transport, 'decoded')) inst.rxOnDecoded(msgType, data, ptr)
+      },
+      txOnError: (e: Error) => {
+        if (inst.isCurrentTransport(transport, 'tx error')) inst.txOnError(e)
+      },
+      txOnEncoded: (msgType: string, data: string, hdr: ILooseObject) => {
+        if (inst.isCurrentTransport(transport, 'encoded')) inst.txOnEncoded(msgType, data, hdr)
+      }
+    }
+    const rx = transport.receiver
+    const tx = transport.transmitter
+    rx?.on('msg', subscription.rxOnMsg)
+    rx?.on('error', subscription.rxOnError)
+    rx?.on('done', subscription.rxOnDone)
+    rx?.on('end', subscription.rxOnEnd)
+    rx?.on('decoded', subscription.rxOnDecoded)
+    tx?.on('error', subscription.txOnError)
+    tx?.on('encoded', subscription.txOnEncoded)
+    this.subscription = subscription
+    this.sessionLogger.info(`subscribed to transport ${transport.id}`)
   }
 
   protected validStateApplicationMsg (): boolean {
@@ -285,12 +369,16 @@ export abstract class FixSession extends events.EventEmitter {
     if (this.sessionState.state === SessionState.Stopped) return
     this.sessionLogger.error(error)
     this.stopTimer()
+    this.unsubscribe()
     if (this.transport) {
+      this.sessionLogger.info(`terminate: kill transport ${this.transport.id}`)
       this.transport.end()
     }
     this.transport = null
     this.setState(SessionState.Stopped)
+    this.onSessionStopping()
     this.emit('error', error)
+    this.onStopped(error)
   }
 
   protected peerLogout (view: MsgView): void {
@@ -415,6 +503,16 @@ export abstract class FixSession extends events.EventEmitter {
     // Override in subclass to reset coordinator/transient state
   }
 
+  /**
+   * Called once as the session moves to Stopped, before the application is informed
+   * via onStopped.  Override to release session scoped resources - the ascii session
+   * uses this to remove itself from the session registry.  Mirrors cspurefix
+   * FixSession.OnSessionStopping.
+   */
+  protected onSessionStopping (): void {
+    // Default no-op
+  }
+
   /**
    * Called for initiators after the store is loaded but before the Logon is sent.
    * Override to reset sequences/store when ResetSeqNumFlag=Y so the Logon goes out
@@ -424,13 +522,26 @@ export abstract class FixSession extends events.EventEmitter {
     // Default no-op
   }
 
+  /**
+   * Stop this session on behalf of an external caller - typically the session registry
+   * when a new connection for the same SessionId replaces this one, but equally an
+   * application which has decided the peer is gone.  Mirrors cspurefix
+   * FixSession.RequestStop.
+   * @param reason recorded in the session log and carried on the emitted error
+   */
+  public requestStop (reason: string): void {
+    this.sessionLogger.info(`requestStop: ${reason}`)
+    this.stop(new Error(reason))
+  }
+
   protected stop (error: Error | null = null): void {
     if (this.sessionState.state === SessionState.Stopped) {
       return
     }
     this.stopTimer()
     this.unsubscribe()
-    this.sessionLogger.info('stop: kill transport')
+    this.sessionLogger.info(`stop: kill transport ${this.transport?.id ?? 'none'}`)
+    this.onSessionStopping()
     this.transport?.end()
     if (error) {
       this.sessionLogger.info(`stop: emit error ${error.message}`)

package/src/transport/session/index.ts

@@ -10,3 +10,5 @@ export * from './session-sequence-coordinator'
 export * from './session-sequence-store'
 export * from './resend-request-manager'
 export * from './fix-clock'
+export * from './session-registry'
+export * from './clone-session-description'

package/src/transport/session/resend-request-manager.ts

@@ -46,7 +46,7 @@ export class ResendAction {
 }
 
 export class PendingResendRange {
-  private readonly receivedSeqs: Set<number> = new Set()
+  private readonly receivedSeqs = new Set<number>()
 
   constructor (
     public readonly begin: number,
@@ -190,11 +190,11 @@ export class ResendRequestManager {
     // keep requestHistory for debugging
   }
 
-  get pending (): ReadonlyArray<PendingResendRange> {
+  get pending (): readonly PendingResendRange[] {
     return this.pendingRequests.slice()
   }
 
-  get history (): ReadonlyArray<ResendRequestRecord> {
+  get history (): readonly ResendRequestRecord[] {
     return this.requestHistory.slice()
   }
 
@@ -240,7 +240,7 @@ export class ResendRequestManager {
       return { begin: gapBegin, end: gapEnd }
     }
 
-    const covered: Set<number> = new Set()
+    const covered = new Set<number>()
     for (const pending of this.pendingRequests) {
       for (let seq = pending.begin; seq <= pending.end; seq++) {
         covered.add(seq)

package/src/transport/session/session-msg-factory.ts

@@ -13,4 +13,17 @@ export interface ISessionMsgFactory {
   heartbeat: (testReqId: string) => ILooseObject
   header: (msgType: string, seqNum: number, time: Date, overrideData?: Partial<IStandardHeader>) => ILooseObject
   trailer: (checksum: number) => ILooseObject
+  /**
+   * Produce a factory of this same kind bound to another session description.
+   *
+   * An acceptor builds one of these per accepted connection, because the outbound
+   * header carries that session's comp ids - and under a wildcard TargetCompID the
+   * target is not known until the peer logs on.  Implementing this is what lets an
+   * application's own factory survive into those per-session scopes; without it the
+   * acceptor can only fall back to the stock factory for the protocol.
+   *
+   * ASessionMsgFactory supplies a default that reconstructs via the concrete
+   * constructor, so a subclass taking (description, mutator) needs to do nothing.
+   */
+  cloneFor?: (description: ISessionDescription) => ISessionMsgFactory
 }

package/src/transport/session/session-registry.ts

@@ -0,0 +1,112 @@
+import { SessionId } from '../../store/session-id'
+import { IJsFixLogger } from '../../config/js-fix-logger'
+import { JsFixLoggerFactory } from '../../config/js-fix-logger-factory'
+
+/**
+ * The registry only ever needs to ask a session to stop, so it is typed against
+ * that capability rather than against FixSession.  IJsFixConfig carries a registry,
+ * and FixSession is constructed from IJsFixConfig - depending on the concrete class
+ * here would close an import cycle.
+ */
+export interface IStoppableSession {
+  requestStop: (reason: string) => void
+}
+
+/**
+ * Tracks the live session for each SessionId served by an acceptor.
+ *
+ * FIX allows exactly one active session per (BeginString, SenderCompID,
+ * TargetCompID).  A counterparty whose socket has gone half open - no FIN, no RST,
+ * so node never raises 'end' - will happily open a second connection and log on
+ * again.  Without a registry the acceptor then runs two sessions for one CompID
+ * pair, both writing to the same message store and both stamping sequence numbers,
+ * which corrupts the store and produces sequence errors the peer cannot recover
+ * from.  See https://github.com/TimelordUK/jspurefix/issues/153.
+ *
+ * Ported from cspurefix PureFix.Transport/Session/SessionRegistry.cs.
+ */
+export interface ISessionRegistry {
+  /**
+   * Claim this SessionId for the given session.  Any *different* session already
+   * holding it is stopped first, because its transport is by definition stale.
+   * @returns true when an existing session was stopped
+   */
+  register: (sessionId: SessionId, session: IStoppableSession) => boolean
+  /**
+   * Release this SessionId.  A no-op unless the registered session is this exact
+   * instance - a session which has already been replaced must not evict its
+   * successor on the way out.
+   */
+  unregister: (sessionId: SessionId, session: IStoppableSession) => void
+  /** number of live sessions */
+  readonly count: number
+  /** the SessionId keys currently held, for logging and diagnostics */
+  keys: () => string[]
+  get: (sessionId: SessionId) => IStoppableSession | null
+}
+
+export const REPLACED_BY_NEW_CONNECTION =
+  'replaced by new connection - stopping old session with stale transport'
+
+export class SessionRegistry implements ISessionRegistry {
+  private readonly sessions = new Map<string, IStoppableSession>()
+  private readonly logger: IJsFixLogger | null
+
+  constructor (logFactory?: JsFixLoggerFactory) {
+    this.logger = logFactory?.logger('SessionRegistry') ?? null
+  }
+
+  public get count (): number {
+    return this.sessions.size
+  }
+
+  public keys (): string[] {
+    return Array.from(this.sessions.keys())
+  }
+
+  public get (sessionId: SessionId): IStoppableSession | null {
+    return this.sessions.get(sessionId.toString()) ?? null
+  }
+
+  public register (sessionId: SessionId, session: IStoppableSession): boolean {
+    const key = sessionId.toString()
+    const logger = this.logger
+    logger?.info(`register called for SessionId=${key}, activeSessions=${this.sessions.size}`)
+
+    const existing = this.sessions.get(key)
+    let stoppedOld = false
+
+    if (existing && existing !== session) {
+      logger?.info(`FOUND EXISTING SESSION for ${key} - this is a reconnection scenario`)
+      logger?.info('stopping old session to prevent stale transport writes')
+      this.sessions.set(key, session)
+      // stop after re-pointing the map so the old session's unregister (which runs
+      // synchronously inside requestStop) sees it is no longer the holder
+      existing.requestStop(REPLACED_BY_NEW_CONNECTION)
+      stoppedOld = true
+      logger?.info('old session stopped, new session registered')
+    } else if (existing === session) {
+      logger?.debug(`same session instance already registered for ${key}`)
+    } else {
+      logger?.info(`no existing session found - registering new session: ${key}`)
+      this.sessions.set(key, session)
+    }
+
+    logger?.info(`register complete for ${key}: stoppedOldSession=${stoppedOld}, totalActiveSessions=${this.sessions.size}`)
+    return stoppedOld
+  }
+
+  public unregister (sessionId: SessionId, session: IStoppableSession): void {
+    const key = sessionId.toString()
+    const logger = this.logger
+    logger?.info(`unregister called for SessionId=${key}`)
+
+    if (this.sessions.get(key) === session) {
+      this.sessions.delete(key)
+      logger?.info(`successfully unregistered session: ${key}, remainingActiveSessions=${this.sessions.size}`)
+    } else {
+      // expected when a new connection has already taken this SessionId over
+      logger?.info(`session NOT unregistered (already replaced by new connection or not found): ${key}`)
+    }
+  }
+}

package/src/transport/session/session-sequence-coordinator.ts

@@ -160,7 +160,7 @@ export class SessionSequenceCoordinator {
     this.resendManager.recordRequestSent(begin, end, now)
   }
 
-  get pendingResendRequests (): ReadonlyArray<PendingResendRange> {
+  get pendingResendRequests (): readonly PendingResendRange[] {
     return this.resendManager.pending
   }
 

package/src/transport/session/session-sequence-store.ts

@@ -6,9 +6,9 @@
 export interface ISessionSequenceStore {
   senderSeqNum: number
   targetSeqNum: number
-  setSenderSeqNum (value: number): Promise<void>
-  setTargetSeqNum (value: number): Promise<void>
-  reset (): Promise<void>
+  setSenderSeqNum: (value: number) => Promise<void>
+  setTargetSeqNum: (value: number) => Promise<void>
+  reset: () => Promise<void>
 }
 
 /**

package/src/transport/tcp/tcp-acceptor-listener.ts

@@ -1,4 +1,4 @@
-import { IJsFixConfig } from '../../config'
+import { IJsFixConfig, IJsFixLogger } from '../../config'
 import { FixAcceptor } from '../fix-acceptor'
 import { TcpAcceptor } from './tcp-acceptor'
 import { MsgTransport } from '../factory'
@@ -6,14 +6,23 @@ import { inject, injectable } from 'tsyringe'
 import { FixSession } from '../session/fix-session'
 import { DITokens } from '../../runtime/di-tokens'
 import { FixEntity } from '../fix-entity'
+import { ISessionRegistry, SessionRegistry } from '../session/session-registry'
 
 @injectable()
 export class TcpAcceptorListener extends FixEntity {
   private acceptor: FixAcceptor | null = null
   private resolveStart: ((value: any) => void) | null = null
+  /**
+   * One registry per listener, so a counterparty reconnecting onto a fresh socket
+   * replaces its previous session instead of running alongside it (issue #153).
+   * An application may supply its own via config.sessionRegistry.
+   */
+  public readonly sessionRegistry: ISessionRegistry
 
   constructor (@inject(DITokens.IJsFixConfig) public readonly config: IJsFixConfig) {
     super(config)
+    this.sessionRegistry = config.sessionRegistry ?? new SessionRegistry(config.logFactory)
+    config.sessionRegistry = this.sessionRegistry
   }
 
   async start (): Promise<any> {
@@ -29,24 +38,53 @@ export class TcpAcceptorListener extends FixEntity {
       this.acceptor = acceptor
 
       acceptor.on('transport', (t: MsgTransport) => {
-        logger.info(`creates new transport using DI token ${DITokens.FixSession}.`)
-        const acceptorSession = sessionContainer.resolve<FixSession>(DITokens.FixSession)
+        // resolve from the transport's own scope, not the listener's container, so
+        // this session gets the per-connection description, buffers and message
+        // factory created by TcpAcceptor.  Falls back to the listener container for
+        // transports created outside the acceptor (tests, custom entities).
+        const scope = t.config?.sessionContainer ?? sessionContainer
+        const description = t.config?.description
+        logger.info(`transport ${t.id}: creating session via DI token ${DITokens.FixSession} ` +
+          `[${description?.SenderCompId ?? '?'} -> ${description?.TargetCompID ?? '?'}]`)
+        const acceptorSession = scope.resolve<FixSession>(DITokens.FixSession)
         this.emit('session', acceptorSession, t)
+        // a wildcard acceptor has not claimed its SessionId yet - report again once
+        // the session ends, by which time the registry line is meaningful
+        this.census(logger)
         // Run the session but do NOT close the listener when it ends.
         // The acceptor keeps listening for new connections (reconnects).
         // This matches the C# TcpAcceptorListener accept-loop pattern.
         acceptorSession.run(t).then(() => {
-          logger.info('session ended normally, acceptor continues listening')
+          logger.info(`transport ${t.id}: session ended normally, acceptor continues listening`)
+          this.census(logger)
         }).catch((e: Error) => {
-          logger.warning(`session ended with error: ${e.message}, acceptor continues listening`)
+          logger.warning(`transport ${t.id}: session ended with error: ${e.message}, acceptor continues listening`)
+          this.census(logger)
         })
       })
 
+      acceptor.on('harvested', (tid: number, reason: string) => {
+        logger.info(`transport ${tid} harvested (${reason})`)
+        this.census(logger)
+      })
+
       this.resolveStart = resolve
       acceptor.listen()
     })
   }
 
+  /**
+   * What is actually connected, and which SessionIds are claimed.  Emitted whenever
+   * the population changes so "how many clients do I have, and who are they" is
+   * answerable from the server log alone.
+   */
+  private census (logger: IJsFixLogger): void {
+    const acceptor = this.acceptor as TcpAcceptor | null
+    const transports = acceptor?.liveTransports() ?? []
+    logger.info(`acceptor census: transports=${transports.length} [${transports.join(', ')}] ` +
+      `sessions=${this.sessionRegistry.count} [${this.sessionRegistry.keys().join(', ')}]`)
+  }
+
   /**
    * Explicitly stop the acceptor listener. Call this when the application
    * is shutting down (e.g., timeout, SIGINT). Without this call, the