jspurefix 1.2.0 → 2.0.0

package/src/transport/{fix-session.ts → session/fix-session.ts}

@@ -1,11 +1,13 @@
-import { ElasticBuffer, MsgView, SegmentType } from '../buffer'
-import { IJsFixConfig, IJsFixLogger } from '../config'
-import { FixSessionState, SessionState } from './fix-session-state'
-import { MsgTransport } from './msg-transport'
-import { MsgTag } from '../types'
-import { ILooseObject } from '../collections/collection'
+import { ElasticBuffer, MsgView } from '../../buffer'
+import { IJsFixConfig, IJsFixLogger } from '../../config'
+import { FixSessionState } from './fix-session-state'
+import { MsgTransport } from '../factory'
+import { MsgTag } from '../../types'
+import { ILooseObject } from '../../collections/collection'
 
 import * as events from 'events'
+import { SessionState } from './session-state'
+import { SegmentType } from '../../buffer/segment/segment-type'
 
 export abstract class FixSession extends events.EventEmitter {
   public logReceivedMsgs: boolean = false
@@ -17,7 +19,6 @@ export abstract class FixSession extends events.EventEmitter {
   protected readonly initiator: boolean
   protected readonly acceptor: boolean
   protected readonly sessionState: FixSessionState
-  // protected readonly emitter: events.EventEmitter
   protected readonly sessionLogger: IJsFixLogger
   protected requestLogoutType: string
   protected respondLogoutType: string
@@ -27,7 +28,9 @@ export abstract class FixSession extends events.EventEmitter {
     super()
     const description = config.description
     this.me = description.application.name
-    this.sessionState = new FixSessionState(description.HeartBtInt, config.description.LastReceivedSeqNum)
+    this.sessionState = new FixSessionState(
+      { heartBeat: config.description.HeartBtInt,
+        lastPeerMsgSeqNum: config.description.LastReceivedSeqNum})
     this.sessionLogger = config.logFactory.logger(`${this.me}:FixSession`)
     this.initiator = description.application.type === 'initiator'
     this.acceptor = !this.initiator
@@ -39,7 +42,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
   }
 
@@ -47,21 +51,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)
       }
 
@@ -69,12 +71,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
@@ -109,21 +139,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)
       }
     })
 
@@ -143,23 +166,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()
@@ -167,6 +216,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}'`)
@@ -176,9 +226,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
       }
 
@@ -190,13 +241,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
@@ -204,7 +262,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
       }
 
@@ -213,7 +271,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
       }
 
@@ -226,6 +284,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
@@ -240,12 +299,16 @@ 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
+    const resetSeqNum = this.config.description.ResetSeqNumFlag || true
+    this.sessionState.reset(resetSeqNum) // from header def ... eventually
     this.setState(SessionState.NetworkConnectionEstablished)
   }
 
@@ -253,7 +316,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/{make-fixl-session.ts → session/make-fix-session.ts}

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

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

@@ -0,0 +1,18 @@
+import { IMsgApplication } from '../msg-application'
+
+export interface ISessionDescription {
+  readonly application?: IMsgApplication
+  readonly Name: string
+  readonly Username: string
+  readonly Password: string
+  HeartBtInt: number
+  readonly SenderCompId: string
+  readonly TargetCompID: string
+  readonly ResetSeqNumFlag: boolean
+  readonly LastSentSeqNum?: number
+  readonly LastReceivedSeqNum?: number
+  readonly SenderSubID: string
+  readonly TargetSubID: string
+  readonly BeginString: string
+  readonly BodyLengthChars?: number,
+}

package/src/transport/{fix-msg-factory.ts → session/session-msg-factory.ts}

@@ -1,5 +1,5 @@
-import { ILooseObject } from '../collections/collection'
-import { IStandardHeader } from '../types/FIX4.4/repo'
+import { ILooseObject } from '../../collections/collection'
+import { IStandardHeader } from '../../types/FIX4.4/repo'
 import { ISessionDescription } from './session-description'
 
 export interface ISessionMsgFactory {

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

@@ -0,0 +1,25 @@
+export enum SessionState {
+  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
+}

package/src/transport/tcp/index.ts

@@ -1,5 +1,6 @@
 export * from './recovering-tcp-initiator'
 export * from './tcp-initiator'
 export * from './tcp-acceptor'
-export * from './initiator'
-export * from './acceptor'
+export * from './tcp-initiator-connector'
+export * from './tcp-acceptor-listener'
+export * from '../session/session-state'

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

@@ -1,12 +1,14 @@
-import { IMsgApplication, ITcpTransportDescription } from '../session-description'
 import { IJsFixConfig, IJsFixLogger } from '../../config'
-import { MakeFixSession } from '../make-fixl-session'
-import { FixSession } from '../fix-session'
-import { SessionState } from '../fix-session-state'
+import { FixSession } from '../session/fix-session'
 import { TcpInitiator } from './tcp-initiator'
-import { MsgTransport } from '../msg-transport'
-import * as events from 'events'
+import { MsgTransport } from '../factory'
 import Timeout = NodeJS.Timeout
+import { SessionState } from '../session/session-state'
+import { inject, injectable } from 'tsyringe'
+import { DITokens } from '../../runtime/di-tokens'
+import { ITcpTransportDescription } from './tcp-transport-description'
+import { IMsgApplication } from '../msg-application'
+import { FixEntity } from '../fix-entity'
 
 /*
    create one application session instance - and recover a lost transport.  Hence the application
@@ -14,7 +16,8 @@ import Timeout = NodeJS.Timeout
    last known sequence number or sequence reset.
  */
 
-export class RecoveringTcpInitiator extends events.EventEmitter {
+@injectable()
+export class RecoveringTcpInitiator extends FixEntity {
   public tcp: ITcpTransportDescription
   public session: FixSession
   private readonly logger: IJsFixLogger
@@ -25,8 +28,8 @@ export class RecoveringTcpInitiator extends events.EventEmitter {
   public recoveryAttemptSecs: number = 5
   public backoffFailConnectSecs: number = 30
 
-  constructor (public readonly jsFixConfig: IJsFixConfig, public readonly sessionFactory: MakeFixSession) {
-    super()
+  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`)
     if (!this.application) {
@@ -40,12 +43,12 @@ export class RecoveringTcpInitiator extends events.EventEmitter {
       this.logger.error(e)
       throw e
     }
-    this.createSession(jsFixConfig, sessionFactory)
+    this.createSession(jsFixConfig)
   }
 
-  private createSession (jsFixConfig: IJsFixConfig, sessionFactory: MakeFixSession) {
-    this.logger.info('creating an application session')
-    this.session = sessionFactory(jsFixConfig)
+  private createSession (jsFixConfig: IJsFixConfig) {
+    this.logger.info(`creating an application session with DI token ${DITokens.FixSession}.`)
+    this.session = jsFixConfig.sessionContainer.resolve<FixSession>(DITokens.FixSession)
     this.session.on('done', () => {
       this.logger.info('session has permanently ended')
       this.emit('end', this)
@@ -66,6 +69,10 @@ export class RecoveringTcpInitiator extends events.EventEmitter {
     this.emit('transport', transport)
     this.logger.info(`initiator connects id ${(transport.id)}`)
     const session = this.session
+    if (this.jsFixConfig.description.ResetSeqNumFlag) {
+      this.logger.info('reset sequence numbers')
+      session.reset()
+    }
     session.setState(SessionState.NetworkConnectionEstablished)
     session.run(transport).then((id: number) => {
       if (!transport || id === transport.id) {
@@ -108,6 +115,10 @@ export class RecoveringTcpInitiator extends events.EventEmitter {
     },this.recoveryAttemptSecs * 1000)
   }
 
+  public start (): Promise<any> {
+    return 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.

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

@@ -0,0 +1,45 @@
+import { IJsFixConfig } from '../../config'
+import { FixAcceptor } from '../fix-acceptor'
+import { TcpAcceptor } from './tcp-acceptor'
+import { MsgTransport } from '../factory'
+import { inject, injectable } from 'tsyringe'
+import { FixSession } from '../session/fix-session'
+import { DITokens } from '../../runtime/di-tokens'
+import { FixEntity } from '../fix-entity'
+
+@injectable()
+export class TcpAcceptorListener extends FixEntity {
+  constructor (@inject(DITokens.IJsFixConfig) public readonly config: IJsFixConfig) {
+    super(config)
+  }
+
+  start (): Promise<any> {
+    return new Promise<any>(async (accept, reject) => {
+      const logger = this.config.logFactory.logger('acceptor')
+      const sessionContainer = this.config.sessionContainer
+      if (!sessionContainer.isRegistered(DITokens.FixSession)) {
+        reject(new Error(`application must register a DI token '${DITokens.FixSession}' - see src/sample`))
+      }
+      logger.info('starting.')
+      const acceptor: FixAcceptor = sessionContainer.resolve<FixAcceptor>(TcpAcceptor)
+      acceptor.on('transport', (t: MsgTransport) => {
+        logger.info(`creates new transport using DI token ${DITokens.FixSession}.`)
+        const acceptorSession = sessionContainer.resolve<FixSession>(DITokens.FixSession)
+        acceptorSession.run(t).then(() => {
+          logger.info('ends')
+          acceptor.close(() => {
+            logger.info('acceptor closed.')
+            accept(true)
+          })
+        }).catch((e: Error) => {
+          logger.info(`error in session - close listener ${e.message}`)
+          acceptor.close(() => {
+            logger.info('acceptor closed.')
+            reject(e)
+          })
+        })
+      })
+      acceptor.listen()
+    })
+  }
+}

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

@@ -1,60 +1,85 @@
 import { TcpDuplex } from '../duplex'
-import { MsgTransport } from '../msg-transport'
+import { MsgTransport } from '../factory'
 import { FixAcceptor } from '../fix-acceptor'
 import { IJsFixConfig, IJsFixLogger } from '../../config'
-import { getTlsOptions } from './tls-options'
-import { createServer as netCreateServer, Socket, Server } from 'net'
-import { createServer as tlsCreateServer, TLSSocket, TlsOptions } from 'tls'
+import { createServer as netCreateServer, Server, Socket } from 'net'
+import { createServer as tlsCreateServer, TlsOptions, TLSSocket } from 'tls'
+import { TlsOptionsFactory } from './tls-options-factory'
+import { inject, injectable } from 'tsyringe'
+import { DITokens } from '../../runtime/di-tokens'
 
+@injectable()
 export class TcpAcceptor extends FixAcceptor {
   private server: Server
   private logger: IJsFixLogger
-  constructor (public readonly config: IJsFixConfig) {
+  private nextId: number = 0
+
+  constructor (@inject(DITokens.IJsFixConfig) public readonly config: IJsFixConfig) {
     super(config.description.application)
     this.logger = config.logFactory.logger(`${config.description.application.name}:TcpAcceptor`)
-    let nextId: number = 0
-    const tcp = this.config.description.application.tcp
-    const tlsOptions: TlsOptions = getTlsOptions(tcp.tls)
+    const tlsOptions: TlsOptions = this.tlsOptions()
     if (tlsOptions) {
-      try {
-        this.logger.info(`create tls server`)
-        this.server = tlsCreateServer(tlsOptions, (tlsSocket: TLSSocket) => {
-          if (tcp.tls.enableTrace) {
-            this.logger.info(`enabling tls session trace`)
-            tlsSocket.enableTrace()
-          }
-          if (tlsSocket.authorized) {
-            tlsSocket.setEncoding('utf8')
-            const id: number = nextId++
-            this.logger.info(`tls creates session ${id} ${tlsSocket.authorized}`)
-            this.onSocket(id, tlsSocket, config)
-          } else {
-            this.logger.info(`no transport created on tls with no authorized connection`)
-          }
-        })
-      } catch (e) {
-        this.logger.error(e)
-        throw e
-      }
+      this.tlsServer()
     } else {
-      try {
-        this.logger.info(`create unsecured server`)
-        this.server = netCreateServer((socket: Socket) => {
-          const id: number = nextId++
-          this.logger.info(`net creates session ${id} }`)
-          socket.setNoDelay(true)
-          this.onSocket(id, socket, config)
-        })
-      } catch (e) {
-        this.logger.error(e)
-        throw e
-      }
+      this.unsecureServer()
     }
     this.server.on('error', ((err: Error) => {
       throw err
     }))
   }
 
+  getId (): number {
+    this.nextId++
+    return this.nextId
+  }
+
+  tlsServer (): void {
+    try {
+      const config: IJsFixConfig = this.config
+      const tcp = this.config.description.application.tcp
+      const tlsOptions: TlsOptions = TlsOptionsFactory.getTlsOptions(tcp.tls)
+      this.logger.info(`create tls server`)
+      this.server = tlsCreateServer(tlsOptions, (tlsSocket: TLSSocket) => {
+        if (tcp.tls.enableTrace) {
+          this.logger.info(`enabling tls session trace`)
+          tlsSocket.enableTrace()
+        }
+        if (tlsSocket.authorized) {
+          tlsSocket.setEncoding('utf8')
+          const id: number = this.getId()
+          this.logger.info(`tls creates session ${id} ${tlsSocket.authorized}`)
+          this.onSocket(id, tlsSocket, config)
+        } else {
+          this.logger.info(`no transport created on tls with no authorized connection`)
+        }
+      })
+    } catch (e) {
+      this.logger.error(e)
+      throw e
+    }
+  }
+
+  unsecureServer () {
+    try {
+      const config = this.config
+      this.logger.info(`create unsecured server`)
+      this.server = netCreateServer((socket: Socket) => {
+        const id: number = this.getId()
+        this.logger.info(`net creates session ${id}`)
+        socket.setNoDelay(true)
+        this.onSocket(id, socket, config)
+      })
+    } catch (e) {
+      this.logger.error(e)
+      throw e
+    }
+  }
+
+  tlsOptions (): TlsOptions {
+    const tcp = this.config.description.application.tcp
+    return TlsOptionsFactory.getTlsOptions(tcp.tls)
+  }
+
   private onSocket (id: number, socket: Socket, config: IJsFixConfig) {
     const transport: MsgTransport = new MsgTransport(id, config, new TcpDuplex(socket))
     this.saveTransport(id, transport)