jspurefix 1.1.2 → 1.4.1

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

@@ -4,19 +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
-  }
-
-  public static asPiped (txt: string) {
-    return txt.replace(/\x01/g,'|')
+    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 {
@@ -37,14 +38,18 @@ export abstract class AsciiSession extends FixSession {
           this.sessionLogger.warning(`terminate as seqDelta (${seqDelta}) < 0 lastSeq = ${lastSeq} seqNo = ${seqNo}`)
           this.stop()
         } else if (seqDelta > 1) {
-          // reset required as have missed messages.
-          const resend = this.config.factory.resendRequest(lastSeq + 1, seqNo)
-          this.sessionLogger.warning(`sending resend last received ${lastSeq} seqNo ${seqNo}`)
-          this.send(MsgType.ResendRequest, resend)
-          // Sequence discrepancies should be resolved after logon. However, this does not make the Logon invalid.
-          if (MsgType.Logon) {
-            return true
+          // resend request required as have missed messages.
+
+          // We process a Logon beforehand to confirm the connection even we out of sync
+          if (msgType === MsgType.Logon) {
+            this.peerLogon(view)
+          }
+          // If the out of sync message is a resend request itself, then we handle it first in order
+          // to avoid triggering an endless loop of both sides sending resend requests in response to resend requests.
+          if (msgType === MsgType.ResendRequest) {
+            this.onResendRequest(view)
           }
+          this.sendResendRequest(lastSeq, seqNo)
         } else {
           ret = true
           state.lastPeerMsgSeqNum = seqNo
@@ -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)
@@ -61,6 +77,12 @@ export abstract class AsciiSession extends FixSession {
     this.send(MsgType.Reject, reject)
   }
 
+  protected sendResendRequest (lastSeq: number, receivedSeq: number) {
+    const resend = this.config.factory.resendRequest(lastSeq + 1, 0)
+    this.sessionLogger.warning(`received seq ${receivedSeq}, but last known seq is ${lastSeq}. Sending resend request for all messages > ${lastSeq}`)
+    this.send(MsgType.ResendRequest, resend)
+  }
+
   private checkIntegrity (msgType: string, view: MsgView): boolean {
     const state = this.sessionState
     const seqNum = view.getTyped(MsgTag.MsgSeqNum)
@@ -101,7 +123,8 @@ export abstract class AsciiSession extends FixSession {
     }
 
     switch (state.state) {
-      case SessionState.PeerLoggedOn: {
+      case SessionState.InitiationLogonReceived:
+      case SessionState.InitiationLogonResponse: {
         const targetCompId = view.getString(MsgTag.TargetCompID)
         if (targetCompId !== state.compId) {
           const msg: string = `msgType ${msgType} unexpected TargetCompID ${targetCompId}`
@@ -130,21 +153,44 @@ export abstract class AsciiSession extends FixSession {
    * Override to resend stored messages following a sequence reset.
    * @protected
    */
-  // tslint:disable-next-line:no-empty
   protected onResendRequest (view: MsgView) {
-    const endSeqNo: number = view.getTyped(MsgTag.EndSeqNo)
-    const resend = this.config.factory.sequenceReset(endSeqNo)
-    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)
+    })
   }
 
-  private onSessionMsg (msgType: string, view: MsgView): void {
+  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
       }
 
@@ -155,17 +201,18 @@ 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
       }
 
       case MsgType.ResendRequest: {
-        logger.info(`peer sends '${msgType}' resend reset.`)
+        logger.info(`peer sends '${msgType}' resend request.`)
         this.onResendRequest(view)
         break
       }
@@ -196,10 +243,8 @@ export abstract class AsciiSession extends FixSession {
       this.sessionLogger.info(`message '${msgType}' failed checkIntegrity.`)
       switch (msgType) {
         case MsgType.Logon: {
-          this.sessionState.state = SessionState.PeerLogonRejected
-          this.timer = setInterval(() => {
-            this.tick()
-          }, 200)
+          this.setState(SessionState.PeerLogonRejected)
+          this.startTimer()
           break
         }
       }
@@ -225,34 +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.state = SessionState.PeerLoggedOn
     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.send(MsgType.Logon, this.config.factory.logon())
+      this.setState(SessionState.InitiationLogonResponse)
+      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) {
@@ -263,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/ascii/index.ts

@@ -1,2 +1,3 @@
 export * from './ascii-session'
 export * from './ascii-msg-transmitter'
+export * from './ascii-session-msg-factory'

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-msg-factory.ts

@@ -9,7 +9,7 @@ export interface ISessionMsgFactory {
   logon (userRequestId?: string, isResponse?: boolean): ILooseObject
   testRequest (reqId?: string): ILooseObject
   resendRequest (from: number, to: number): ILooseObject
-  sequenceReset (newSeq: 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/fix-session-state.ts

@@ -2,12 +2,29 @@ import { ElasticBuffer } from '../buffer'
 import moment = require('moment')
 
 export enum SessionState {
-  Connected = 1,
-  PeerLoggedOn = 2,
-  PeerLogonRejected = 3,
-  WaitingLogoutConfirm = 4,
-  ConfirmingLogout = 5,
-  Stopped = 6
+  DisconnectedNoConnectionToday = 1,
+  DisconnectedConnectionToday = 2,
+  DetectBrokenNetworkConnection = 3,
+  AwaitingConnection = 4,
+  InitiateConnection = 5,
+  NetworkConnectionEstablished = 6,
+  InitiationLogonSent = 7,
+  InitiationLogonReceived = 8,
+  InitiationLogonResponse = 9,
+  HandleResendRequest = 10,
+  ReceiveMsgSeqNumTooHigh = 11,
+  AwaitingProcessingResponseToResendRequest = 12,
+  NoMessagesReceivedInInterval = 13,
+  AwaitingProcessingResponseToTestRequest = 14,
+  ReceiveLogout = 15,
+  InitiateLogout = 16,
+  ActiveNormalSession = 17,
+  WaitingForALogon = 18,
+  PeerLogonRejected = 20,
+  WaitingLogoutConfirm = 21,
+  ConfirmingLogout = 22,
+  Stopped = 23,
+  Idle = 24
 }
 
 export enum TickAction {
@@ -19,6 +36,14 @@ export enum TickAction {
   Stop = 6
 }
 
+interface IFixSessionStateArgs {
+  heartBeat: number
+  state?: SessionState
+  waitLogoutConfirmSeconds?: number
+  stopSeconds?: number
+  lastPeerMsgSeqNum?: number
+}
+
 export class FixSessionState {
   public nextTickAction: TickAction = TickAction.Nothing
 
@@ -30,17 +55,41 @@ export class FixSessionState {
   public compId: string = ''
   public peerCompId: string = ''
   public peerHeartBeatSecs: number = 0
+  public lastPeerMsgSeqNum: number
+  public readonly heartBeat: number
+  public state: SessionState
+  public readonly waitLogoutConfirmSeconds: number
+  public readonly stopSeconds: number
 
   private secondsSinceLogoutSent: number = -1
   private secondsSinceSent: number = -1
   private secondsSinceReceive: number = -1
 
-  public constructor (public readonly heartBeat: number,
-                      public lastPeerMsgSeqNum: number = 0,
-                      public state: SessionState = SessionState.Connected,
-                      public readonly waitLogoutConfirmSeconds: number = 5,
-                      public readonly stopSeconds: number = 2) {
+  public reset (resetSeqNo: boolean): void {
+    this.lastReceivedAt = null
+    this.LastSentAt = null
+    this.lastTestRequestAt = null
+    this.secondsSinceLogoutSent = -1
+    this.secondsSinceSent = -1
+    this.secondsSinceReceive = -1
+    this.peerHeartBeatSecs = 0
+    this.logoutSentAt = null
+    this.nextTickAction = TickAction.Nothing
+    if (resetSeqNo) {
+      this.lastPeerMsgSeqNum = 0
+    }
+  }
 
+  public constructor ({ heartBeat,
+                        state = SessionState.Idle,
+                        waitLogoutConfirmSeconds = 5,
+                        stopSeconds = 2,
+                        lastPeerMsgSeqNum = 0 }: IFixSessionStateArgs) {
+    this.heartBeat = heartBeat
+    this.state = state
+    this.waitLogoutConfirmSeconds = waitLogoutConfirmSeconds
+    this.stopSeconds = stopSeconds
+    this.lastPeerMsgSeqNum = lastPeerMsgSeqNum
   }
 
   private static dateAsString (d: Date) {
@@ -56,8 +105,8 @@ export class FixSessionState {
 
     buffer.writeString(`compId = ${this.compId}, `)
     buffer.writeString(`heartBeat = ${this.heartBeat}, `)
-    buffer.writeString(`state = ${this.state}, `)
-    buffer.writeString(`nextTickAction = ${this.nextTickAction}, `)
+    buffer.writeString(`state = ${SessionState[this.state]} (${this.state}), `)
+    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()}, `)
@@ -98,7 +147,10 @@ export class FixSessionState {
         break
       }
 
-      case SessionState.PeerLoggedOn: {
+      case SessionState.ActiveNormalSession:
+      case SessionState.AwaitingProcessingResponseToTestRequest:
+      case SessionState.InitiationLogonReceived:
+      case SessionState.InitiationLogonResponse : {
         if (this.timeToHeartbeat()) {
           // have not sent anything for heartbeat period so let other side know still alive.
           this.nextTickAction = TickAction.Heartbeat
@@ -123,7 +175,7 @@ export class FixSessionState {
 
   public timeToDie (): boolean {
     return this.secondsSinceLogoutSent > this.waitLogoutConfirmSeconds ||
-    this.secondsSinceLogoutSent > this.stopSeconds
+      this.secondsSinceLogoutSent > this.stopSeconds
   }
 
   public timeToHeartbeat (): boolean {