jspurefix 1.3.0 → 1.4.1

package/src/sample/tcp/trade-capture/trade-capture-client.ts

@@ -52,6 +52,12 @@ export class TradeCaptureClient extends AsciiSession {
     this.fixLog.info(txt)
   }
 
+  private logoutTimer (logoutSeconds: number = 32) {
+    setTimeout(() => {
+      this.done()
+    }, logoutSeconds * 1000)
+  }
+
   protected onReady (view: MsgView): void {
     this.logger.info('ready')
     const tcr: ITradeCaptureReportRequest = TradeFactory.tradeCaptureReportRequest('all-trades', new Date())
@@ -59,12 +65,11 @@ export class TradeCaptureClient extends AsciiSession {
     this.send(MsgType.TradeCaptureReportRequest, tcr)
     const logoutSeconds = 32
     this.logger.info(`will logout after ${logoutSeconds}`)
-    setTimeout(() => {
-      this.done()
-    }, logoutSeconds * 1000)
+    this.logoutTimer()
   }
 
   protected onLogon (view: MsgView, user: string, password: string): boolean {
+    this.logger.info(`onLogon user ${user}`)
     return true
   }
 }

package/src/store/fix-msg-ascii-store-resend.ts

@@ -72,8 +72,9 @@ export class FixMsgAsciiStoreResend {
   }
 
   public sequenceResetGap (startGap: number, newSeq: number): IFixMsgStoreRecord {
-    const gapFill: ISequenceReset = this.config.factory.sequenceReset(newSeq, true) as ISequenceReset
-    gapFill.StandardHeader = this.config.factory.header(MsgType.SequenceReset, startGap) as IStandardHeader
+    const factory = this.config.factory
+    const gapFill: ISequenceReset = factory.sequenceReset(newSeq, true) as ISequenceReset
+    gapFill.StandardHeader = factory.header(MsgType.SequenceReset, startGap) as IStandardHeader
     gapFill.StandardHeader.PossDupFlag = true
     gapFill.NewSeqNo = newSeq
     return new FixMsgStoreRecord(

package/src/store/fix-msg-store-record.ts

@@ -16,6 +16,7 @@ export class FixMsgStoreRecord implements IFixMsgStoreRecord {
                public obj?: ILooseObject,
                public readonly encoded?: string) {
   }
+
   clone (): IFixMsgStoreRecord {
     return new FixMsgStoreRecord(this.msgType, this.timestamp, this.seqNum, this.obj, this.encoded)
   }

package/src/transport/ascii/ascii-msg-transmitter.ts

@@ -21,8 +21,9 @@ export class AsciiMsgTransmitter extends MsgTransmitter {
     this.encoder = new AsciiEncoder(buffer, config.definitions, tf,
       config.delimiter || AsciiChars.Soh,
       config.logDelimiter || AsciiChars.Pipe)
-    this.header = config.definitions.component.get('StandardHeader')
-    this.trailer = config.definitions.component.get('StandardTrailer')
+    const components = config.definitions.component
+    this.header = components.get('StandardHeader')
+    this.trailer = components.get('StandardTrailer')
   }
 
   private checksum (): number {
@@ -46,9 +47,11 @@ export class AsciiMsgTransmitter extends MsgTransmitter {
     if (StandardHeader) {
       const { BeginString, BodyLength, MsgType, SenderCompID, SendingTime, TargetCompID, TargetSubID, ...hp } = StandardHeader
       headerProps = hp // pick up any optional applied by application
+      headerProps.OrigSendingTime = SendingTime // when first sent
     }
 
-    const hdr: ILooseObject = factory.header(msgType, this.msgSeqNum, this.time || new Date(), headerProps)
+    const sendingTime = this.time || new Date()
+    const hdr: ILooseObject = factory.header(msgType, this.msgSeqNum, sendingTime, headerProps)
 
     // Only increment sequence number if this is not a duplicate message.
     if (!headerProps.PossDupFlag) {

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

@@ -4,15 +4,20 @@ import { IJsFixConfig } from '../../config'
 import { IMsgApplication } from '../session-description'
 import { SessionState, TickAction } from '../fix-session-state'
 import { FixSession } from '../fix-session'
+import { FixMsgAsciiStoreResend, FixMsgMemoryStore, IFixMsgStore, IFixMsgStoreRecord } from '../../store'
 
 export abstract class AsciiSession extends FixSession {
 
   public heartbeat: boolean = true
+  protected store: IFixMsgStore = null
+  protected resender: FixMsgAsciiStoreResend
 
   protected constructor (public readonly config: IJsFixConfig) {
     super(config)
     this.requestLogoutType = this.respondLogoutType = MsgType.Logout
     this.requestLogonType = MsgType.Logon
+    this.store = new FixMsgMemoryStore(this.config.description.SenderCompId, this.config)
+    this.resender = new FixMsgAsciiStoreResend(this.store, this.config)
   }
 
   private checkSeqNo (msgType: string, view: MsgView): boolean {
@@ -54,6 +59,17 @@ export abstract class AsciiSession extends FixSession {
     }
   }
 
+  protected checkForwardMsg (msgType: string, view: MsgView): void {
+    const okToForward = this.validStateApplicationMsg()
+    if (okToForward) {
+      this.sessionLogger.info(`ascii forwarding msgType = '${msgType}' to application`)
+      this.setState(SessionState.ActiveNormalSession)
+      this.onApplicationMsg(msgType, view)
+    } else {
+      this.terminate(new Error(`msgType ${msgType} received in state ${this.stateString()}`))
+    }
+  }
+
   private sendReject (msgType: string, seqNo: number, msg: string, reason: number): void {
     const factory = this.config.factory
     const reject = factory.reject(msgType, seqNo, msg, reason)
@@ -138,19 +154,43 @@ export abstract class AsciiSession extends FixSession {
    * @protected
    */
   protected onResendRequest (view: MsgView) {
-    const endSeqNo: number = view.getTyped(MsgTag.EndSeqNo)
-    const resend = this.config.factory.sequenceReset(endSeqNo, true)
-    this.send(MsgType.SequenceReset, resend)
+    // if no records are in store then send a gap fill for entire sequence
+    this.setState(SessionState.HandleResendRequest)
+    const [beginSeqNo, endSeqNo] = view.getTypedTags([MsgTag.BeginSeqNo, MsgTag.EndSeqNo])
+    this.sessionLogger.info(`onResendRequest getResendRequest beginSeqNo = ${beginSeqNo}, endSeqNo = ${endSeqNo}`)
+    this.resender.getResendRequest(beginSeqNo, endSeqNo).then((records: IFixMsgStoreRecord[]) => {
+      const validRecords = records.filter(rec => rec.obj !== null)
+      this.sessionLogger.info(`sending ${validRecords.length}`)
+      validRecords.forEach(rec => {
+        this.send(rec.msgType, rec.obj)
+      })
+      this.setState(SessionState.ActiveNormalSession)
+    }).catch(e => {
+      this.sessionLogger.error(e)
+    })
+  }
+
+  okForLogon (): boolean {
+    const state = this.sessionState.state
+    if (this.acceptor) {
+      return state === SessionState.WaitingForALogon
+    }
+    return state === SessionState.InitiationLogonSent
   }
 
   protected onSessionMsg (msgType: string, view: MsgView): void {
 
-    const factory = this.config.factory
     const logger = this.sessionLogger
 
     switch (msgType) {
       case MsgType.Logon: {
-        this.peerLogon(view)
+        // only valid to receive a logon when in LogonSent or WaitingALogon
+        // else will drop connection immediately.
+        if (this.okForLogon()) {
+          this.peerLogon(view)
+        } else {
+          this.terminate(new Error(`state ${this.stateString()} is illegal for Logon`))
+        }
         break
       }
 
@@ -161,12 +201,13 @@ export abstract class AsciiSession extends FixSession {
 
       case MsgType.TestRequest: {
         const req: string = view.getString(MsgTag.TestReqID)
-        this.send(MsgType.Heartbeat, factory.heartbeat(req))
+        this.sendHeartbeat(req)
         break
       }
 
       case MsgType.Heartbeat: {
         this.sessionState.lastTestRequestAt = null
+        this.setState(SessionState.ActiveNormalSession)
         break
       }
 
@@ -203,9 +244,7 @@ export abstract class AsciiSession extends FixSession {
       switch (msgType) {
         case MsgType.Logon: {
           this.setState(SessionState.PeerLogonRejected)
-          this.timer = setInterval(() => {
-            this.tick()
-          }, 200)
+          this.startTimer()
           break
         }
       }
@@ -231,36 +270,53 @@ export abstract class AsciiSession extends FixSession {
     }
   }
 
+  private startTimer (interval: number = 200) {
+    this.timer = setInterval(() => {
+      this.tick()
+    }, interval)
+  }
+
   private peerLogon (view: MsgView) {
     const logger = this.sessionLogger
-    const heartBtInt = view.getTyped(MsgTag.HeartBtInt)
-    const peerCompId = view.getTyped(MsgTag.SenderCompID)
-    const userName = view.getString(MsgTag.Username)
+    const [heartBtInt, peerCompId, userName, password] = view.getTypedTags([MsgTag.HeartBtInt, MsgTag.SenderCompID, MsgTag.Username, MsgTag.Password])
     logger.info(`peerLogon Username = ${userName}, heartBtInt = ${heartBtInt}, peerCompId = ${peerCompId}, userName = ${userName}`)
     const state = this.sessionState
     state.peerHeartBeatSecs = view.getTyped(MsgTag.HeartBtInt)
     state.peerCompId = view.getTyped(MsgTag.SenderCompID)
+    const res = this.onLogon(view, userName, password)
+    // currently not using this.
+    logger.info(`peerLogon onLogon returns ${res}`)
     if (this.acceptor) {
       this.setState(SessionState.InitiationLogonResponse)
-      this.send(MsgType.Logon, this.config.factory.logon())
+      logger.info('acceptor responds to logon request')
+      this.sendLogon() // if res send response else reject, terminate
     } else { // as an initiator the acceptor has responded
+      logger.info('initiator receives logon response')
       this.setState(SessionState.InitiationLogonReceived)
     }
     if (this.heartbeat) {
       logger.debug(`start heartbeat timer.`)
-      this.timer = setInterval(() => {
-        this.tick()
-      }, 200)
+      this.startTimer()
     }
     logger.info(`system ready, inform app`)
     this.onReady(view)
   }
 
+  private sendTestRequest () {
+    const factory = this.config.factory
+    this.setState(SessionState.AwaitingProcessingResponseToTestRequest)
+    this.send(MsgType.TestRequest, factory.testRequest())
+  }
+
+  private sendHeartbeat (testReqId: string) {
+    const factory = this.config.factory
+    this.send(MsgType.Heartbeat, factory.heartbeat(testReqId))
+  }
+
   private tick (): void {
     const sessionState = this.sessionState
     const action: TickAction = sessionState.calcAction(new Date())
     const application: IMsgApplication = this.transport.config.description.application
-    const factory = this.config.factory
     const logger = this.sessionLogger
 
     switch (action) {
@@ -271,13 +327,13 @@ export abstract class AsciiSession extends FixSession {
 
       case TickAction.TestRequest: {
         logger.debug(`send test req. state = ${sessionState.toString()}`)
-        this.send(MsgType.TestRequest, factory.testRequest())
+        this.sendTestRequest()
         break
       }
 
       case TickAction.Heartbeat: {
         logger.debug(`send heartbeat. state = ${sessionState.toString()}`)
-        this.send(MsgType.Heartbeat, factory.heartbeat(sessionState.now.toUTCString()))
+        this.sendHeartbeat(sessionState.now.toUTCString())
         break
       }
 

package/src/transport/duplex/http-duplex.ts

@@ -1,7 +1,7 @@
 import { FixDuplex } from './fix-duplex'
 import { Readable, Writable } from 'stream'
 import { IHttpAdapter } from '../session-description'
-import * as requestPromise from 'request-promise'
+import * as rp from 'request-promise-native'
 
 export class HttpDuplex extends FixDuplex {
   public constructor (public readonly adapter: IHttpAdapter) {
@@ -28,7 +28,7 @@ export class HttpDuplex extends FixDuplex {
         try {
           const adapter = this.adapter
           const options = adapter.getOptions(data)
-          requestPromise(options).then((message: any) => {
+          rp(options).then((message: any) => {
             const body = adapter.endMessage(message)
             forward.push(body)
             done()

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

@@ -74,6 +74,7 @@ export class FixSessionState {
     this.secondsSinceReceive = -1
     this.peerHeartBeatSecs = 0
     this.logoutSentAt = null
+    this.nextTickAction = TickAction.Nothing
     if (resetSeqNo) {
       this.lastPeerMsgSeqNum = 0
     }
@@ -105,7 +106,7 @@ export class FixSessionState {
     buffer.writeString(`compId = ${this.compId}, `)
     buffer.writeString(`heartBeat = ${this.heartBeat}, `)
     buffer.writeString(`state = ${SessionState[this.state]} (${this.state}), `)
-    buffer.writeString(`nextTickAction = ${this.nextTickAction}, `)
+    buffer.writeString(`nextTickAction = ${TickAction[this.nextTickAction]} (${this.nextTickAction}), `)
     buffer.writeString(`now = ${FixSessionState.dateAsString(this.now)}, `)
     buffer.writeString(`timeToDie = ${this.timeToDie()}, `)
     buffer.writeString(`timeToHeartbeat = ${this.timeToHeartbeat()}, `)
@@ -146,6 +147,8 @@ export class FixSessionState {
         break
       }
 
+      case SessionState.ActiveNormalSession:
+      case SessionState.AwaitingProcessingResponseToTestRequest:
       case SessionState.InitiationLogonReceived:
       case SessionState.InitiationLogonResponse : {
         if (this.timeToHeartbeat()) {

package/src/transport/fix-session.ts

@@ -40,7 +40,8 @@ export abstract class FixSession extends events.EventEmitter {
     if (state === this.sessionState.state) return
     const logger = this.sessionLogger
     const prevState = this.sessionState.state
-    logger.info(`current state ${SessionState[prevState]} (${prevState}) moves to ${SessionState[state]} (${state})`)
+    const msg = `current state ${SessionState[prevState]} (${prevState}) moves to ${SessionState[state]} (${state})`
+    logger.info(msg)
     this.sessionState.state = state
   }
 
@@ -48,21 +49,19 @@ export abstract class FixSession extends events.EventEmitter {
     return this.sessionState.state
   }
 
-  public run (transport: MsgTransport): Promise<number> {
+  public sendLogon () {
+    this.send(this.requestLogonType, this.config.factory.logon())
+  }
+
+  private waitPromise (): Promise<any> {
     const logger = this.sessionLogger
-    if (this.transport) {
-      logger.info('reset from previous transport.')
-      this.reset()
-    }
-    this.transport = transport
-    this.subscribe()
     return new Promise<any>((accept, reject) => {
       if (this.initiator) {
-        logger.debug('initiator sending logon')
-        this.send(this.requestLogonType, this.config.factory.logon())
+        logger.debug(`initiator sending logon state = ${this.stateString()}`)
+        this.sendLogon()
         this.setState(SessionState.InitiationLogonSent)
       } else {
-        logger.debug('acceptor waits for logon')
+        logger.debug(`acceptor waits for logon state = ${this.stateString()}`)
         this.setState(SessionState.WaitingForALogon)
       }
 
@@ -70,12 +69,40 @@ export abstract class FixSession extends events.EventEmitter {
         logger.error(e)
         reject(e)
       })
+
       this.on('done', () => {
         accept(this.transport.id)
       })
     })
   }
 
+  public run (transport: MsgTransport): Promise<number> {
+    const logger = this.sessionLogger
+    if (this.transport) {
+      logger.info(`reset from previous transport. state ${this.stateString()}`)
+      this.reset()
+    }
+    this.transport = transport
+    this.subscribe()
+    return this.waitPromise()
+  }
+
+  protected expectedState (): 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:
+        return false
+    }
+  }
+
   protected subscribe () {
 
     const transport = this.transport
@@ -110,21 +137,14 @@ export abstract class FixSession extends events.EventEmitter {
 
     rx.on('end', () => {
       logger.info(`rx end received sessionState = [${this.sessionState.toString()}]`)
-      switch (this.sessionState.state) {
-        case SessionState.ReceiveLogout:
-        case SessionState.Stopped:
-        case SessionState.ConfirmingLogout: {
-          logger.info(`rx graceful end state = ${SessionState[this.sessionState.state]}`)
-          this.done()
-        }
-          break
-
-        default: {
-          const e = new Error(`unexpected state - transport failed? = ${SessionState[this.sessionState.state]}`)
-          logger.info(`rx error ${e.message}`)
-          this.terminate(e)
-        }
-          break
+      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)
       }
     })
 
@@ -144,23 +164,49 @@ export abstract class FixSession extends events.EventEmitter {
     })
   }
 
+  protected validStateApplicationMsg (): boolean {
+    switch (this.sessionState.state) {
+      case SessionState.Idle:
+      case SessionState.InitiateConnection:
+      case SessionState.InitiationLogonSent:
+      case SessionState.WaitingForALogon:
+      case SessionState.HandleResendRequest:
+      case SessionState.AwaitingProcessingResponseToTestRequest:
+      case SessionState.AwaitingProcessingResponseToResendRequest:
+        return false
+      default:
+        return true
+    }
+  }
+
+  protected stateString (): string {
+    return SessionState[this.sessionState.state]
+  }
+
   protected checkForwardMsg (msgType: string, view: MsgView): void {
     this.sessionLogger.info(`forwarding msgType = '${msgType}' to application`)
+    this.setState(SessionState.ActiveNormalSession)
     this.onApplicationMsg(msgType, view)
   }
 
   protected terminate (error: Error): void {
+    if (this.sessionState.state === SessionState.Stopped) return
     this.sessionLogger.error(error)
-    clearInterval(this.timer)
-    this.transport.end()
+    if (this.timer) {
+      clearInterval(this.timer)
+    }
+    if (this.transport) {
+      this.transport.end()
+    }
     this.transport = null
-    this.sessionState.state = SessionState.Stopped
+    this.setState(SessionState.Stopped)
     this.emit('error', error)
   }
 
   protected peerLogout (view: MsgView) {
     const msg = view.getString(MsgTag.Text)
-    switch (this.sessionState.state) {
+    const state = this.sessionState.state
+    switch (state) {
       case SessionState.WaitingLogoutConfirm: {
         this.sessionLogger.info(`peer confirms logout Text = '${msg}'`)
         this.stop()
@@ -168,6 +214,7 @@ export abstract class FixSession extends events.EventEmitter {
       }
 
       case SessionState.InitiationLogonResponse:
+      case SessionState.ActiveNormalSession:
       case SessionState.InitiationLogonReceived: {
         this.setState(SessionState.ConfirmingLogout)
         this.sessionLogger.info(`peer initiates logout Text = '${msg}'`)
@@ -177,9 +224,10 @@ export abstract class FixSession extends events.EventEmitter {
   }
 
   protected send (msgType: string, obj: ILooseObject) {
-    switch (this.sessionState.state) {
+    const state = this.sessionState.state
+    switch (state) {
       case SessionState.Stopped: {
-        this.sessionLogger.warning(`can't send in stopped state`)
+        this.sessionLogger.warning(`can't send in state ${this.stateString()}`)
         break
       }
 
@@ -191,13 +239,20 @@ export abstract class FixSession extends events.EventEmitter {
     }
   }
 
+  protected sendLogout (msg: string) {
+    const factory = this.config.factory
+    this.sessionLogger.info(`sending logout with ${msg}`)
+    this.send(this.requestLogoutType, factory.logout(this.requestLogoutType, msg))
+  }
+
   protected sessionLogout (): void {
     const sessionState = this.sessionState
     if (sessionState.logoutSentAt) {
       return
     }
-    const factory = this.config.factory
+
     switch (sessionState.state) {
+      case SessionState.ActiveNormalSession:
       case SessionState.InitiationLogonResponse:
       case SessionState.InitiationLogonReceived: {
         // this instance initiates logout
@@ -205,7 +260,7 @@ export abstract class FixSession extends events.EventEmitter {
         sessionState.logoutSentAt = new Date()
         const msg = `${this.me} initiate logout`
         this.sessionLogger.info(msg)
-        this.send(this.requestLogoutType, factory.logout(this.requestLogoutType,msg))
+        this.sendLogout(msg)
         break
       }
 
@@ -214,7 +269,7 @@ export abstract class FixSession extends events.EventEmitter {
         sessionState.logoutSentAt = new Date()
         const msg = `${this.me} confirming logout`
         this.sessionLogger.info(msg)
-        this.send(this.respondLogoutType, factory.logout(this.respondLogoutType,msg))
+        this.sendLogout(msg)
         break
       }
 
@@ -227,6 +282,7 @@ export abstract class FixSession extends events.EventEmitter {
   public done (): void {
     switch (this.sessionState.state) {
       case SessionState.InitiationLogonResponse:
+      case SessionState.ActiveNormalSession:
       case SessionState.InitiationLogonReceived: {
         this.sessionLogout()
         break
@@ -241,10 +297,13 @@ export abstract class FixSession extends events.EventEmitter {
         break
       }
     }
-    this.sessionLogger.info(`done. check logout sequence`)
+    this.sessionLogger.info(`done. check logout sequence state ${this.stateString()}`)
   }
 
   public reset (): void {
+    if (this.timer) {
+      clearInterval(this.timer)
+    }
     this.transport = null
     this.sessionState.reset(true) // from header def ... eventually
     this.setState(SessionState.NetworkConnectionEstablished)
@@ -254,7 +313,9 @@ export abstract class FixSession extends events.EventEmitter {
     if (this.sessionState.state === SessionState.Stopped) {
       return
     }
-    clearInterval(this.timer)
+    if (this.timer) {
+      clearInterval(this.timer)
+    }
     this.sessionLogger.info(`stop: kill transport`)
     this.transport.end()
     if (error) {

package/src/transport/http/http-acceptor.ts

@@ -8,6 +8,7 @@ import { Dictionary } from '../../collections'
 import * as express from 'express'
 import * as bodyParser from 'body-parser'
 import * as http from 'http'
+import { v4 as uuidv4 } from 'uuid'
 
 export class HttpAcceptor extends FixAcceptor {
   private app: express.Express = express()
@@ -49,11 +50,9 @@ export class HttpAcceptor extends FixAcceptor {
   }
 
   private saveTransport (tid: number, transport: MsgTransport): string {
-    const uuidv3 = require('uuid/v3')
     this.transports[tid] = transport
-    const app = this.config.description.application
     const keys: string[] = Object.keys(this.transports)
-    const a = uuidv3(app.http.uri, uuidv3.URL)
+    const a = uuidv4()
     this.keys.addUpdate(a, transport)
     this.logger.info(`new transport id = ${tid} token = ${a} created total transports = ${keys.length}`)
     this.emit('transport', transport)
@@ -134,13 +133,13 @@ export class HttpAcceptor extends FixAcceptor {
     const authorise = `${root}authorise`
     const query = `${root}query`
     this.logger.info(`uri: authorise ${authorise}, query ${query}`)
-    router.post(authorise, (req: express.Request, res: express.Response) => {
+    router.post(authorise, async (req: express.Request, res: express.Response) => {
       if (!req.headers.authorization) {
         this.logger.info('logon')
-        this.logon(req, res)
+        await this.logon(req, res)
       } else {
         this.logger.info('logout')
-        this.logout(req, res)
+        await this.logout(req, res)
       }
     })
 
@@ -157,6 +156,8 @@ export class HttpAcceptor extends FixAcceptor {
         const d = t.duplex
         this.respond(d, res).then(() => {
           this.logger.info(`responded to ${req.url}`)
+        }).catch(e => {
+          res.send(e)
         })
         d.readable.push(body.fixml)
       }