jspurefix 2.2.1 → 3.0.0

package/src/jsfix-cmd.ts

@@ -11,7 +11,6 @@ import { MsgTag } from './types'
 import { IJsFixConfig } from './config'
 
 import * as util from 'util'
-const fs = require('node-fs-extra')
 import * as minimist from 'minimist'
 import * as path from 'path'
 import { MsgTransport } from './transport/factory'
@@ -19,6 +18,7 @@ import { EnumCompiler, ICompilerSettings, MsgCompiler } from './dictionary/compi
 import { AsciiMsgTransmitter } from './transport/ascii/ascii-msg-transmitter'
 import { SessionContainer } from './runtime'
 import { DITokens } from './runtime/di-tokens'
+const fs = require('node-fs-extra')
 
 const argv: any = minimist(process.argv.slice(2))
 
@@ -49,7 +49,7 @@ export class JsfixCmd {
   private sessionDescription: ISessionDescription
   private delimiter: number = AsciiChars.Soh
   private stats: ILooseObject = {}
-  private filter: string = null
+  private filter: string | null = null
   private messages: number = 0
   private print: boolean = true
 
@@ -89,20 +89,19 @@ export class JsfixCmd {
     return mode
   }
 
-  private static async writeFile (name: string, api: string) {
+  private static async writeFile (name: string, api: string): Promise<void> {
     const writer = util.promisify(fs.writeFile)
-    await writer(name, api, {
-      encoding: 'utf8'}
+    await writer(name, api, { encoding: 'utf8' }
     ).catch((e: Error) => {
       throw e
     })
   }
 
-  public exec (): Promise<any> {
-    return new Promise<any>((resolve, reject) => {
+  public async exec (): Promise<any> {
+    return await new Promise<any>((resolve, reject) => {
       this.init().then(async () => {
         let actioned: boolean = true
-        let command = JsfixCmd.getCommand()
+        const command = JsfixCmd.getCommand()
 
         switch (command) {
           case Command.Generate: {
@@ -168,8 +167,8 @@ export class JsfixCmd {
     })
   }
 
-  private firstMessage (t: MsgTransport): Promise<MsgView> {
-    return new Promise<MsgView>((resolve, reject) => {
+  private async firstMessage (t: MsgTransport): Promise<MsgView> {
+    return await new Promise<MsgView>((resolve, reject) => {
       t.receiver.on('msg', (msgType: string, msgView: MsgView) => {
         resolve(msgView.clone())
       })
@@ -179,7 +178,7 @@ export class JsfixCmd {
     })
   }
 
-  private async generate () {
+  protected async generate (): Promise<void> {
     const lipPath: string = path.join(this.root, 'data/examples/lipsum.txt')
     const words: string[] = await getWords(lipPath)
     const generator = new MessageGenerator(words, this.definitions)
@@ -199,7 +198,7 @@ export class JsfixCmd {
     }
   }
 
-  private async single (generator: MessageGenerator, density: number) {
+  private async single (generator: MessageGenerator, density: number): Promise<void> {
     if (!argv.type) {
       console.log('specify type to generate e.g. --type = AE')
       return
@@ -220,14 +219,14 @@ export class JsfixCmd {
     }
   }
 
-  private async script (generator: MessageGenerator, density: number) {
-    let buffer: ElasticBuffer = new ElasticBuffer()
+  private async script (generator: MessageGenerator, density: number): Promise<void> {
+    const buffer: ElasticBuffer = new ElasticBuffer()
     const repeats: number = argv.repeats || 50
     const key: string = MsgTag.MsgType.toString()
     const sf = this.definitions.simple.get(key)
     const session: AsciiMsgTransmitter = this.session
     for (let i = 0; i < repeats; ++i) {
-      const msgType: string = MessageGenerator.getRandomEnum(sf).toString()
+      const msgType: string = sf ? MessageGenerator.getRandomEnum(sf).toString() : ''
       console.log(`i = ${i} ${msgType}`)
       const obj: ILooseObject = generator.generate(msgType, density)
       session.encodeMessage(msgType, obj)
@@ -237,9 +236,9 @@ export class JsfixCmd {
     await JsfixCmd.writeFile('./fix.txt', buffer.slice().toString('utf8'))
   }
 
-  private async unitTest (fix: string, obj: ILooseObject, ft: MsgTransport) {
+  private async unitTest (fix: string, obj: ILooseObject, ft: MsgTransport): Promise<void> {
     const view: MsgView = await this.firstMessage(ft)
-    const summary = view.structure.summary()
+    const summary = view?.structure?.summary()
 
     await JsfixCmd.writeFile('./fix.txt', fix)
     await JsfixCmd.writeFile('./object.json', JSON.stringify(obj, null, 4))
@@ -262,7 +261,7 @@ export class JsfixCmd {
   }
 
   private field (): void {
-    let sf: SimpleFieldDefinition
+    let sf: SimpleFieldDefinition | null
     const tag: number = parseInt(argv.field, 10)
     const definitions = this.definitions
     if (!isNaN(tag)) {
@@ -275,19 +274,19 @@ export class JsfixCmd {
     }
   }
 
-  ensureExists (path: string): Promise<any> {
-    return new Promise<any>((accept, reject) => {
+  async ensureExists (path: string): Promise<any> {
+    return await new Promise<any>((resolve, reject) => {
       fs.mkdirp(path, (err: Error) => {
         if (err) {
           reject(err)
         } else {
-          accept(true)
+          resolve(true)
         }
       })
     })
   }
 
-  private async compileDefinitions (outputPath: string) {
+  private async compileDefinitions (outputPath: string): Promise<void> {
     await this.ensureExists(path.join(outputPath, 'set'))
     await this.ensureExists(path.join(outputPath, 'enum'))
     const definitions = this.definitions
@@ -300,7 +299,7 @@ export class JsfixCmd {
     await enumCompiler.generate(writeFile)
   }
 
-  private async compile () {
+  private async compile (): Promise<void> {
     let output = argv.output
     const dp = new DefinitionFactory().getDictPath(argv.dict)
     if (dp) {
@@ -361,13 +360,12 @@ export class JsfixCmd {
     }
   }
 
-  private subscribe (ft: MsgTransport) {
+  private subscribe (ft: MsgTransport): void {
     this.messages = 0
     this.stats = {}
     const filter = this.filter
     // the receiver is message parser which is piped from an input stream - file, socket
     ft.receiver.on('msg', (msgType: string, m: AsciiView) => {
-
       if (filter) {
         if (msgType !== filter) {
           return
@@ -378,17 +376,19 @@ export class JsfixCmd {
     })
   }
 
-  private onMsg (msgType: string, m: MsgView) {
+  private onMsg (msgType: string, m: MsgView): void {
     const mode: PrintMode = JsfixCmd.getPrintMode()
     const print = this.print
     const stats = this.stats
     switch (mode) {
       case PrintMode.Stats: {
+        let i: number = 0
         if (!stats[msgType]) {
-          stats[msgType] = 1
+          i = 1
         } else {
-          stats[msgType] = stats[msgType] + 1
+          i = stats[msgType] as number + 1
         }
+        stats[msgType] = i
         break
       }
 
@@ -404,14 +404,14 @@ export class JsfixCmd {
         const asObject: ILooseObject = m.toObject()
         if (print) {
           const def = this.definitions.message.get(msgType)
-          console.log(`${msgType} [${def.name}] = ${JSON.stringify(asObject, null, 4)}`)
+          console.log(`${msgType} [${def?.name}] = ${JSON.stringify(asObject, null, 4)}`)
           console.log()
         }
         break
       }
 
       case PrintMode.Structure: {
-        const summary = m.structure.summary()
+        const summary = m?.structure?.summary()
         if (print) {
           console.log(JSON.stringify(summary, null, 4))
         }
@@ -448,35 +448,59 @@ export class JsfixCmd {
     await this.dispatch(ft)
   }
 
+  private async promisedRead (f: string): Promise<string> {
+    return new Promise((resolve, reject) => {
+      fs.readFile(f, 'utf8', async (err: Error, contents: string) => {
+        if (err) {
+          reject(err)
+        }
+        resolve(contents)
+      })
+    })
+  }
+
+  async benchParse (contents: string, iterations: number, print: boolean): Promise<void> {
+    return new Promise((resolve, reject) => {
+      const toParse = new StringDuplex(contents.repeat(iterations), false)
+      const startsAt: Date = new Date()
+      let i = 0
+      const config = this.config
+      const buffer = config.sessionContainer.resolve<ElasticBuffer>(DITokens.ParseBuffer)
+      const asciiParser: MsgParser = new AsciiParser(config, toParse.readable, buffer)
+      function printer (msgType: string, v: MsgView): void {
+        const elapsed: number = new Date().getTime() - startsAt.getTime()
+        console.log(contents)
+        console.log(v.toString())
+        console.log(`[${msgType}]: iterations = ${iterations}, fields = ${v?.structure?.tags.nextTagPos}, length = ${contents.length} chars, elapsed ms ${elapsed}, ${(elapsed / iterations) * 1000} micros per msg`)
+      }
+      asciiParser.on('msg', (msgType: string, v: MsgView) => {
+        ++i
+        if (i === iterations) {
+          if (print) {
+            printer(msgType, v)
+          }
+          resolve()
+        }
+      })
+      asciiParser.on('error', e => reject(e))
+    })
+  }
+
   private async benchmark (repeats: number): Promise<any> {
     if (!argv.fix) {
       console.log('provide a path to fix file i.e. --fix=data/examples/execution-report/fix.txt')
       return
     }
-    return new Promise<any>((accept, reject) => {
+    return await new Promise<any>((resolve, reject) => {
       const fix: string = this.norm(argv.fix)
-      const fs = require('fs')
-      fs.readFile(fix, 'utf8', async (err: Error, contents: string) => {
-        if (err) {
-          reject(err)
-        }
-        const toParse = new StringDuplex(contents.repeat(repeats), false)
-        const startsAt: Date = new Date()
-        let i = 0
-        const config = this.config
-        const buffer = config.sessionContainer.resolve<ElasticBuffer>(DITokens.ParseBuffer)
-        const asciiParser: MsgParser = new AsciiParser(config, toParse.readable, buffer)
-        asciiParser.on('msg', (msgType: string, v: MsgView) => {
-          ++i
-          if (i === repeats) {
-            const elapsed: number = new Date().getTime() - startsAt.getTime()
-            console.log(contents)
-            console.log(v.toString())
-            console.log(`[${msgType}]: repeats = ${repeats}, fields = ${v.structure.tags.nextTagPos}, length = ${contents.length} chars, elapsed ms ${elapsed}, ${(elapsed / repeats) * 1000} micros per msg`)
-            accept(true)
-          }
+      this.promisedRead(fix)
+        .then(contents => {
+          this.benchParse(contents, repeats, true)
+            .then((a: any) => resolve(a))
+            .catch(e => reject(e))
+        }).catch(e => {
+          reject(e)
         })
-      })
     })
   }
 
@@ -521,23 +545,23 @@ function showHelp (): void {
   console.log()
 
   console.log('token format use fix repo dictionary')
-  console.log('jsfix-cmd --dict=data/fix_repo/FIX.4.4/Base --fix=data/examples/quickfix/FIX.4.4/execution-report/fix.txt'
-        + ' --delimiter="|" --tokens')
+  console.log('jsfix-cmd --dict=data/fix_repo/FIX.4.4/Base --fix=data/examples/quickfix/FIX.4.4/execution-report/fix.txt' +
+    ' --delimiter="|" --tokens')
   console.log()
 
   console.log('structure format i.e. show locations of components etc.')
   console.log('jsfix-cmd --dict=data/FIX44.xml --fix=data/examples/FIX.4.4/quickfix/execution-report/fix.txt' +
-        ' --delimiter="|" --tokens --structures')
+    ' --delimiter="|" --tokens --structures')
   console.log()
 
   console.log('full JS object in JSON format.')
   console.log('jsfix-cmd --dict=data/FIX44.xml --fix=data/examples/FIX.4.4/quickfix/execution-report/fix.txt' +
-        ' --delimiter="|" --tokens --objects')
+    ' --delimiter="|" --tokens --objects')
   console.log()
 
   console.log('full JS object in JSON format - filter only type messages.')
   console.log('jsfix-cmd --dict=data/FIX44.xml --fix=data/examples/FIX.4.4/quickfix/execution-report/fix.txt' +
-        ' --delimiter="|" --tokens --type=8 --objects')
+    ' --delimiter="|" --tokens --type=8 --objects')
   console.log()
 
   console.log('timing stats and message counts. Structured parsing of all messages.')
@@ -546,7 +570,7 @@ function showHelp (): void {
 
   console.log('encode a json object to fix format')
   console.log('jsfix-cmd --json=data/examples/FIX.4.4/quickfix/execution-report/object.json' +
-        ' --session=data/session.json --type=8 --delimiter="|"')
+    ' --session=data/session.json --type=8 --delimiter="|"')
   console.log()
 
   console.log('display field definition')

package/src/runtime/make-config.ts

@@ -14,19 +14,24 @@ export class RuntimeFactory {
     @inject(DITokens.ISessionMsgFactory) public readonly msgFactory: ISessionMsgFactory,
     @inject(DITokens.ISessionDescription) public readonly description: ISessionDescription) {}
 
-  makeConfig (): Promise<IJsFixConfig> {
-    const description = this.description
-    return new Promise<IJsFixConfig>((accept, reject) => {
+  async makeConfig (): Promise<IJsFixConfig> {
+    const description = this.description || null
+    return await new Promise<IJsFixConfig>((resolve, reject) => {
       try {
-        this.definitionFactory.getDefinitions(description.application.dictionary,
+        if (!description) reject(new Error('no description object'))
+        const path = description.application?.dictionary ?? 'na'
+        if (!path) reject(new Error('no dictionary in application object'))
+        const type = description.application?.type ?? null
+        if (!type) reject(new Error('no application type in application object'))
+        this.definitionFactory.getDefinitions(path,
           (t: string) => {
-            return this.logFactory.logger(`${description.application.type}.${t}`)
+            return this.logFactory.logger(`${type}.${t}`)
           }).then((definitions: FixDefinitions) => {
-            const config = new JsFixConfig(this.msgFactory, definitions, description, AsciiChars.Soh, this.logFactory)
-            accept(config)
-          }).catch(e => {
-            reject(e)
-          })
+          const config = new JsFixConfig(this.msgFactory, definitions, description, AsciiChars.Soh, this.logFactory)
+          resolve(config)
+        }).catch(e => {
+          reject(e)
+        })
       } catch (e) {
         reject(e)
       }

package/src/runtime/session-container.ts

@@ -1,11 +1,13 @@
 import { container, DependencyContainer } from 'tsyringe'
 import { DefinitionFactory } from '../util'
-import { IJsFixConfig, JsFixWinstonLogFactory, WinstonLogger } from '../config'
+import { IJsFixConfig, JsFixLoggerFactory, JsFixWinstonLogFactory, WinstonLogger } from '../config'
 import { DITokens } from './di-tokens'
 import { RuntimeFactory } from './make-config'
 
-import { TcpAcceptorListener, RecoveringTcpInitiator,
-  TcpInitiatorConnector, TcpInitiator } from '../transport/tcp'
+import {
+  TcpAcceptorListener, RecoveringTcpInitiator,
+  TcpInitiatorConnector, TcpInitiator
+} from '../transport/tcp'
 import { HttpInitiator, HttpAcceptorListener, HttpJsonSampleAdapter } from '../transport/http'
 import { ISessionMsgFactory, MsgTransmitter, ISessionDescription } from '../transport'
 import { AsciiMsgTransmitter } from '../transport/ascii/ascii-msg-transmitter'
@@ -19,14 +21,20 @@ import { FixEntity } from '../transport/fix-entity'
 import { IHttpAdapter } from '../transport/http/http-adapter'
 
 export class SessionContainer {
-
   public reset (): void {
     container.reset()
   }
 
-  public registerGlobal (level: string = 'info'): void {
+  public registerGlobal (loggerFactory?: JsFixLoggerFactory): void
+  public registerGlobal (level: string): void
+  public registerGlobal (levelOrLoggerFactory: string | JsFixLoggerFactory = 'info'): void {
     container.registerInstance(DefinitionFactory, new DefinitionFactory())
-    const lf = new JsFixWinstonLogFactory(WinstonLogger.consoleOptions(level))
+    let lf: JsFixLoggerFactory
+    if (typeof levelOrLoggerFactory === 'string') {
+      lf = new JsFixWinstonLogFactory(WinstonLogger.consoleOptions(levelOrLoggerFactory))
+    } else {
+      lf = levelOrLoggerFactory
+    }
     container.registerInstance(DITokens.JsFixLoggerFactory, lf)
     container.register<RuntimeFactory>(RuntimeFactory, {
       useClass: RuntimeFactory
@@ -38,9 +46,9 @@ export class SessionContainer {
 
   protected makeSessionFactory (description: ISessionDescription): ISessionMsgFactory {
     const fixml = !this.isAscii(description)
-    return fixml ?
-      new FixmlSessionMsgFactory(description) :
-      new AsciiSessionMsgFactory(description)
+    return fixml
+      ? new FixmlSessionMsgFactory(description)
+      : new AsciiSessionMsgFactory(description)
   }
 
   public newChild (description: ISessionDescription): DependencyContainer {
@@ -51,8 +59,8 @@ export class SessionContainer {
     return sessionContainer
   }
 
-  public makeSystem (description: ISessionDescription): Promise<DependencyContainer> {
-    return new Promise<DependencyContainer>((resolve, reject) => {
+  public async makeSystem (description: ISessionDescription): Promise<DependencyContainer> {
+    return await new Promise<DependencyContainer>((resolve, reject) => {
       const sessionContainer = this.newChild(description)
       const factory = sessionContainer.resolve<RuntimeFactory>(RuntimeFactory)
       factory.makeConfig().then((c: IJsFixConfig) => {
@@ -65,14 +73,14 @@ export class SessionContainer {
   }
 
   public isAscii (description: ISessionDescription): boolean {
-    return description.application.protocol === 'ascii'
+    return description.application?.protocol === 'ascii'
   }
 
   public isInitiator (description: ISessionDescription): boolean {
-    return description.application.type === 'initiator'
+    return description.application?.type === 'initiator'
   }
 
-  public asAscii (description: ISessionDescription, sessionContainer: DependencyContainer) {
+  public asAscii (description: ISessionDescription, sessionContainer: DependencyContainer): void {
     sessionContainer.register<MsgTransmitter>(DITokens.MsgTransmitter, {
       useClass: AsciiMsgTransmitter
     })
@@ -105,7 +113,7 @@ export class SessionContainer {
       sessionContainer.register<TcpInitiatorConnector>(TcpInitiatorConnector, {
         useClass: TcpInitiatorConnector
       })
-      if (description.application.resilient) {
+      if (description.application?.resilient) {
         sessionContainer.register<FixEntity>(DITokens.FixEntity, {
           useClass: RecoveringTcpInitiator
         })
@@ -121,7 +129,7 @@ export class SessionContainer {
     }
   }
 
-  public asFixml (description: ISessionDescription, sessionContainer: DependencyContainer) {
+  public asFixml (description: ISessionDescription, sessionContainer: DependencyContainer): void {
     sessionContainer.register<MsgTransmitter>(DITokens.MsgTransmitter, {
       useClass: FixmlMsgTransmitter
     })
@@ -157,7 +165,7 @@ export class SessionContainer {
     }
   }
 
-  protected asciiConstants (c: IJsFixConfig, sessionContainer: DependencyContainer) {
+  protected asciiConstants (c: IJsFixConfig, sessionContainer: DependencyContainer): void {
     sessionContainer.register(DITokens.delimiter, {
       useValue: c.delimiter
     })
@@ -166,7 +174,7 @@ export class SessionContainer {
     })
   }
 
-  public registerSession (c: IJsFixConfig, sessionContainer: DependencyContainer) {
+  public registerSession (c: IJsFixConfig, sessionContainer: DependencyContainer): void {
     if (this.isAscii(c.description)) {
       this.asAscii(c.description, sessionContainer)
       this.asciiConstants(c, sessionContainer)

package/src/runtime/session-launcher.ts

@@ -1,32 +1,42 @@
 import * as path from 'path'
-import { IJsFixConfig, IJsFixLogger, JsFixWinstonLogFactory, WinstonLogger } from '../config'
+import { IJsFixConfig, IJsFixLogger, JsFixLoggerFactory, JsFixWinstonLogFactory, WinstonLogger } from '../config'
 import { ISessionDescription, FixEntity, FixSession } from '../transport'
 import { DependencyContainer } from 'tsyringe'
 import { EngineFactory } from './engine-factory'
 import { SessionContainer } from './session-container'
 import { DITokens } from './di-tokens'
 
-const logFactory = new JsFixWinstonLogFactory(WinstonLogger.consoleOptions('info'))
+const defaultLoggerFactory = new JsFixWinstonLogFactory(WinstonLogger.consoleOptions('info'))
 
 export abstract class SessionLauncher {
   public root: string = '../../'
   protected readonly logger: IJsFixLogger
-  protected constructor (public readonly initiatorConfig: string,
-                         public readonly acceptorConfig: string = null) {
-    this.logger = logFactory.logger('launcher')
+  public readonly initiatorConfig: ISessionDescription
+  public readonly acceptorConfig: ISessionDescription | null
+  protected constructor (initiatorConfig: string | ISessionDescription,
+    acceptorConfig: string | ISessionDescription | null = null,
+    private readonly loggerFactory: JsFixLoggerFactory = defaultLoggerFactory) {
+    this.logger = this.loggerFactory.logger('launcher')
+    this.initiatorConfig = this.loadConfig(initiatorConfig)
+    this.acceptorConfig = acceptorConfig ? this.loadConfig(acceptorConfig) : null
   }
+
   protected sessionContainer: SessionContainer = new SessionContainer()
 
-  private empty (): Promise<any> {
-    return new Promise((resolve, _) => {
-      setImmediate(() => {
-        this.logger.info('resolving an empty promise')
-        resolve(null)
-      })
+  private async empty (): Promise<any> {
+    return await new Promise((resolve, reject) => {
+      try {
+        setImmediate(() => {
+          this.logger.info('resolving an empty promise')
+          resolve(null)
+        })
+      } catch (e) {
+        reject(e)
+      }
     })
   }
 
-  protected getAcceptor (sessionContainer: DependencyContainer): Promise<any> {
+  protected async getAcceptor (sessionContainer: DependencyContainer): Promise<any> {
     if (sessionContainer.isRegistered<FixEntity>(DITokens.FixEntity)) {
       const entity = sessionContainer.resolve<FixEntity>(DITokens.FixEntity)
       return entity.start()
@@ -35,7 +45,7 @@ export abstract class SessionLauncher {
     }
   }
 
-  protected getInitiator (sessionContainer: DependencyContainer): Promise<any> {
+  protected async getInitiator (sessionContainer: DependencyContainer): Promise<any> {
     if (sessionContainer.isRegistered<FixEntity>(DITokens.FixEntity)) {
       const entity = sessionContainer.resolve<FixEntity>(DITokens.FixEntity)
       return entity.start()
@@ -44,17 +54,17 @@ export abstract class SessionLauncher {
     }
   }
 
-  protected makeFactory (config: IJsFixConfig): EngineFactory {
+  protected makeFactory (config: IJsFixConfig): EngineFactory | null {
     return null
   }
 
-  public run () {
-    return new Promise<any>((accept, reject) => {
+  public async run (): Promise<boolean> {
+    return await new Promise<any>((resolve, reject) => {
       const logger = this.logger
       logger.info('launching ..')
       this.setup().then(() => {
         logger.info('.. done')
-        accept(true)
+        resolve(true)
       }).catch((e: Error) => {
         logger.error(e)
         reject(e)
@@ -62,7 +72,7 @@ export abstract class SessionLauncher {
     })
   }
 
-  public exec () {
+  public exec (): void {
     this.run().then(() => {
       console.log('finished.')
     }).catch(e => {
@@ -82,9 +92,11 @@ export abstract class SessionLauncher {
     this.logger.info('bypass register via DI')
   }
 
-  private makeSystem (description: ISessionDescription): Promise<DependencyContainer> {
-    this.logger.info(`creating app ${description.application.name} [protocol ${description.application.protocol}]`)
-    return this.sessionContainer.makeSystem(description)
+  private async makeSystem (description: ISessionDescription): Promise<DependencyContainer> {
+    const name = description.application?.name ?? 'na'
+    const protocol = description.application?.protocol ?? 'ascii'
+    this.logger.info(`creating app ${name} [protocol ${protocol}]`)
+    return await this.sessionContainer.makeSystem(description)
   }
 
   private register (container: DependencyContainer): void {
@@ -102,26 +114,42 @@ export abstract class SessionLauncher {
   }
 
   private async makeClient (): Promise<any> {
-    const description: ISessionDescription = require(path.join(this.root, this.initiatorConfig))
-    const sessionContainer = await this.makeSystem(description)
+    const sessionContainer = await this.makeSystem(this.initiatorConfig)
     this.register(sessionContainer)
     this.logger.info('create initiator')
-    return this.getInitiator(sessionContainer)
+    return await this.getInitiator(sessionContainer)
   }
 
   private async makeServer (): Promise<any> {
-    const description: ISessionDescription = require(path.join(this.root, this.acceptorConfig))
-    const sessionContainer = await this.makeSystem(description)
+    if (!this.acceptorConfig) return
+    const sessionContainer = await this.makeSystem(this.acceptorConfig)
     this.register(sessionContainer)
     this.logger.info('create acceptor')
-    return this.getAcceptor(sessionContainer)
+    return await this.getAcceptor(sessionContainer)
   }
 
-  private async setup () {
-    this.sessionContainer.registerGlobal()
+  async serverOrEmpty (): Promise<any> {
     const server = this.acceptorConfig ? this.makeServer() : this.empty()
+    return server
+  }
+
+  async clientOrEmpty (): Promise<any> {
     const client = this.initiatorConfig ? this.makeClient() : this.empty()
+    return client
+  }
+
+  private async setup (): Promise<any> {
+    this.sessionContainer.registerGlobal(this.loggerFactory)
+    const server = this.serverOrEmpty()
+    const client = this.clientOrEmpty()
     this.logger.info('launching ....')
-    return Promise.all([server, client])
+    return await Promise.all([server, client])
+  }
+
+  private loadConfig (config: string | ISessionDescription): ISessionDescription {
+    if (typeof config === 'string') {
+      return require(path.join(this.root, config))
+    }
+    return config
   }
 }