jspurefix 5.10.6 → 5.11.1

package/src/runtime/session-launcher.ts

@@ -57,6 +57,7 @@ export abstract class SessionLauncher {
   }
 
   private acceptorEntity: FixEntity | null = null
+  private initiatorEntity: FixEntity | null = null
   private stopRequested: boolean = false
 
   protected async getAcceptor (sessionContainer: DependencyContainer): Promise<any> {
@@ -78,6 +79,11 @@ export abstract class SessionLauncher {
   protected async getInitiator (sessionContainer: DependencyContainer): Promise<any> {
     if (sessionContainer.isRegistered<FixEntity>(DITokens.FixEntity)) {
       const entity = sessionContainer.resolve<FixEntity>(DITokens.FixEntity)
+      this.initiatorEntity = entity
+      if (this.stopRequested) {
+        this.logger.info('stop requested before the initiator started - not connecting')
+        return this.empty()
+      }
       return entity.start()
     } else {
       return this.empty()
@@ -95,7 +101,8 @@ export abstract class SessionLauncher {
   }
 
   /**
-   * Stop what this launcher started - in practice, close the acceptor's listener.
+   * Stop what this launcher started - close the acceptor's listener, and give up a
+   * resilient initiator's attempts to get its transport back.
    *
    * An acceptor is meant to outlive any one counterparty, so nothing closes its
    * listener on its own.  That is right for a venue and wrong for an application
@@ -107,12 +114,18 @@ export abstract class SessionLauncher {
    * usual arrangement as soon as more than one client is involved.  There was then
    * no way to shut a listener down short of killing the process.
    *
-   * Safe before start (the request is remembered and the listener never opens), and
-   * safe to call twice.  run() resolves once the listener has closed.
+   * A resilient initiator had the same problem from the other side: losing the
+   * transport schedules another attempt, so it too kept the process alive with no way
+   * to call it off.  See issue #72.
+   *
+   * Safe before start (the request is remembered and neither is opened), and safe to
+   * call twice.  run() resolves once the listener has closed and the initiator has
+   * given up.
    */
   public stop (): void {
     this.stopRequested = true
     this.stopAcceptor()
+    this.stopInitiator()
   }
 
   public async run (): Promise<boolean> {
@@ -229,6 +242,15 @@ export abstract class SessionLauncher {
     }
   }
 
+  // only a resilient initiator has anything to call off - a plain one ends with its
+  // session, so it has no stop to find here
+  private stopInitiator (): void {
+    const entity = this.initiatorEntity as any
+    if (entity && typeof entity.stop === 'function') {
+      entity.stop()
+    }
+  }
+
   private loadConfig (config: string | ISessionDescription): ISessionDescription {
     if (typeof config === 'string') {
       return require(path.join(this.root, config))

package/src/transport/msg-application.ts

@@ -4,8 +4,24 @@ import { IHttpTransportDescription } from './http/http-transport-description'
 export interface IMsgApplication {
   readonly name: string
   readonly type: string
+  /**
+   * An initiator which re-establishes its transport after the connection drops and
+   * resumes the same session, rather than ending when the socket does.  Defaults to
+   * false, which gives a single connection.  See "Reconnecting initiators" in the
+   * README for the retry policy below.
+   */
   readonly resilient: boolean
+  /** how long to wait between attempts whilst trying to establish a connection.  Defaults to 5. */
   readonly reconnectSeconds: number
+  /**
+   * how long to keep attempting a connection before giving up.  Defaults to 60 for a
+   * resilient initiator and 22 for a plain one.
+   */
+  readonly connectTimeoutSeconds?: number
+  /** resilient only: how long after losing the transport before trying to get it back.  Defaults to 5. */
+  readonly recoveryAttemptSeconds?: number
+  /** resilient only: how long to wait after a failed recovery before trying again.  Defaults to 30. */
+  readonly backoffFailConnectSeconds?: number
   readonly tcp?: ITcpTransportDescription
   readonly http?: IHttpTransportDescription
   readonly protocol: string

package/src/transport/tcp/connect-error.ts

@@ -0,0 +1,56 @@
+/**
+ * A readable reason for a failed connection.
+ *
+ * Node raises an AggregateError when the host resolved to more than one address and
+ * every attempt failed.  That is not an edge case: 'localhost' is both ::1 and
+ * 127.0.0.1 on any modern machine, so it is what an ordinary refused connection looks
+ * like.  Its own message is empty and the detail sits in errors[], so reporting
+ * e.message alone said nothing at all about the commonest failure there is - an
+ * application catching a rejected connect saw an Error with no message.
+ *
+ * Falls back to the code (ECONNREFUSED, ENOTFOUND, ETIMEDOUT) when there is no
+ * message anywhere, which is still enough to act on.
+ */
+export function describeConnectError (e: unknown): string {
+  if (e == null) return 'unknown error'
+  const described = detail(e)
+  return described.length > 0 ? described : String(e)
+}
+
+/**
+ * The reason, or '' when this error carries none.
+ *
+ * Kept separate from the public function so a nested error with nothing to say
+ * contributes nothing, rather than a stringified 'Error' that would then look like a
+ * reason and stop the aggregate falling back to its own code.
+ */
+function detail (e: unknown): string {
+  if (e == null) return ''
+
+  const err = e as { message?: string, code?: string, errors?: unknown[] }
+
+  if (Array.isArray(err.errors) && err.errors.length > 0) {
+    // every address usually fails the same way - say it once rather than repeating
+    // 'connect ECONNREFUSED' for each family
+    const unique = Array.from(new Set(err.errors.map(detail).filter(m => m.length > 0)))
+    if (unique.length > 0) return unique.join('; ')
+  }
+
+  if (err.message) return err.message
+  if (err.code) return err.code
+  return ''
+}
+
+/**
+ * Give an error a message when it has none, keeping the object itself.
+ *
+ * Deliberately not a wrapper: `code` and `errors` are what a caller switches on, and
+ * building a fresh Error to hold the text would throw both away.  Returns the same
+ * error so it can be used inline.
+ */
+export function withConnectReason (e: Error): Error {
+  if (!e.message) {
+    e.message = describeConnectError(e)
+  }
+  return e
+}

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

@@ -9,6 +9,7 @@ import { DITokens } from '../../runtime/di-tokens'
 import { ITcpTransportDescription } from './tcp-transport-description'
 import { IMsgApplication } from '../msg-application'
 import { FixEntity } from '../fix-entity'
+import { describeConnectError } from './connect-error'
 
 /*
    create one application session instance - and recover a lost transport.  Hence, the application
@@ -25,8 +26,14 @@ export class RecoveringTcpInitiator extends FixEntity {
   private initiator: TcpInitiator
   private transport: MsgTransport
   private th: Timeout | null = null
-  public recoveryAttemptSecs: number = 5
-  public backoffFailConnectSecs: number = 30
+  private stopRequested: boolean = false
+  public static readonly DefaultRecoveryAttemptSecs = 5
+  public static readonly DefaultBackoffFailConnectSecs = 30
+  public static readonly DefaultConnectTimeoutSecs = 60
+
+  public recoveryAttemptSecs: number = RecoveringTcpInitiator.DefaultRecoveryAttemptSecs
+  public backoffFailConnectSecs: number = RecoveringTcpInitiator.DefaultBackoffFailConnectSecs
+  public connectTimeoutSecs: number = RecoveringTcpInitiator.DefaultConnectTimeoutSecs
 
   constructor (@inject(DITokens.IJsFixConfig) public readonly jsFixConfig: IJsFixConfig) {
     super(jsFixConfig)
@@ -40,6 +47,14 @@ export class RecoveringTcpInitiator extends FixEntity {
     if (!this.tcp) {
       throw new Error('no tcp in session description need tcp { host: hostname, port: port }')
     }
+    // the retry policy used to live only in these fields, which nothing set - an
+    // application could not change how hard or how long the engine tried to get its
+    // transport back without subclassing the launcher.  See issue #72.
+    this.recoveryAttemptSecs = this.application.recoveryAttemptSeconds ?? this.recoveryAttemptSecs
+    this.backoffFailConnectSecs = this.application.backoffFailConnectSeconds ?? this.backoffFailConnectSecs
+    this.connectTimeoutSecs = this.application.connectTimeoutSeconds ?? this.connectTimeoutSecs
+    this.logger.info(`recovery policy: connectTimeout=${this.connectTimeoutSecs}s, ` +
+      `recoveryAttempt=${this.recoveryAttemptSecs}s, backoffFailConnect=${this.backoffFailConnectSecs}s`)
     this.createSession(jsFixConfig)
   }
 
@@ -54,6 +69,13 @@ export class RecoveringTcpInitiator extends FixEntity {
       this.logger.info('session has permanently ended')
       this.emit('end', this)
     })
+    // A lost transport is this initiator's normal course of events, and recovery is
+    // driven by session.run() rejecting rather than by this event.  But whilst waiting
+    // between attempts there is no run in flight to carry a listener, so a stop landing
+    // then would emit 'error' to nobody - which node treats as fatal.
+    this.session.on('error', (e: Error) => {
+      this.logger.info(`session error: ${e.message}`)
+    })
     this.session.setState(SessionState.DisconnectedNoConnectionToday)
   }
 
@@ -104,7 +126,31 @@ export class RecoveringTcpInitiator extends FixEntity {
   // succeed in which case can restart session or fails in which case wait and
   // restart an attempt to connect
 
+  /**
+   * Give up recovering and end the session for good.
+   *
+   * Without this a resilient initiator could not be shut down: losing the transport
+   * schedules another attempt, and nothing cancelled that timer, so the process stayed
+   * alive retrying a counterparty the application had finished with.  Safe to call
+   * twice, and safe whilst waiting between attempts with no transport at all.
+   */
+  public stop (): void {
+    if (this.stopRequested) return
+    this.stopRequested = true
+    this.logger.info('stop requested - cancelling recovery')
+    this.clearTimer()
+    if (this.session.getState() !== SessionState.Stopped) {
+      this.session.requestStop('initiator stopped')
+    }
+    this.emit('end', this)
+  }
+
   private recover (): void {
+    if (this.stopRequested) {
+      this.logger.info('transport lost after a stop was requested - not recovering')
+      this.emit('end', this)
+      return
+    }
     this.session.setState(SessionState.DetectBrokenNetworkConnection)
     this.logger.info(`recover session transport - attempt in ${this.recoveryAttemptSecs} secs`)
     if (!this.resetSeq()) {
@@ -115,10 +161,10 @@ export class RecoveringTcpInitiator extends FixEntity {
       }
     }
     this.th = setTimeout(() => {
-      this.connect(60).then(t => {
+      this.connect(this.connectTimeoutSecs).then(t => {
         this.logger.info(`new transport ${t.id}`)
       }).catch((e) => {
-        this.logger.info(`failed to re-connect ${e.message} - backoff for ${this.backoffFailConnectSecs}`)
+        this.logger.info(`failed to re-connect: ${describeConnectError(e)} - backoff for ${this.backoffFailConnectSecs}`)
         this.th = setTimeout(() => {
           this.logger.info('returning to recover()')
           setImmediate(() => {
@@ -135,18 +181,34 @@ export class RecoveringTcpInitiator extends FixEntity {
 
   // 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.
+  // connections are re-established using the same session instance.  So this promise
+  // is the lifetime of the application, not a signal that the session is up: for that,
+  // use onReady on the session.  See issue #72.
 
-  public async run (initialTimeout: number = 60): Promise<any> {
+  public async run (initialTimeout: number = this.connectTimeoutSecs): Promise<any> {
     return await new Promise<any>((resolve, reject) => {
-      this.connect(initialTimeout).then(() => {
-        this.on('end', () => {
-          this.clearTimer()
-          this.initiator.end()
-          this.logger.info(`run: transport ${this.transport.id} gracefully ends ${initialTimeout} - resolving`)
-          resolve(null)
-        })
-      }).catch(e => {
+      // 'end' can arrive more than once - a stop both ends the session and calls off
+      // recovery, and each path announces itself - so settle only on the first.  The
+      // listener goes on before connecting, not after: a stop landing whilst the first
+      // connection is still being attempted has to be able to end this too, and until
+      // now there was nothing listening that early to hear it.
+      let ended = false
+      const finish = (): void => {
+        if (ended) return
+        ended = true
+        this.clearTimer()
+        this.initiator?.end()
+        this.logger.info(`run: transport ${this.transport?.id ?? 'none'} ends - resolving`)
+        resolve(null)
+      }
+      this.on('end', finish)
+
+      this.connect(initialTimeout).catch(e => {
+        if (this.stopRequested) {
+          this.logger.info('run: first connection abandoned on stop - resolving')
+          finish()
+          return
+        }
         this.logger.info(`run: failed to connect to first transport ${initialTimeout} - rejecting`)
         reject(e)
       })

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

@@ -9,8 +9,13 @@ import { FixEntity } from '../fix-entity'
 
 @injectable()
 export class TcpInitiatorConnector extends FixEntity {
+  public static readonly DefaultConnectTimeoutSecs = 22
+
+  public connectTimeoutSecs: number = TcpInitiatorConnector.DefaultConnectTimeoutSecs
+
   constructor (@inject(DITokens.IJsFixConfig) public readonly config: IJsFixConfig) {
     super(config)
+    this.connectTimeoutSecs = config.description.application?.connectTimeoutSeconds ?? this.connectTimeoutSecs
   }
 
   async start (reconnectTimeout: number = 0): Promise<any> {
@@ -62,7 +67,7 @@ export class TcpInitiatorConnector extends FixEntity {
     const logger = this.config.logFactory.logger('initiator')
     const initiator: FixInitiator = this.config.sessionContainer.resolve<FixInitiator>(TcpInitiator)
     logger.info('connecting ...')
-    const initiatorTransport: MsgTransport = await initiator.connect(22)
+    const initiatorTransport: MsgTransport = await initiator.connect(this.connectTimeoutSecs)
     logger.info('... connected, run session')
     await initiatorSession.run(initiatorTransport)
     logger.info('ends')

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

@@ -4,12 +4,12 @@ import { MsgTransport } from '../factory'
 import { IJsFixConfig, IJsFixLogger } from '../../config'
 import { TcpDuplex, FixDuplex } from '../duplex'
 
-import * as util from 'util'
 import { connect as tlsConnect, ConnectionOptions, TLSSocket } from 'tls'
 import { createConnection } from 'net'
 import Timeout = NodeJS.Timeout
 import { TlsOptionsFactory } from './tls-options-factory'
 import { describeConnectionOptions, describeNegotiated, describePeerCertificate } from './tls-diagnostics'
+import { describeConnectError, withConnectReason } from './connect-error'
 import { inject, injectable } from 'tsyringe'
 import { DITokens } from '../../runtime/di-tokens'
 import { ITcpTransportDescription } from './tcp-transport-description'
@@ -28,6 +28,7 @@ export class TcpInitiator extends FixInitiator {
   private readonly logger: IJsFixLogger
   private duplex: FixDuplex
   private th: Timeout | null = null
+  private timeoutTh: Timeout | null = null
 
   constructor (@inject(DITokens.IJsFixConfig) public readonly jsFixConfig: IJsFixConfig) {
     super(jsFixConfig.description.application ?? null)
@@ -73,7 +74,7 @@ export class TcpInitiator extends FixInitiator {
               // connect() whose timeout expires before the first retry interval fires - the
               // default case, timeout and reconnectSeconds are both 5 - reported a generic
               // "timeout whilst connecting" and threw away the reason.  see #94.
-              this.logger.info(`first connect attempt failed: ${first.message}`)
+              this.logger.info(`first connect attempt failed: ${describeConnectError(first)}`)
               this.repeatConnect(timeoutSeconds, first)
                 .then((t: MsgTransport) => { resolve(t) })
                 .catch((e: Error) => { reject(e) })
@@ -189,13 +190,15 @@ export class TcpInitiator extends FixInitiator {
       clearInterval(this.th)
       this.th = null
     }
+    if (this.timeoutTh) {
+      clearTimeout(this.timeoutTh)
+      this.timeoutTh = null
+    }
   }
 
   private async repeatConnect (timeoutSeconds: number, initialError?: Error): Promise < MsgTransport > {
     return await new Promise<MsgTransport>(async (resolve, reject) => {
       const application = this.application
-      const promisify = util.promisify
-      const timeoutPromise = promisify(setTimeout)
       const reconnectSeconds = application?.reconnectSeconds ?? 5
       let retries = 0
       let lastError: Error | undefined = initialError
@@ -209,18 +212,24 @@ export class TcpInitiator extends FixInitiator {
             resolve(t)
           }).catch((e: Error) => {
             lastError = e
-            this.logger.info(`${name}: retries ${retries} ${e.message}`)
+            this.logger.info(`${name}: retries ${retries} ${describeConnectError(e)}`)
           })
       }, reconnectSeconds * 1000)
-      timeoutPromise(timeoutSeconds * 1000).then(() => {
+      // a plain timer, not a promisified one: promisify(setTimeout) hands back no
+      // handle, so this deadline could never be cancelled.  Connecting successfully
+      // cleared the retry interval and left this one running to its full term - up to
+      // the 60s an initiator allows - holding the event loop open long after the
+      // session was up, and stopping a process (or a test runner) from exiting.
+      this.timeoutTh = setTimeout(() => {
         this.clearTimer()
         this.state = InitiatorState.Stopped
-        const e = lastError ?? new Error(`${name}: timeout of ${timeoutSeconds} whilst connecting`)
+        // this error is what the application catches from run() - so give it a message
+        // it can print.  An AggregateError arrives with none at all, which meant a
+        // caller handling a failed connect had nothing to report but an empty string.
+        const e = withConnectReason(lastError ?? new Error(`${name}: timeout of ${timeoutSeconds} whilst connecting`))
         this.logger.warning(`${name}: giving up after ${timeoutSeconds}s and ${retries} retries, last error: ${e.message}`)
         reject(e)
-      }).catch(e => {
-        reject(e)
-      })
+      }, timeoutSeconds * 1000)
     })
   }
 }