jspurefix 1.3.0 → 2.0.2

package/src/dictionary/fields-dispatch.ts

@@ -1,45 +0,0 @@
-import { ContainedField, ContainedFieldType, ContainedGroupField, ContainedSimpleField, ContainedComponentField } from './contained'
-
-export interface IFieldDispatcher {
-  group?: { (field: ContainedGroupField): void }
-  simple?: { (field: ContainedSimpleField): void }
-  component?: { (field: ContainedComponentField): void }
-}
-
-function dispatchField (field: ContainedField, dispatcher: IFieldDispatcher): void {
-  switch (field.type) {
-    case ContainedFieldType.Group: {
-      if (dispatcher.group) {
-        dispatcher.group(field as ContainedGroupField)
-      }
-      break
-    }
-
-    case ContainedFieldType.Simple: {
-      if (dispatcher.simple) {
-        try {
-          dispatcher.simple(field as ContainedSimpleField)
-        } catch (ex) {
-          let x = 0
-        }
-      }
-      break
-    }
-
-    case ContainedFieldType.Component: {
-      if (dispatcher.component) {
-        dispatcher.component(field as ContainedComponentField)
-      }
-      break
-    }
-
-    default:
-      throw new Error(`unknown type ${field.type}`)
-  }
-}
-
-export function dispatchFields (fields: ContainedField[], dispatcher: IFieldDispatcher): void {
-  fields.forEach((field: ContainedField) => {
-    dispatchField(field, dispatcher)
-  })
-}

package/src/sample/launcher.ts

@@ -1,56 +0,0 @@
-import * as path from 'path'
-import { WinstonLogger, IJsFixConfig, JsFixWinstonLogFactory, IJsFixLogger } from '../config'
-import { makeConfig, ISessionDescription, ISessionMsgFactory } from '../transport'
-import { AsciiSessionMsgFactory } from '../transport/ascii'
-import { FixmlSessionMsgFactory } from '../transport/fixml'
-
-const root = '../../'
-const logFactory = new JsFixWinstonLogFactory(WinstonLogger.consoleOptions('info'))
-
-export abstract class Launcher {
-  protected readonly logger: IJsFixLogger
-  protected constructor (public readonly initiatorConfig: string, public readonly acceptorConfig: string) {
-    this.logger = logFactory.logger('launcher')
-  }
-
-  protected abstract getInitiator (config: IJsFixConfig): Promise<any>
-  protected abstract getAcceptor (config: IJsFixConfig): Promise<any>
-
-  public run () {
-    return new Promise<any>((accept, reject) => {
-      const logger = this.logger
-      logger.info('launching ..')
-      this.setup().then(() => {
-        logger.info('.. done')
-        accept(true)
-      }).catch((e: Error) => {
-        logger.error(e)
-        reject(e)
-      })
-    })
-  }
-
-  private makeSessionFactory (description: ISessionDescription): ISessionMsgFactory {
-    const fixml = description.application.protocol !== 'ascii'
-    const factory = fixml ?
-      new FixmlSessionMsgFactory(description) :
-      new AsciiSessionMsgFactory(description)
-    return factory
-  }
-
-  private async setup () {
-    const clientDescription: ISessionDescription = require(path.join(root, this.initiatorConfig))
-    const serverDescription: ISessionDescription = require(path.join(root, this.acceptorConfig))
-    this.logger.info(`launching [protocol ${clientDescription.application.protocol}] ...`)
-    const clientConfig = await
-    makeConfig(clientDescription, logFactory, this.makeSessionFactory(clientDescription))
-    const serverConfig = await
-    makeConfig(serverDescription, logFactory, this.makeSessionFactory(serverDescription))
-    this.logger.info('create acceptor')
-    const server = this.getAcceptor(serverConfig)
-    this.logger.info('create initiator')
-    const client = this.getInitiator(clientConfig)
-    this.logger.info('launching ....')
-    return Promise.all([server, client])
-  }
-}

package/src/transport/fixml/acceptor.ts

@@ -1,29 +0,0 @@
-import { IJsFixConfig } from '../../config'
-import { FixAcceptor } from '../fix-acceptor'
-import { MsgTransport } from '../msg-transport'
-import { HttpAcceptor } from '../http'
-import { MakeFixSession } from '../make-fixl-session'
-
-export function acceptor (config: IJsFixConfig, sessionFactory: MakeFixSession): Promise<any> {
-  return new Promise<any>(async (accept, reject) => {
-    const logger = config.logFactory.logger('acceptor')
-    logger.info('starting.')
-    const acceptor: FixAcceptor = new HttpAcceptor(config)
-    acceptor.on('transport', (t: MsgTransport) => {
-      logger.info('creates new transport.')
-      const acceptorSession = sessionFactory(config)
-      acceptorSession.run(t).then(() => {
-        logger.info('ends')
-        acceptor.close(() => {
-          logger.info('acceptor closed.')
-          accept(true)
-        })
-      }).catch((e: Error) => {
-        logger.error(e)
-        logger.info(e.stack)
-        reject(e)
-      })
-    })
-    acceptor.listen()
-  })
-}

package/src/transport/make-config.ts

@@ -1,19 +0,0 @@
-import { AsciiChars } from '../buffer'
-import { ISessionDescription } from './session-description'
-import { ISessionMsgFactory } from './fix-msg-factory'
-import { IJsFixConfig, JsFixConfig, JsFixLoggerFactory } from '../config'
-import { FixDefinitions } from '../dictionary'
-import { getDefinitions } from '../util'
-
-export async function makeConfig (description: ISessionDescription, logFactory: JsFixLoggerFactory, msgFactory: ISessionMsgFactory): Promise<IJsFixConfig> {
-  return new Promise<IJsFixConfig>(async (accept, reject) => {
-    try {
-      const definitions: FixDefinitions = await getDefinitions(description.application.dictionary,
-        (t: string) => logFactory.logger(`${description.application.type}.${t}`))
-      const config = new JsFixConfig(msgFactory, definitions, description, AsciiChars.Soh, logFactory)
-      accept(config)
-    } catch (e) {
-      reject(e)
-    }
-  })
-}

package/src/transport/msg-transport.ts

@@ -1,67 +0,0 @@
-import { AsciiParser, FiXmlParser, MsgParser, AsciiChars } from '../buffer'
-import { AsciiMsgTransmitter } from './ascii'
-import { MsgTransmitter } from './msg-transmitter'
-import { FixmlMsgTransmitter } from './fixml'
-import { FixDuplex } from './duplex'
-import { IJsFixConfig } from '../config'
-
-export class MsgTransport {
-  public readonly transmitter: MsgTransmitter
-  public readonly receiver: MsgParser
-
-  constructor (public readonly id: number,
-               public readonly config: IJsFixConfig,
-               public readonly duplex: FixDuplex) {
-
-    const delimiter = config.delimiter
-    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
-    switch (protocol) {
-      case 'ascii': {
-        // 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, logDelimiter)
-        break
-      }
-
-      case 'fixml': {
-        this.transmitter = new FixmlMsgTransmitter(config)
-        this.receiver = new FiXmlParser(config, duplex.readable)
-        break
-      }
-
-      default: {
-        throw new Error(`session Protocol must ascii or fixml. got ${protocol}`)
-      }
-    }
-
-    // pipe the encoder to say a socket.
-    if (duplex.writable) {
-      this.transmitter.encodeStream.pipe(duplex.writable)
-    }
-  }
-
-  public end (): void {
-    this.duplex.end()
-  }
-
-  public wait (): Promise<any> {
-    return new Promise<any>((resolve, reject) => {
-      this.receiver.on('end', () => {
-        resolve(this.id)
-      })
-      this.receiver.on('error', (e) => {
-        reject(e)
-      })
-      this.transmitter.on('error', (e) => {
-        reject(e)
-      })
-    })
-  }
-}

package/src/transport/session-description.ts

@@ -1,70 +0,0 @@
-export interface ITlsOptions {
-  readonly key: string,
-  readonly cert: string,
-  readonly ca?: string[],
-  readonly timeout?: number,
-  readonly sessionTimeout?: number,
-  readonly enableTrace?: boolean,
-  readonly requestCert?: boolean,
-  readonly rejectUnauthorized?: boolean
-}
-
-export interface ITcpTransportDescription {
-  readonly port: number
-  readonly host: string,
-  readonly tls?: ITlsOptions
-}
-
-export interface IHttpAdapter {
-  getOptions (data: Buffer): IHtmlOptions
-  beginMessage (msgType: string): void
-  endMessage (m: any): Buffer
-}
-
-export interface IHtmlOptions {
-  method: string,
-  uri: string,
-  json: boolean,
-  body: any,
-  headers: any,
-  resolveWithFullResponse: boolean
-}
-
-export interface IHtmlRoute {
-  name: string,
-  value: IHtmlOptions
-}
-
-export interface IHttpTransportDescription {
-  readonly port: number
-  readonly uri: string,
-  readonly options: IHtmlRoute[]
-  adapter: IHttpAdapter
-}
-
-export interface IMsgApplication {
-  readonly name: string
-  readonly type: string,
-  readonly reconnectSeconds: number
-  readonly tcp?: ITcpTransportDescription,
-  readonly http?: IHttpTransportDescription,
-  readonly protocol: string,
-  readonly dictionary: string
-}
-
-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/tcp/acceptor.ts

@@ -1,31 +0,0 @@
-import { IJsFixConfig } from '../../config'
-import { FixAcceptor } from '../fix-acceptor'
-import { TcpAcceptor } from './tcp-acceptor'
-import { MsgTransport } from '../msg-transport'
-import { MakeFixSession } from '../make-fixl-session'
-
-export function acceptor (config: IJsFixConfig, sessionFactory: MakeFixSession): Promise<any> {
-  return new Promise<any>(async (accept, reject) => {
-    const logger = config.logFactory.logger('acceptor')
-    logger.info('starting.')
-    const acceptor: FixAcceptor = new TcpAcceptor(config)
-    acceptor.on('transport', (t: MsgTransport) => {
-      logger.info('creates new transport.')
-      const acceptorSession = sessionFactory(config)
-      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/initiator.ts

@@ -1,59 +0,0 @@
-import { IJsFixConfig } from '../../config'
-import { FixInitiator } from '../fix-initiator'
-import { TcpInitiator } from './tcp-initiator'
-import { MsgTransport } from '../msg-transport'
-import { MakeFixSession } from '../make-fixl-session'
-import { FixSession } from '../fix-session'
-
-export function initiator (config: IJsFixConfig, sessionFactory: MakeFixSession, reconnectTimeout: number = 0): Promise<any> {
-  return new Promise<any>(async (accept, reject) => {
-    const logger = config.logFactory.logger('initiator')
-    logger.info('create session')
-    const initiatorSession = sessionFactory(config)
-    let connecting: boolean = true
-    while (connecting) {
-      try {
-        await once(config, initiatorSession)
-        logger.info('session has ended')
-        connecting = false
-        accept(true)
-      } catch (e) {
-        if (!reconnectTimeout) {
-          connecting = false
-          reject(e)
-        } else {
-          logger.info(`waiting ${reconnectTimeout} to reconnect following error`)
-          await delay(reconnectTimeout)
-        }
-      }
-    }
-  })
-}
-
-function delay (p: number): Promise<any> {
-  return new Promise<any>((accept) => {
-    if (!p) {
-      accept(true)
-    }
-    setTimeout(() => {
-      accept(true)
-    }, p)
-  })
-}
-
-function once (config: IJsFixConfig, initiatorSession: FixSession): Promise<any> {
-  return new Promise<any>(async (accept, reject) => {
-    const logger = config.logFactory.logger('initiator')
-    const initiator: FixInitiator = new TcpInitiator(config)
-    logger.info('connecting ...')
-    const initiatorTransport: MsgTransport = await initiator.connect(22)
-    logger.info('... connected, run session')
-    initiatorSession.run(initiatorTransport).then(() => {
-      logger.info('ends')
-      accept(true)
-    }).catch((e: Error) => {
-      logger.error(e)
-      reject(e)
-    })
-  })
-}

package/src/util/dictionary-definitions.ts

@@ -1,41 +0,0 @@
-import { FixXsdParser, FixDefinitions, FixParser, QuickFixXmlFileParser, RepositoryXmlParser } from '../dictionary'
-import { GetJsFixLogger, makeEmptyLogger } from '../config'
-import * as path from 'path'
-import * as fs from 'fs'
-
-export interface IDictionaryPath {
-  output: string,
-  dict: string
-}
-
-const root: string = path.join(__dirname, '../../')
-
-export function getDictPath (p: string): IDictionaryPath {
-  const dictionary = require(path.join(root, 'data/dictionary.json'))
-  return dictionary[p]
-}
-
-export async function getDefinitions (path: string, getLogger: GetJsFixLogger = makeEmptyLogger): Promise<FixDefinitions> {
-  let parser: FixParser
-  const dp: IDictionaryPath = getDictPath(path)
-  if (dp) {
-    path = dp.dict
-  }
-  path = norm(path)
-  if (fs.lstatSync(path).isDirectory() && path.indexOf('fixml') >= 0) {
-    parser = new FixXsdParser(path, getLogger)
-  } else if (fs.lstatSync(path).isDirectory()) {
-    parser = new RepositoryXmlParser(path, getLogger)
-  } else {
-    parser = new QuickFixXmlFileParser(path, getLogger)
-  }
-  return parser.parse()
-}
-
-function norm (p: string): string {
-  let f: string = p
-  if (!path.isAbsolute(p)) {
-    f = path.join(root, f)
-  }
-  return f
-}