jspurefix 2.2.1 → 3.0.0

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

@@ -11,8 +11,8 @@ import { SegmentType } from '../../buffer/segment/segment-type'
 
 export abstract class FixSession extends events.EventEmitter {
   public logReceivedMsgs: boolean = false
-  protected timer: NodeJS.Timer = null
-  protected transport: MsgTransport = null
+  protected timer: NodeJS.Timer | null = null
+  protected transport: MsgTransport | null = null
   public manageSession: boolean = true
   public checkMsgIntegrity: boolean = false
   protected readonly me: string
@@ -27,37 +27,75 @@ export abstract class FixSession extends events.EventEmitter {
   protected constructor (public readonly config: IJsFixConfig) {
     super()
     const description = config.description
-    this.me = description.application.name
+    this.me = description?.application?.name ?? 'me'
     this.sessionState = new FixSessionState(
-      { heartBeat: config.description.HeartBtInt,
-        lastPeerMsgSeqNum: config.description.LastReceivedSeqNum})
+      {
+        heartBeat: config.description.HeartBtInt,
+        lastPeerMsgSeqNum: config.description.LastReceivedSeqNum
+      })
     this.sessionLogger = config.logFactory.logger(`${this.me}:FixSession`)
-    this.initiator = description.application.type === 'initiator'
+    this.initiator = description?.application?.type === 'initiator'
     this.acceptor = !this.initiator
     this.checkMsgIntegrity = this.acceptor
     this.sessionState.compId = description.SenderCompId
   }
 
-  public setState (state: SessionState) {
-    if (state === this.sessionState.state) return
+  stateStr (theState: SessionState): string {
+    return SessionState[theState]
+  }
+
+  assignState (newState: SessionState): void {
+    const currentState = this.sessionState.state
+    const currentStateStr = this.stateStr(currentState)
     const logger = this.sessionLogger
-    const prevState = this.sessionState.state
-    const msg = `current state ${SessionState[prevState]} (${prevState}) moves to ${SessionState[state]} (${state})`
+    const msg = `current state ${currentStateStr} (${currentState}) moves to ${SessionState[newState]} (${newState})`
     logger.info(msg)
-    this.sessionState.state = state
+    this.sessionState.state = newState
+  }
+
+  public setState (state: SessionState): void {
+    const logger = this.sessionLogger
+    const currentState = this.sessionState.state
+    const currentStateStr = this.stateStr(currentState)
+    if (state === currentState) return
+    switch (currentState) {
+      case SessionState.ConfirmingLogout:
+      case SessionState.Stopped:
+        if (state !== SessionState.NetworkConnectionEstablished) {
+          logger.info(`ignoring request to change state as now already in ${currentStateStr}`)
+        } else {
+          this.assignState(state)
+        }
+        break
+
+      default: {
+        this.assignState(state)
+      }
+    }
   }
 
   public getState (): SessionState {
     return this.sessionState.state
   }
 
-  public sendLogon () {
-    this.send(this.requestLogonType, this.config.factory.logon())
+  public lastSentSeqNum (): number {
+    return this.sessionState.lastSentSeqNum()
+  }
+
+  public lastPeerSeqNum (): number {
+    return this.sessionState.lastPeerMsgSeqNum
   }
 
-  private waitPromise (): Promise<any> {
+  public sendLogon (): void {
+    const lo = this.config.factory?.logon()
+    if (lo) {
+      this.send(this.requestLogonType, lo)
+    }
+  }
+
+  private async waitPromise (): Promise<number> {
     const logger = this.sessionLogger
-    return new Promise<any>((accept, reject) => {
+    return await new Promise<any>((resolve, reject) => {
       if (this.initiator) {
         logger.debug(`initiator sending logon state = ${this.stateString()}`)
         this.sendLogon()
@@ -73,12 +111,12 @@ export abstract class FixSession extends events.EventEmitter {
       })
 
       this.on('done', () => {
-        accept(this.transport.id)
+        resolve(this.transport?.id)
       })
     })
   }
 
-  public run (transport: MsgTransport): Promise<number> {
+  public async run (transport: MsgTransport): Promise<number> {
     const logger = this.sessionLogger
     if (this.transport) {
       logger.info(`reset from previous transport. state ${this.stateString()}`)
@@ -86,18 +124,13 @@ export abstract class FixSession extends events.EventEmitter {
     }
     this.transport = transport
     this.subscribe()
-    return this.waitPromise()
+    return await this.waitPromise()
   }
 
-  protected expectedState (): boolean {
+  protected expectedEndState (): boolean {
     switch (this.sessionState.state) {
-      case SessionState.ActiveNormalSession:
-      case SessionState.ReceiveLogout:
       case SessionState.Stopped:
       case SessionState.ConfirmingLogout:
-      case SessionState.HandleResendRequest:
-      case SessionState.AwaitingProcessingResponseToTestRequest:
-      case SessionState.AwaitingProcessingResponseToResendRequest:
         return true
 
       default:
@@ -105,65 +138,97 @@ export abstract class FixSession extends events.EventEmitter {
     }
   }
 
-  protected subscribe () {
+  protected rxOnEnd (): void {
+    const logger = this.sessionLogger
+    logger.info(`rx end received sessionState = [${this.sessionState.toString()}]`)
+    const expectedState = this.expectedEndState()
+    if (expectedState) {
+      logger.info(`rx receives end state = ${this.stateString()} - stop session`)
+      this.stop()
+    } else {
+      this.setState(SessionState.DetectBrokenNetworkConnection)
+      const e = new Error(`unexpected state - transport failed? = ${this.stateString()}`)
+      logger.info(`rx error ${e.message}`)
+      this.terminate(e)
+    }
+  }
 
-    const transport = this.transport
+  protected rxOnMsg (msgType: string, view: MsgView): void {
     const logger = this.sessionLogger
 
-    const rx = transport.receiver
-    const tx = transport.transmitter
+    if (this.logReceivedMsgs) {
+      const name = view.segment.type !== SegmentType.Unknown ? view?.segment?.set?.name : 'unknown'
+      logger.info(`${msgType}: ${name}`)
+      logger.info(`${view.toString()}`)
+    }
+    this.sessionState.lastReceivedAt = new Date()
+    if (this.manageSession) {
+      this.onMsg(msgType, view)
+    } else {
+      this.checkForwardMsg(msgType, view)
+    }
+  }
 
-    rx.on('msg', (msgType: string, view: MsgView) => {
-      if (this.logReceivedMsgs) {
-        const name = view.segment.type !== SegmentType.Unknown ? view.segment.set.name : 'unknown'
-        logger.info(`${msgType}: ${name}`)
-        logger.info(`${view.toString()}`)
-      }
-      this.sessionState.lastReceivedAt = new Date()
-      if (this.manageSession) {
-        this.onMsg(msgType, view)
-      } else {
-        this.checkForwardMsg(msgType, view)
-      }
-    })
+  protected rxOnDone (): void {
+    const logger = this.sessionLogger
+    logger.info('rx done received')
+    this.done()
+  }
 
-    rx.on('error', (e: Error) => {
-      logger.warning(`rx error event: ${e.message} ${e.stack || ''}`)
-      this.terminate(e)
-    })
+  protected rxOnError (e: Error): void {
+    const logger = this.sessionLogger
+    logger.warning(`rx error event: ${e.message} ${e.stack ?? ''}`)
+    this.terminate(e)
+  }
 
-    rx.on('done', () => {
-      logger.info('rx done received')
-      this.done()
-    })
+  protected rxOnDecoded (msgType: string, data: ElasticBuffer, ptr: number): void {
+    const logger = this.sessionLogger
+    logger.debug(`rx: [${msgType}] ${ptr} bytes`)
+    this.onDecoded(msgType, data.toString(ptr))
+  }
 
-    rx.on('end', () => {
-      logger.info(`rx end received sessionState = [${this.sessionState.toString()}]`)
-      const expectedState = this.expectedState()
-      if (expectedState) {
-        logger.info(`rx graceful end state = ${this.stateString()}`)
-        this.done()
-      } else {
-        const e = new Error(`unexpected state - transport failed? = ${this.stateString()}`)
-        logger.info(`rx error ${e.message}`)
-        this.terminate(e)
-      }
-    })
+  protected txOnError (e: Error): void {
+    const logger = this.sessionLogger
+    logger.warning(`tx error event: ${e.message} ${e.stack ?? ''}`)
+    this.terminate(e)
+  }
 
-    rx.on('decoded', (msgType: string, data: ElasticBuffer, ptr: number) => {
-      logger.debug(`rx: [${msgType}] ${ptr} bytes`)
-      this.onDecoded(msgType, data.toString(ptr))
-    })
+  protected txOnEncoded (msgType: string, data: string, hdr: ILooseObject): void {
+    const logger = this.sessionLogger
+    this.sessionState.lastHeader = hdr
+    logger.debug(`tx: [${msgType}] ${data.length} bytes seqNo = ${this.lastSentSeqNum()}`)
+    this.onEncoded(msgType, data)
+  }
 
-    tx.on('error', (e: Error) => {
-      logger.warning(`tx error event: ${e.message} ${e.stack || ''}`)
-      this.terminate(e)
-    })
+  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)
+  }
 
-    tx.on('encoded', (msgType: string, data: string) => {
-      logger.debug(`tx: [${msgType}] ${data.length} bytes`)
-      this.onEncoded(msgType, data)
-    })
+  protected subscribe (): void {
+    const transport = this.transport
+
+    const rx = transport?.receiver
+    const tx = transport?.transmitter
+    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))
   }
 
   protected validStateApplicationMsg (): boolean {
@@ -191,12 +256,18 @@ export abstract class FixSession extends events.EventEmitter {
     this.onApplicationMsg(msgType, view)
   }
 
-  protected terminate (error: Error): void {
-    if (this.sessionState.state === SessionState.Stopped) return
-    this.sessionLogger.error(error)
+  private stopTimer (): void {
     if (this.timer) {
+      this.sessionLogger.info('stopTimer')
       clearInterval(this.timer)
+      this.timer = null
     }
+  }
+
+  protected terminate (error: Error): void {
+    if (this.sessionState.state === SessionState.Stopped) return
+    this.sessionLogger.error(error)
+    this.stopTimer()
     if (this.transport) {
       this.transport.end()
     }
@@ -205,7 +276,7 @@ export abstract class FixSession extends events.EventEmitter {
     this.emit('error', error)
   }
 
-  protected peerLogout (view: MsgView) {
+  protected peerLogout (view: MsgView): void {
     const msg = view.getString(MsgTag.Text)
     const state = this.sessionState.state
     switch (state) {
@@ -225,7 +296,7 @@ export abstract class FixSession extends events.EventEmitter {
     }
   }
 
-  protected send (msgType: string, obj: ILooseObject) {
+  protected send (msgType: string, obj: ILooseObject): void {
     const state = this.sessionState.state
     switch (state) {
       case SessionState.Stopped: {
@@ -235,16 +306,19 @@ export abstract class FixSession extends events.EventEmitter {
 
       default: {
         this.sessionState.LastSentAt = new Date()
-        this.transport.transmitter.send(msgType, obj)
+        this.transport?.transmitter.send(msgType, obj)
         break
       }
     }
   }
 
-  protected sendLogout (msg: string) {
+  protected sendLogout (msg: string): void {
     const factory = this.config.factory
     this.sessionLogger.info(`sending logout with ${msg}`)
-    this.send(this.requestLogoutType, factory.logout(this.requestLogoutType, msg))
+    const lo = factory?.logout(this.requestLogoutType, msg)
+    if (lo) {
+      this.send(this.requestLogoutType, lo)
+    }
   }
 
   protected sessionLogout (): void {
@@ -267,7 +341,8 @@ export abstract class FixSession extends events.EventEmitter {
       }
 
       case SessionState.ConfirmingLogout: {
-        // this instance responds to logout
+        // this instance responds to log out
+        this.setState(SessionState.ConfirmingLogout)
         sessionState.logoutSentAt = new Date()
         const msg = `${this.me} confirming logout`
         this.sessionLogger.info(msg)
@@ -291,7 +366,7 @@ export abstract class FixSession extends events.EventEmitter {
       }
 
       case SessionState.Stopped:
-        this.sessionLogger.info(`done. session is now stopped`)
+        this.sessionLogger.info('done. session is now stopped')
         break
 
       default: {
@@ -302,25 +377,23 @@ export abstract class FixSession extends events.EventEmitter {
     this.sessionLogger.info(`done. check logout sequence state ${this.stateString()}`)
   }
 
-  public reset (): void {
-    if (this.timer) {
-      clearInterval(this.timer)
-    }
+  public reset (resetSeqNum?: number | null): void {
+    this.stopTimer()
     this.transport = null
-    const resetSeqNum = this.config.description.ResetSeqNumFlag || true
-    this.sessionState.reset(resetSeqNum) // from header def ... eventually
+    const resetFlag = this.config.description.ResetSeqNumFlag
+    const seqNum = resetFlag ? 0 : resetSeqNum ?? this.sessionState.lastPeerMsgSeqNum
+    this.sessionState.reset(seqNum) // from header def ... eventually
     this.setState(SessionState.NetworkConnectionEstablished)
   }
 
-  protected stop (error: Error = null): void {
+  protected stop (error: Error | null = null): void {
     if (this.sessionState.state === SessionState.Stopped) {
       return
     }
-    if (this.timer) {
-      clearInterval(this.timer)
-    }
-    this.sessionLogger.info(`stop: kill transport`)
-    this.transport.end()
+    this.stopTimer()
+    this.unsubscribe()
+    this.sessionLogger.info('stop: kill transport')
+    this.transport?.end()
     if (error) {
       this.sessionLogger.info(`stop: emit error ${error.message}`)
       this.emit('error', error)
@@ -329,7 +402,7 @@ export abstract class FixSession extends events.EventEmitter {
     }
 
     this.setState(SessionState.Stopped)
-    this.onStopped(error)
+    this.onStopped(error ?? undefined)
     this.transport = null
   }
 

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

@@ -1,5 +1,4 @@
 import { IJsFixConfig } from '../../config'
 import { FixSession } from './fix-session'
 
-export interface MakeFixSession { (config: IJsFixConfig): FixSession
-}
+export type MakeFixSession = (config: IJsFixConfig) => FixSession

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

@@ -9,10 +9,10 @@ export interface ISessionDescription {
   readonly SenderCompId: string
   readonly TargetCompID: string
   readonly ResetSeqNumFlag: boolean
-  readonly LastSentSeqNum?: number
+  LastSentSeqNum?: number
   readonly LastReceivedSeqNum?: number
   readonly SenderSubID: string
   readonly TargetSubID: string
   readonly BeginString: string
-  readonly BodyLengthChars?: number,
+  readonly BodyLengthChars?: number
 }

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

@@ -4,13 +4,13 @@ import { ISessionDescription } from './session-description'
 
 export interface ISessionMsgFactory {
   description: ISessionDescription
-  reject (msgType: string, seqNo: number, msg: string, reason: number): ILooseObject
-  logout (msgType: string, text: string): ILooseObject
-  logon (userRequestId?: string, isResponse?: boolean): ILooseObject
-  testRequest (reqId?: string): ILooseObject
-  resendRequest (from: number, to: number): ILooseObject
-  sequenceReset (newSeq: number, gapFill?: boolean): ILooseObject
-  heartbeat (testReqId: string): ILooseObject
-  header (msgType?: string, seqNum?: number, time?: Date, overrideData?: Partial<IStandardHeader>): ILooseObject
-  trailer (checksum: number): ILooseObject
+  reject: (msgType: string, seqNo: number, msg: string, reason: number) => ILooseObject
+  logout: (msgType: string, text: string) => ILooseObject
+  logon: (userRequestId?: string, isResponse?: boolean) => ILooseObject
+  testRequest: (reqId?: string) => ILooseObject
+  resendRequest: (from: number, to: number) => ILooseObject
+  sequenceReset: (newSeq: number, gapFill?: boolean) => ILooseObject
+  heartbeat: (testReqId: string) => ILooseObject
+  header: (msgType?: string, seqNum?: number, time?: Date, overrideData?: Partial<IStandardHeader>) => ILooseObject
+  trailer: (checksum: number) => ILooseObject
 }

package/src/transport/tcp/recovering-tcp-initiator.ts

@@ -11,38 +11,39 @@ import { IMsgApplication } from '../msg-application'
 import { FixEntity } from '../fix-entity'
 
 /*
-   create one application session instance - and recover a lost transport.  Hence the application
+   create one application session instance - and recover a lost transport.  Hence, the application
    will automatically re-connected and the "message recovery" policy enacted i.e. replay from
    last known sequence number or sequence reset.
  */
 
 @injectable()
 export class RecoveringTcpInitiator extends FixEntity {
-  public tcp: ITcpTransportDescription
+  public tcp: ITcpTransportDescription | null
   public session: FixSession
   private readonly logger: IJsFixLogger
-  private application: IMsgApplication
+  private readonly application: IMsgApplication | null
   private initiator: TcpInitiator
   private transport: MsgTransport
-  private th: Timeout = null
+  private th: Timeout | null = null
   public recoveryAttemptSecs: number = 5
   public backoffFailConnectSecs: number = 30
 
   constructor (@inject(DITokens.IJsFixConfig) public readonly jsFixConfig: IJsFixConfig) {
     super(jsFixConfig)
-    this.application = this.jsFixConfig.description.application
-    this.logger = jsFixConfig.logFactory.logger(`${this.application.name}:RecoveringTcpInitiator`)
+    this.application = this.jsFixConfig.description.application ?? null
+    const name = this.application?.name ?? 'na'
+    this.logger = jsFixConfig.logFactory.logger(`${name}:RecoveringTcpInitiator`)
     if (!this.application) {
-      throw new Error(`no application in session description.`)
+      throw new Error('no application in session description.')
     }
-    this.tcp = this.application.tcp
+    this.tcp = this.application.tcp ?? null
     if (!this.tcp) {
-      throw new Error(`no tcp in session description need tcp { host: hostname, port: port }`)
+      throw new Error('no tcp in session description need tcp { host: hostname, port: port }')
     }
     this.createSession(jsFixConfig)
   }
 
-  private createSession (jsFixConfig: IJsFixConfig) {
+  private createSession (jsFixConfig: IJsFixConfig): void {
     this.logger.info(`creating an application session with DI token ${DITokens.FixSession}.`)
     this.session = jsFixConfig.sessionContainer.resolve<FixSession>(DITokens.FixSession)
     this.session.on('done', () => {
@@ -60,12 +61,20 @@ export class RecoveringTcpInitiator extends FixEntity {
     return this.session.getState()
   }
 
-  private newTransport (transport: MsgTransport) {
+  public lastSentSeqNum (): number {
+    return this.session.lastSentSeqNum()
+  }
+
+  private resetSeq (): boolean {
+    return this.jsFixConfig.description.ResetSeqNumFlag
+  }
+
+  private newTransport (transport: MsgTransport): void {
     this.transport = transport
     this.emit('transport', transport)
     this.logger.info(`initiator connects id ${(transport.id)}`)
     const session = this.session
-    if (this.jsFixConfig.description.ResetSeqNumFlag) {
+    if (this.resetSeq()) {
       this.logger.info('reset sequence numbers')
       session.reset()
     }
@@ -84,7 +93,7 @@ export class RecoveringTcpInitiator extends FixEntity {
     this.logger.info(`running session with transport ${transport.id} state = ${session.getState()}`)
   }
 
-  private clearTimer () {
+  private clearTimer (): void {
     if (this.th) {
       clearTimeout(this.th)
       this.th = null
@@ -98,6 +107,13 @@ export class RecoveringTcpInitiator extends FixEntity {
   private recover (): void {
     this.session.setState(SessionState.DetectBrokenNetworkConnection)
     this.logger.info(`recover session transport - attempt in ${this.recoveryAttemptSecs} secs`)
+    if (!this.resetSeq()) {
+      const lastSentSeqNum = this.lastSentSeqNum()
+      if (lastSentSeqNum > 0) {
+        this.logger.info(`recover session set LastSentSeqNum ${lastSentSeqNum} for new transport`)
+        this.config.description.LastSentSeqNum = lastSentSeqNum
+      }
+    }
     this.th = setTimeout(() => {
       this.connect(60).then(t => {
         this.logger.info(`new transport ${t.id}`)
@@ -105,22 +121,24 @@ export class RecoveringTcpInitiator extends FixEntity {
         this.logger.info(`failed to re-connect ${e.message} - backoff for ${this.backoffFailConnectSecs}`)
         this.th = setTimeout(() => {
           this.logger.info('returning to recover()')
-          this.recover()
+          setImmediate(() => {
+            this.recover()
+          })
         }, this.backoffFailConnectSecs * 1000)
       })
-    },this.recoveryAttemptSecs * 1000)
+    }, this.recoveryAttemptSecs * 1000)
   }
 
-  public start (): Promise<any> {
-    return this.run()
+  public async start (): Promise<any> {
+    return await this.run()
   }
 
   // for first connection - reject if no initial connection established within timeout
   // once connection established, will not resolve until session is ended - i.e. lost
   // connections are re-established using the same session instance.
 
-  public run (initialTimeout: number = 60): Promise<any> {
-    return new Promise<any>((resolve, reject) => {
+  public async run (initialTimeout: number = 60): Promise<any> {
+    return await new Promise<any>((resolve, reject) => {
       this.connect(initialTimeout).then(() => {
         this.on('end', () => {
           this.clearTimer()
@@ -137,8 +155,8 @@ export class RecoveringTcpInitiator extends FixEntity {
 
   // return a promise for new transport - or reject if no connection within timeout
 
-  private connect (timeout: number): Promise<MsgTransport> {
-    return new Promise<MsgTransport>((resolve, reject) => {
+  private async connect (timeout: number): Promise<MsgTransport> {
+    return await new Promise<MsgTransport>((resolve, reject) => {
       this.logger.info(`connect: start initiator timeout ${timeout}`)
       this.session.setState(SessionState.InitiateConnection)
       this.initiator = new TcpInitiator(this.jsFixConfig)

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

@@ -13,8 +13,8 @@ export class TcpAcceptorListener extends FixEntity {
     super(config)
   }
 
-  start (): Promise<any> {
-    return new Promise<any>(async (accept, reject) => {
+  async start (): Promise<any> {
+    return await new Promise<any>(async (resolve, reject) => {
       const logger = this.config.logFactory.logger('acceptor')
       const sessionContainer = this.config.sessionContainer
       if (!sessionContainer.isRegistered(DITokens.FixSession)) {
@@ -25,11 +25,12 @@ export class TcpAcceptorListener extends FixEntity {
       acceptor.on('transport', (t: MsgTransport) => {
         logger.info(`creates new transport using DI token ${DITokens.FixSession}.`)
         const acceptorSession = sessionContainer.resolve<FixSession>(DITokens.FixSession)
+        this.emit('session', acceptorSession, t)
         acceptorSession.run(t).then(() => {
           logger.info('ends')
           acceptor.close(() => {
             logger.info('acceptor closed.')
-            accept(true)
+            resolve(true)
           })
         }).catch((e: Error) => {
           logger.info(`error in session - close listener ${e.message}`)