jspurefix 1.3.0 → 2.0.2

package/src/transport/index.ts

@@ -1,15 +1,16 @@
-export * from './tcp'
-export * from './http'
-export * from './ascii'
 export * from './duplex'
-export * from './a-session-msg-factory'
-export * from './make-config'
+export * from './fix-entity'
+export * from './session/a-session-msg-factory'
 export * from './fix-acceptor'
 export * from './fix-initiator'
-export * from './fix-msg-factory'
-export * from './fix-session'
-export * from './fix-session-state'
+export * from './session/session-msg-factory'
+export * from './session/fix-session'
+export * from './session/session-state'
+export * from './session/fix-session-state'
 export * from './msg-transmitter'
-export * from './msg-transport'
 export * from './msg-payload'
-export * from './session-description'
+export * from './session/session-description'
+export * from './tick-action'
+export * from './session/make-fix-session'
+export * from './msg-application'
+export * from './ascii/ascii-session'

package/src/transport/msg-application.ts

@@ -0,0 +1,13 @@
+import { ITcpTransportDescription } from './tcp/tcp-transport-description'
+import { IHttpTransportDescription } from './http/http-transport-description'
+
+export interface IMsgApplication {
+  readonly name: string
+  readonly type: string,
+  readonly resilient: boolean
+  readonly reconnectSeconds: number
+  readonly tcp?: ITcpTransportDescription,
+  readonly http?: IHttpTransportDescription,
+  readonly protocol: string,
+  readonly dictionary: string
+}

package/src/transport/msg-transmitter.ts

@@ -1,17 +1,17 @@
 import { MsgEncoder, ElasticBuffer } from '../buffer'
-import { FixDefinitions } from '../dictionary'
+import { FixDefinitions } from '../dictionary/definition'
 import { Transform } from 'stream'
 import { MsgPayload } from './msg-payload'
 import { ILooseObject } from '../collections/collection'
-import { ISessionDescription } from './session-description'
+import { ISessionDescription } from './session/session-description'
 import * as events from 'events'
 
 export abstract class MsgTransmitter extends events.EventEmitter {
   public readonly encodeStream: Transform
-  public readonly buffer: ElasticBuffer = new ElasticBuffer(10 * 1024)
-  protected encoder: MsgEncoder
+  public encoder: MsgEncoder
 
-  protected constructor (public readonly definitions: FixDefinitions,
+  protected constructor (public readonly buffer: ElasticBuffer,
+                         public readonly definitions: FixDefinitions,
                          public readonly session: ISessionDescription) {
     super()
     this.encodeStream = this.encoderStream()

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

@@ -1,7 +1,7 @@
-import { ISessionMsgFactory } from './fix-msg-factory'
+import { ISessionMsgFactory } from './session-msg-factory'
 import { ISessionDescription } from './session-description'
-import { ILooseObject } from '../collections/collection'
-import { MsgType } from '../types'
+import { ILooseObject } from '../../collections/collection'
+import { MsgType } from '../../types'
 
 import {
   IHeartbeat,
@@ -11,7 +11,7 @@ import {
   IStandardHeader,
   IStandardTrailer,
   ITestRequest
-} from '../types/FIX4.4/repo'
+} from '../../types/FIX4.4/repo'
 
 export interface ObjectMutator { (description: ISessionDescription, type: string, o: ILooseObject): ILooseObject
 }

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

@@ -0,0 +1,9 @@
+import { SessionState } from './session-state'
+
+export interface IFixSessionStateArgs {
+  heartBeat: number
+  state?: SessionState
+  waitLogoutConfirmSeconds?: number
+  stopSeconds?: number
+  lastPeerMsgSeqNum?: number
+}

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

@@ -1,48 +1,8 @@
-import { ElasticBuffer } from '../buffer'
+import { ElasticBuffer } from '../../buffer'
 import moment = require('moment')
-
-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
-}
-
-export enum TickAction {
-  Nothing = 1,
-  Heartbeat = 2,
-  TestRequest = 3,
-  TerminateOnError = 4,
-  WaitLogoutConfirmExpired = 5,
-  Stop = 6
-}
-
-interface IFixSessionStateArgs {
-  heartBeat: number
-  state?: SessionState
-  waitLogoutConfirmSeconds?: number
-  stopSeconds?: number
-  lastPeerMsgSeqNum?: number
-}
+import { TickAction } from '../tick-action'
+import { IFixSessionStateArgs } from './fix-session-state-args'
+import { SessionState } from './session-state'
 
 export class FixSessionState {
   public nextTickAction: TickAction = TickAction.Nothing
@@ -74,6 +34,7 @@ export class FixSessionState {
     this.secondsSinceReceive = -1
     this.peerHeartBeatSecs = 0
     this.logoutSentAt = null
+    this.nextTickAction = TickAction.Nothing
     if (resetSeqNo) {
       this.lastPeerMsgSeqNum = 0
     }
@@ -105,7 +66,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 +107,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 → 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
@@ -40,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
   }
 
@@ -48,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)
       }
 
@@ -70,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
@@ -110,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)
       }
     })
 
@@ -144,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()
@@ -168,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}'`)
@@ -177,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
       }
 
@@ -191,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
@@ -205,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
       }
 
@@ -214,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
       }
 
@@ -227,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
@@ -241,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)
   }
 
@@ -254,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()
+    })
+  }
+}