jspurefix 5.10.5 → 5.11.0

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/session/fix-session.ts

@@ -631,11 +631,21 @@ export abstract class FixSession extends events.EventEmitter {
    */
   protected abstract onStopped (error?: Error): void
   /**
-   * Placeholder infomring the application of a peer login attempt.
+   * Inform the application of a peer login attempt and ask it to accept or reject.
+   *
+   * Return true to let the session continue.  Return false to refuse the peer: a
+   * Logout carrying a Text reason is sent and the transport is dropped, so onReady
+   * is never reached and no heartbeat is started.
+   *
+   * The verdict may be returned as a promise, for applications that must check the
+   * credentials against an async source such as an http api or a database.  While
+   * that promise is pending the transport is paused and any message the peer sends
+   * is queued, then replayed in order once the verdict arrives.
+   *
    * @param view the login message
    * @param user extracted user from message
    * @param password extracted password from the message.
    * @protected
    */
-  protected abstract onLogon (view: MsgView, user: string, password: string): boolean
+  protected abstract onLogon (view: MsgView, user: string, password: string): boolean | Promise<boolean>
 }

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

@@ -25,8 +25,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 +46,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 +68,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 +125,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,7 +160,7 @@ 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}`)
@@ -135,18 +180,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

@@ -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)
@@ -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
@@ -212,15 +215,18 @@ export class TcpInitiator extends FixInitiator {
             this.logger.info(`${name}: retries ${retries} ${e.message}`)
           })
       }, 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.logger.warning(`${name}: giving up after ${timeoutSeconds}s and ${retries} retries, last error: ${e.message}`)
         reject(e)
-      }).catch(e => {
-        reject(e)
-      })
+      }, timeoutSeconds * 1000)
     })
   }
 }