@homaiohq/napi-quickfix 0.1.0 → 0.3.0

package/cpp/engine_common.h

@@ -1,10 +1,74 @@
 #ifndef NAPI_QUICKFIX_ENGINE_COMMON_H
 #define NAPI_QUICKFIX_ENGINE_COMMON_H
 
+#include <memory>
+#include <set>
+#include <string>
+#include <utility>
+
+#include "quickfix/Exceptions.h"
 #include "quickfix/Log.h"
+#include "quickfix/Session.h"
+#include "quickfix/SessionID.h"
+#include "quickfix/SessionSettings.h"
 
 namespace napi_quickfix {
 
+// Throw ConfigError("Duplicate Session ...") if any [SESSION] of `settings`
+// that an engine of `connectionType` ("initiator" / "acceptor") would create
+// already has a live FIX::Session in this process. QuickFIX only rejects
+// duplicates within ONE settings object (SessionSettings::set); across engines
+// its Session constructor ignores addSession()'s result, so a second engine
+// would silently shadow the first in the process-wide registry that
+// lookupSession()/sendToTarget() read, and the per-engine SessionOpGate
+// registry would couple operations with the wrong engine. Call it on the JS
+// thread right before constructing the engine: engines are only created and
+// destroyed on that thread, so the check cannot race another engine.
+inline void RejectDuplicateSessions(const FIX::SessionSettings& settings,
+                                    const std::string& connectionType) {
+  for (const FIX::SessionID& id : settings.getSessions()) {
+    const FIX::Dictionary& dict = settings.get(id);
+    // Sessions of the other type are skipped by the engine (and a missing
+    // ConnectionType is its own ConfigError, raised by the engine itself).
+    if (!dict.has("ConnectionType") ||
+        dict.getString("ConnectionType") != connectionType) {
+      continue;
+    }
+    if (FIX::Session::doesSessionExist(id)) {
+      throw FIX::ConfigError("Duplicate Session " + id.toString());
+    }
+  }
+}
+
+// Delete the FIX::Session objects a FAILED engine constructor left behind.
+// FIX::Initiator/Acceptor::initialize() creates one FIX::Session per [SESSION]
+// of its connection type, registering each in the process-wide registry, and
+// if a later [SESSION] throws ConfigError the constructor unwinds WITHOUT the
+// engine destructor that would delete them: they stay registered with no
+// owner, so lookupSession() keeps resolving them and every later engine with
+// one of those ids is rejected as a duplicate for the rest of the process.
+// Call it right after the engine constructor threw, on the JS thread, with
+// the same `settings`/`connectionType` RejectDuplicateSessions() was called
+// with just before: that check guarantees every session of ours that exists
+// now was created by the failed constructor, and each one is fully
+// constructed: the only callback FIX::Session's constructor makes after
+// registering itself is onCreate, which the bridge dispatches fire-and-forget
+// (a throwing JS handler never unwinds the constructor). ~Session unregisters
+// it and destroys its store/log through the factories the wrap still owns
+// (public virtual destructor; the engine destructor does exactly this
+// `delete`).
+inline void DestroyOrphanedSessions(const FIX::SessionSettings& settings,
+                                    const std::string& connectionType) {
+  for (const FIX::SessionID& id : settings.getSessions()) {
+    const FIX::Dictionary& dict = settings.get(id);
+    if (!dict.has("ConnectionType") ||
+        dict.getString("ConnectionType") != connectionType) {
+      continue;
+    }
+    delete FIX::Session::lookupSession(id);  // nullptr-safe
+  }
+}
+
 // A LogFactory that produces no-op NullLog instances, for log:'none'. QuickFIX
 // ships NullLog but no public NullLogFactory, so we provide one.
 class NullLogFactory : public FIX::LogFactory {
@@ -14,6 +78,50 @@ class NullLogFactory : public FIX::LogFactory {
   void destroy(FIX::Log* log) override { delete log; }
 };
 
+// The wrap's LogFactory: forwards to the real one (File/Screen/Null) and
+// remembers the ENGINE-level Log that FIX::Initiator/Acceptor's constructor
+// requests with create() -- no SessionID -- before it runs initialize(). When
+// initialize() throws ConfigError the constructor unwinds without the engine
+// destructor that would hand that Log back (`m_pLogFactory->destroy(m_pLog)`),
+// and QuickFIX's own factories do not reclaim it either (~FileLogFactory does
+// not delete its m_globalLog): with log:'file' every failed construction left
+// two open streams behind. The wrap calls DestroyOrphanedEngineLog() next to
+// DestroyOrphanedSessions() when the engine constructor threw. The engine
+// keeps a raw pointer to its LogFactory for its whole life (per-session logs,
+// and the destroy() in its destructor), so this object must outlive it: it is
+// the wrap's logFactory_ member, declared before the engine.
+class TrackingLogFactory : public FIX::LogFactory {
+ public:
+  explicit TrackingLogFactory(std::unique_ptr<FIX::LogFactory> inner)
+      : inner_(std::move(inner)) {}
+
+  FIX::Log* create() override {
+    FIX::Log* log = inner_->create();  // may throw: nothing recorded then
+    engineLog_ = log;
+    return log;
+  }
+  FIX::Log* create(const FIX::SessionID& id) override {
+    return inner_->create(id);
+  }
+  void destroy(FIX::Log* log) override {
+    if (log == engineLog_) engineLog_ = nullptr;
+    inner_->destroy(log);
+  }
+
+  // Destroy the engine-level Log if the engine constructor requested one and
+  // then threw, so no engine will ever destroy() it. No-op otherwise.
+  void DestroyOrphanedEngineLog() {
+    if (engineLog_ == nullptr) return;
+    FIX::Log* log = engineLog_;
+    engineLog_ = nullptr;
+    inner_->destroy(log);
+  }
+
+ private:
+  std::unique_ptr<FIX::LogFactory> inner_;
+  FIX::Log* engineLog_ = nullptr;
+};
+
 }  // namespace napi_quickfix
 
 #endif  // NAPI_QUICKFIX_ENGINE_COMMON_H

package/cpp/engine_workers.h

@@ -3,15 +3,43 @@
 
 #include <napi.h>
 
+#include <condition_variable>
 #include <functional>
+#include <memory>
+#include <mutex>
 #include <utility>
 
 #include "errors.h"
 
 namespace napi_quickfix {
 
+// One-shot completion signal from a libuv worker to the JS thread. The stop
+// worker signals it once its operation (FIX stop() + gate freeze) has
+// returned, success or not; the wrap's Teardown() waits on it rather than
+// destroying the engine under an operation that may still be running it.
+class StopCompletion {
+ public:
+  void Signal() {
+    {
+      std::lock_guard<std::mutex> lock(mtx_);
+      done_ = true;
+    }
+    cv_.notify_all();
+  }
+  void Wait() {
+    std::unique_lock<std::mutex> lock(mtx_);
+    cv_.wait(lock, [this] { return done_; });
+  }
+
+ private:
+  std::mutex mtx_;
+  std::condition_variable cv_;
+  bool done_ = false;
+};
+
 // A generic AsyncWorker that runs a blocking QuickFIX engine operation
 // (start/stop) on a libuv worker thread and resolves/rejects a JS Promise.
+// (The per-message SendToTargetWorker lives in session_static.cpp.)
 //
 // Why off-thread: start()/stop() synchronously invoke FIX::Application callbacks
 // (toAdmin/toApp during send-on-logon, onLogout during stop) which the
@@ -22,12 +50,61 @@ namespace napi_quickfix {
 //
 // Lifetime: the worker holds a Napi::ObjectReference to the owning wrap object so
 // it (and its bridge / engine / factories) can't be GC'd while the op is in
-// flight. The ref is released in OnOK/OnError (both run on the JS thread).
+// flight. The reference is released when the promise is settled -- through
+// the Settlement handed to onSettled, which the wrap may settle later than
+// OnOK (on the JS thread) when the promise has to wait for deferred work,
+// e.g. an engine destruction queued behind the bridge's pending callbacks.
 class EngineOpWorker : public Napi::AsyncWorker {
  public:
-  // onSettled receives `true` if the op succeeded, `false` if it threw.
+  // The promise plus the owner reference, moved out of the worker (which
+  // deletes itself once OnOK/OnError returns) so settling can outlive it.
+  class Settlement {
+   public:
+    Settlement(Napi::Promise::Deferred deferred, Napi::ObjectReference ownerRef,
+               CapturedError err)
+        : deferred_(std::move(deferred)),
+          ownerRef_(std::move(ownerRef)),
+          err_(std::move(err)) {}
+
+    // Resolve, or reject with the error the op threw, and release the owner
+    // reference. JS thread only; idempotent.
+    void Settle() {
+      if (done_) return;
+      done_ = true;
+      Napi::Env env = deferred_.Env();
+      Napi::HandleScope scope(env);
+      if (err_.has) {
+        deferred_.Reject(err_.ToError(env).Value());
+      } else {
+        deferred_.Resolve(env.Undefined());
+      }
+      ownerRef_.Reset();
+    }
+
+    // The environment is going away before the promise could be settled:
+    // leave the promise pending and the reference to the environment's own
+    // cleanup, touching nothing that may already be torn down.
+    void Abandon() {
+      if (done_) return;
+      done_ = true;
+      ownerRef_.SuppressDestruct();
+    }
+
+   private:
+    Napi::Promise::Deferred deferred_;
+    Napi::ObjectReference ownerRef_;
+    CapturedError err_;
+    bool done_ = false;
+  };
+
+  // onSettled(ok, settlement) runs on the JS thread once op() has returned
+  // (ok) or thrown (!ok). It must eventually Settle() (or Abandon()) the
+  // settlement -- right away, or later on the JS thread.
+  using OnSettled =
+      std::function<void(bool, const std::shared_ptr<Settlement>&)>;
+
   EngineOpWorker(Napi::Env env, Napi::Object owner, std::function<void()> op,
-                 std::function<void(bool)> onSettled)
+                 OnSettled onSettled)
       : Napi::AsyncWorker(env),
         deferred_(Napi::Promise::Deferred::New(env)),
         op_(std::move(op)),
@@ -52,32 +129,36 @@ class EngineOpWorker : public Napi::AsyncWorker {
 
   // Runs on the JS thread.
   void OnOK() override {
-    Napi::Env env = Env();
-    Napi::HandleScope scope(env);
-    if (onSettled_) onSettled_(!err_.has);
-    if (err_.has) {
-      deferred_.Reject(err_.ToError(env).Value());
-    } else {
-      deferred_.Resolve(env.Undefined());
-    }
-    ownerRef_.Reset();
+    Napi::HandleScope scope(Env());
+    Dispatch();
   }
 
   // Runs on the JS thread (only if AsyncWorker::SetError was used; we don't, so
   // errors flow through OnOK — but provide OnError for completeness/safety).
   void OnError(const Napi::Error& e) override {
-    Napi::Env env = Env();
-    Napi::HandleScope scope(env);
-    if (onSettled_) onSettled_(false);
-    deferred_.Reject(e.Value());
-    ownerRef_.Reset();
+    Napi::HandleScope scope(Env());
+    err_.has = true;
+    err_.message = e.Message();
+    err_.fixErrorName = "Error";
+    Dispatch();
   }
 
  private:
+  void Dispatch() {
+    const bool ok = !err_.has;
+    auto settlement = std::make_shared<Settlement>(
+        std::move(deferred_), std::move(ownerRef_), std::move(err_));
+    if (onSettled_) {
+      onSettled_(ok, settlement);
+    } else {
+      settlement->Settle();
+    }
+  }
+
   Napi::Promise::Deferred deferred_;
   Napi::ObjectReference ownerRef_;
   std::function<void()> op_;
-  std::function<void(bool)> onSettled_;
+  OnSettled onSettled_;
   CapturedError err_;
 };