jspurefix 1.1.2 → 1.4.1

package/src/transport/fix-session.ts

@@ -1,4 +1,4 @@
-import { SegmentType, ElasticBuffer, MsgView } from '../buffer'
+import { ElasticBuffer, MsgView, SegmentType } from '../buffer'
 import { IJsFixConfig, IJsFixLogger } from '../config'
 import { FixSessionState, SessionState } from './fix-session-state'
 import { MsgTransport } from './msg-transport'
@@ -7,7 +7,7 @@ import { ILooseObject } from '../collections/collection'
 
 import * as events from 'events'
 
-export abstract class FixSession {
+export abstract class FixSession extends events.EventEmitter {
   public logReceivedMsgs: boolean = false
   protected timer: NodeJS.Timer = null
   protected transport: MsgTransport = null
@@ -17,17 +17,18 @@ export abstract class FixSession {
   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
   protected requestLogonType: string
 
   protected constructor (public readonly config: IJsFixConfig) {
+    super()
     const description = config.description
-    this.emitter = new events.EventEmitter()
     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
@@ -35,29 +36,73 @@ export abstract class FixSession {
     this.sessionState.compId = description.SenderCompId
   }
 
-  public run (transport: MsgTransport): Promise<any> {
+  public setState (state: SessionState) {
+    if (state === this.sessionState.state) return
+    const logger = this.sessionLogger
+    const prevState = this.sessionState.state
+    const msg = `current state ${SessionState[prevState]} (${prevState}) moves to ${SessionState[state]} (${state})`
+    logger.info(msg)
+    this.sessionState.state = state
+  }
+
+  public getState (): SessionState {
+    return this.sessionState.state
+  }
+
+  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('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 state = ${this.stateString()}`)
+        this.setState(SessionState.WaitingForALogon)
       }
-      this.emitter.on('error', (e: Error) => {
+
+      this.on('error', (e: Error) => {
         logger.error(e)
         reject(e)
       })
-      this.emitter.on('done', () => {
-        accept(true)
+
+      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
@@ -85,8 +130,23 @@ export abstract class FixSession {
       this.terminate(e)
     })
 
-    rx.on('done', () => this.done())
-    rx.on('end', () => this.done())
+    rx.on('done', () => {
+      logger.info('rx done received')
+      this.done()
+    })
+
+    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)
+      }
+    })
 
     rx.on('decoded', (msgType: string, data: ElasticBuffer, ptr: number) => {
       logger.debug(`rx: [${msgType}] ${ptr} bytes`)
@@ -98,34 +158,65 @@ export abstract class FixSession {
       this.terminate(e)
     })
 
-    tx.on('encoded', (msgType: string, data: Buffer) => {
+    tx.on('encoded', (msgType: string, data: string) => {
       logger.debug(`tx: [${msgType}] ${data.length} bytes`)
-      this.onEncoded(msgType, data.toString())
+      this.onEncoded(msgType, data)
     })
   }
 
+  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.emitter.emit('error', error)
+    if (this.timer) {
+      clearInterval(this.timer)
+    }
+    if (this.transport) {
+      this.transport.end()
+    }
+    this.transport = null
+    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()
         break
       }
 
-      case SessionState.PeerLoggedOn: {
-        this.sessionState.state = SessionState.ConfirmingLogout
+      case SessionState.InitiationLogonResponse:
+      case SessionState.ActiveNormalSession:
+      case SessionState.InitiationLogonReceived: {
+        this.setState(SessionState.ConfirmingLogout)
         this.sessionLogger.info(`peer initiates logout Text = '${msg}'`)
         this.sessionLogout()
       }
@@ -133,9 +224,10 @@ export abstract class FixSession {
   }
 
   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
       }
 
@@ -147,20 +239,28 @@ export abstract class FixSession {
     }
   }
 
+  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.PeerLoggedOn: {
+      case SessionState.ActiveNormalSession:
+      case SessionState.InitiationLogonResponse:
+      case SessionState.InitiationLogonReceived: {
         // this instance initiates logout
-        sessionState.state = SessionState.WaitingLogoutConfirm
+        this.setState(SessionState.WaitingLogoutConfirm)
         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
       }
 
@@ -169,7 +269,7 @@ export abstract class FixSession {
         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
       }
 
@@ -181,7 +281,9 @@ export abstract class FixSession {
 
   public done (): void {
     switch (this.sessionState.state) {
-      case SessionState.PeerLoggedOn: {
+      case SessionState.InitiationLogonResponse:
+      case SessionState.ActiveNormalSession:
+      case SessionState.InitiationLogonReceived: {
         this.sessionLogout()
         break
       }
@@ -195,25 +297,36 @@ export abstract class FixSession {
         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.state = SessionState.Connected
-    this.sessionState.lastPeerMsgSeqNum = 0
+    this.sessionState.reset(true) // from header def ... eventually
+    this.setState(SessionState.NetworkConnectionEstablished)
   }
 
-  protected stop (): void {
+  protected stop (error: Error = null): void {
     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()
-    this.emitter.emit('done')
-    this.sessionState.state = SessionState.Stopped
-    this.onStopped()
+    if (error) {
+      this.sessionLogger.info(`stop: emit error ${error.message}`)
+      this.emit('error', error)
+    } else {
+      this.emit('done')
+    }
+
+    this.setState(SessionState.Stopped)
+    this.onStopped(error)
     this.transport = null
   }
 
@@ -227,7 +340,7 @@ export abstract class FixSession {
   // inform application peer has logged in - provide login message
   protected abstract onReady (view: MsgView): void
   // inform application this session has now ended - either from logout or connection dropped
-  protected abstract onStopped (): void
+  protected abstract onStopped (error?: Error): void
   // does the application accept the inbound logon request
   protected abstract onLogon (view: MsgView, user: string, password: string): boolean
 }

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

@@ -0,0 +1,76 @@
+import { ISessionDescription } from './../session-description'
+import { ILooseObject } from '../../collections/collection'
+import { MsgType } from '../../types'
+import { ASessionMsgFactory, ObjectMutator } from '../a-session-msg-factory'
+
+import {
+  IStandardHeader,
+  IUserRequest,
+  IUserResponse,
+  UserRequestType,
+  UserStatus
+} from '../../types/FIXML50SP2'
+
+export class FixmlSessionMsgFactory extends ASessionMsgFactory {
+
+  constructor (readonly description: ISessionDescription, mutator: ObjectMutator = null) {
+    super(description, mutator)
+  }
+
+  public logon (userRequestId: string = '', isResponse: boolean = false): ILooseObject {
+    return this.fixmlLogon(userRequestId, isResponse)
+  }
+
+  public logout (msgType: string, text: string): ILooseObject {
+    return this.fixmlLogout(msgType, msgType !== 'UserReq')
+  }
+
+  public header (msgType: string, seqNum: number = 0, time: Date = new Date(), overrideData?: Partial<IStandardHeader>): ILooseObject {
+    const description = this.description
+    const o: IStandardHeader = {
+      SenderCompID: description.SenderCompId,
+      TargetCompID: description.TargetCompID,
+      SenderSubID: description.SenderSubID,
+      TargetSubID: description.TargetSubID
+    } as IStandardHeader
+    return this.mutate(o, 'StandardHeader')
+  }
+
+  private fixmlLogon (userRequestId: string, isResponse: boolean): ILooseObject {
+    const description = this.description
+    if (!isResponse) {
+      const o: IUserRequest = {
+        Username: description.Username,
+        Password: description.Password,
+        UserRequestID: userRequestId,
+        UserRequestType: UserRequestType.LogOnUser
+      } as IUserRequest
+      return this.mutate(o, MsgType.Logon)
+    } else {
+      const o: IUserResponse = {
+        Username: description.Username,
+        UserRequestID: userRequestId,
+        UserStatus: UserStatus.LoggedIn
+      } as IUserResponse
+      return this.mutate(o, MsgType.Logon)
+    }
+  }
+
+  private fixmlLogout (userRequestId: string, isResponse: boolean): ILooseObject {
+    if (!isResponse) {
+      const o: IUserRequest = {
+        Username: this.description.Username,
+        UserRequestID: userRequestId,
+        UserRequestType: UserRequestType.LogOffUser
+      } as IUserRequest
+      return this.mutate(o, MsgType.Logout)
+    } else {
+      const o: IUserResponse = {
+        Username: this.description.Username,
+        UserRequestID: userRequestId,
+        UserStatus: UserStatus.NotLoggedIn
+      } as IUserResponse
+      return this.mutate(o, MsgType.Logout)
+    }
+  }
+}

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

@@ -69,7 +69,7 @@ export abstract class FixmlSession extends FixSession {
   private peerLogon (view: MsgView) {
     const logger = this.sessionLogger
     const state = this.sessionState
-    state.state = SessionState.PeerLoggedOn
+    state.state = SessionState.InitiationLogonReceived
     state.peerCompId = view.getTyped(MsgTag.SenderCompID)
     if (this.acceptor) {
       const reqId: string = view.getString('UserReqID')

package/src/transport/fixml/index.ts

@@ -1,4 +1,5 @@
 export * from './acceptor'
-export * from './fixml-msg-transmitter'
 export * from './fixml-request'
 export * from './fixml-session'
+export * from './fixml-msg-transmitter'
+export * from './fixml-session-msg-factory'

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)
       }

package/src/transport/index.ts

@@ -2,7 +2,7 @@ export * from './tcp'
 export * from './http'
 export * from './ascii'
 export * from './duplex'
-export * from './session-msg-factory'
+export * from './a-session-msg-factory'
 export * from './make-config'
 export * from './fix-acceptor'
 export * from './fix-initiator'

package/src/transport/msg-transmitter.ts

@@ -40,11 +40,12 @@ export abstract class MsgTransmitter extends events.EventEmitter {
       transform (payload: MsgPayload, encoding, done: Function) {
         try {
           const msgType = payload.msgType
-          transmitter.buffer.reset()
+          transmitter.encoder.reset()
           transmitter.encodeMessage(msgType, payload.obj)
-          payload.encoded = transmitter.buffer.copy()
+          payload.encoded = transmitter.encoder.trim()
           this.push(payload.encoded)
-          transmitter.emit('encoded', msgType, payload.encoded)
+          const encodedTxt = transmitter.buffer.toString()
+          transmitter.emit('encoded', msgType, encodedTxt)
           done()
         } catch (e) {
           done(e)

package/src/transport/msg-transport.ts

@@ -17,6 +17,7 @@ export class MsgTransport {
     if (!delimiter) {
       throw new Error(`no delimiter char given.`)
     }
+    const logDelimiter = config.logDelimiter || AsciiChars.Pipe
     const description = config.description
     const definitions = config.definitions
     const protocol = description.application.protocol
@@ -25,7 +26,7 @@ export class MsgTransport {
         // let parser replace delimiter with Pipe so fix log does not require
         // expensive replace
         this.transmitter = new AsciiMsgTransmitter(config)
-        this.receiver = new AsciiParser(definitions, duplex.readable, delimiter, AsciiChars.Pipe)
+        this.receiver = new AsciiParser(definitions, duplex.readable, delimiter, logDelimiter)
         break
       }
 
@@ -53,7 +54,7 @@ export class MsgTransport {
   public wait (): Promise<any> {
     return new Promise<any>((resolve, reject) => {
       this.receiver.on('end', () => {
-        resolve(true)
+        resolve(this.id)
       })
       this.receiver.on('error', (e) => {
         reject(e)

package/src/transport/session-description.ts

@@ -12,7 +12,7 @@ export interface ITlsOptions {
 export interface ITcpTransportDescription {
   readonly port: number
   readonly host: string,
-  readonly tls: ITlsOptions
+  readonly tls?: ITlsOptions
 }
 
 export interface IHttpAdapter {

package/src/transport/tcp/acceptor.ts

@@ -19,9 +19,11 @@ export function acceptor (config: IJsFixConfig, sessionFactory: MakeFixSession):
           accept(true)
         })
       }).catch((e: Error) => {
-        logger.error(e)
-        logger.info(e.stack)
-        reject(e)
+        logger.info(`error in session - close listener ${e.message}`)
+        acceptor.close(() => {
+          logger.info('acceptor closed.')
+          reject(e)
+        })
       })
     })
     acceptor.listen()

package/src/transport/tcp/index.ts

@@ -1,3 +1,4 @@
+export * from './recovering-tcp-initiator'
 export * from './tcp-initiator'
 export * from './tcp-acceptor'
 export * from './initiator'

package/src/transport/tcp/initiator.ts

@@ -19,6 +19,7 @@ export function initiator (config: IJsFixConfig, sessionFactory: MakeFixSession,
         accept(true)
       } catch (e) {
         if (!reconnectTimeout) {
+          connecting = false
           reject(e)
         } else {
           logger.info(`waiting ${reconnectTimeout} to reconnect following error`)