@homaiohq/napi-quickfix 0.0.0-stage → 0.2.0

package/cpp/session_op_gate.h

@@ -0,0 +1,201 @@
+#ifndef NAPI_QUICKFIX_SESSION_OP_GATE_H
+#define NAPI_QUICKFIX_SESSION_OP_GATE_H
+
+#include <condition_variable>
+#include <map>
+#include <memory>
+#include <mutex>
+#include <set>
+#include <utility>
+
+#include "quickfix/SessionID.h"
+
+namespace napi_quickfix {
+
+// Per-engine gate between the libuv-thread session operations
+// (SendToTargetWorker, session_static.cpp) and the destruction of the engine
+// that owns the sessions they operate on.
+//
+// Why: FIX::Session::lookupSession() hands out a raw, non-owning pointer into
+// an engine-owned object, and nothing in QuickFIX keeps that session alive
+// while the caller uses it. The engine wraps destroy their FIX engine (which
+// deletes every FIX::Session) as soon as stop() settles, so without this gate
+// a `sendToTarget()` still running on one libuv thread while `engine.stop()`
+// completes would be a use-after-free.
+//
+// Why per engine (not process-wide): the gate must only ever couple an
+// operation with the engine that owns its session. A process-wide gate made
+// `A.stop()` wait for B's in-flight operations, and -- worse -- made the wrap
+// destructor, which runs on the JS thread at GC, wait for an operation of
+// ANOTHER engine that may itself be blocked in a BlockingCall that only the JS
+// thread can service: a hard deadlock. With one gate per engine, the
+// destructor only waits for operations on its own sessions, and Teardown()
+// has already deactivated this engine's bridge and joined its network threads
+// by then, so none of those can be waiting on the JS thread.
+//
+// Protocol:
+//   * Each engine wrap owns a `std::shared_ptr<SessionOpGate>` and registers
+//     it for its SessionIDs (Register) right after constructing the FIX engine,
+//     on the JS thread; it unregisters (Unregister) right before destroying it.
+//   * The JS-thread entry point of a session operation (SendToTarget) looks
+//     the gate of the engine owning `id` up (Lookup) BEFORE queuing its
+//     worker, so the operation is bound to the engine that owned the session
+//     when it was called: engines register and unregister on the JS thread
+//     only, so that lookup is exact, and an engine registered later for the
+//     same id can never be the one the operation runs on. No registered gate
+//     means no engine owns the session: SessionNotFound, without touching the
+//     registry QuickFIX keeps. The worker then calls Acquire(gate, id) on its
+//     libuv thread to hold an OpScope on that gate for its whole Execute()
+//     -- lookupSession AND the operation. Constructing the OpScope blocks
+//     while that engine is between Freeze() and Unfreeze(); a gate that is no
+//     longer the registered owner once the scope is held is SessionNotFound
+//     too (see below).
+//   * The engine's stop worker calls Freeze() on its libuv thread AFTER the FIX
+//     engine's own stop() has returned: it blocks new operations on this
+//     engine's sessions and waits for the in-flight ones to drain. The wrap
+//     then unregisters and destroys the engine on the JS thread (OnOK) and
+//     calls Unfreeze() -- or, if the engine survives (the stop threw, or the
+//     environment is torn down before a graceful stop's queued destruction
+//     runs), calls Unfreeze() alone so that operations parked meanwhile are
+//     woken rather than left pinning a libuv thread. Because Freeze() waits
+//     on a libuv thread while the JS loop is free, an in-flight operation
+//     blocked in a BlockingCall to JS (sendToTarget() -> toApp) can still
+//     complete.
+//   * The wrap destructor calls Freeze() on the JS thread, but only after
+//     Teardown() has deactivated the bridge (waking every pending BlockingCall
+//     and making later callbacks pass through) and joined the network threads,
+//     so no in-flight operation on THIS engine's sessions can be waiting on the
+//     (now blocked) JS thread. Operations on other engines are not involved.
+//
+// The gate outlives its engine: a worker whose gate was resolved just before
+// the engine was unregistered holds it by shared_ptr and passes the (now
+// lifted) freeze. By then a NEW engine may own the same id -- its sessions are what
+// lookupSession() would now return -- while the worker holds the OLD gate, on
+// which the new engine's stop() never waits. Acquire() closes that window by
+// re-reading the registry after the OpScope is held: the scope is kept only if
+// the gate is still the registered owner, and that owner cannot be destroyed
+// while the scope is in flight (Freeze() precedes Unregister() everywhere).
+// Otherwise the operation is reported as SessionNotFound, never retried
+// against the new owner: it was queued for the engine that is now gone, and a
+// message delivered through another engine's session -- not logged on, so
+// persisted in its store and sent on its first logon -- is exactly the
+// cross-over SessionWrap::Resolve() refuses for Session handles. Together
+// with the wraps rejecting a SessionID that is already live in the process,
+// this makes gate == registered owner == the engine whose session
+// lookupSession() returns.
+class SessionOpGate {
+ public:
+  class OpScope {
+   public:
+    explicit OpScope(std::shared_ptr<SessionOpGate> gate)
+        : gate_(std::move(gate)) {
+      std::unique_lock<std::mutex> lock(gate_->mtx_);
+      gate_->cv_.wait(lock, [this] { return gate_->frozen_ == 0; });
+      ++gate_->inflight_;
+    }
+    ~OpScope() {
+      {
+        std::lock_guard<std::mutex> lock(gate_->mtx_);
+        --gate_->inflight_;
+      }
+      gate_->cv_.notify_all();
+    }
+    OpScope(const OpScope&) = delete;
+    OpScope& operator=(const OpScope&) = delete;
+
+   private:
+    std::shared_ptr<SessionOpGate> gate_;
+  };
+
+  SessionOpGate() = default;
+  SessionOpGate(const SessionOpGate&) = delete;
+  SessionOpGate& operator=(const SessionOpGate&) = delete;
+
+  // Block new operations on this engine's sessions and wait for the in-flight
+  // ones to finish. Nests: the stop worker freezes on its thread and the wrap
+  // unfreezes later on the JS thread, and in between the destructor (if the
+  // wrap is finalized during environment teardown) freezes again around its
+  // own DestroyEngine().
+  void Freeze() {
+    std::unique_lock<std::mutex> lock(mtx_);
+    ++frozen_;
+    cv_.wait(lock, [this] { return inflight_ == 0; });
+  }
+
+  // Let operations run again. Pairs with Freeze().
+  void Unfreeze() {
+    {
+      std::lock_guard<std::mutex> lock(mtx_);
+      --frozen_;
+    }
+    cv_.notify_all();
+  }
+
+  // --- registry: SessionID -> owning engine's gate ---------------------------
+  // Each id maps to at most one gate at a time: the engine wraps refuse to
+  // construct an engine whose SessionID is already live in the process
+  // (ConfigError "Duplicate Session"). QuickFIX itself does NOT enforce that --
+  // its Session constructor ignores addSession()'s result, so a second engine
+  // would silently shadow the first in the process-wide session registry.
+
+  static void Register(const std::set<FIX::SessionID>& ids,
+                       const std::shared_ptr<SessionOpGate>& gate) {
+    Registry& r = GetRegistry();
+    std::lock_guard<std::mutex> lock(r.mtx);
+    for (const FIX::SessionID& id : ids) r.gates[id] = gate;
+  }
+
+  // Remove `ids` only where they still point at `gate`: a new engine may
+  // already have registered the same ids after this one unregistered them.
+  static void Unregister(const std::set<FIX::SessionID>& ids,
+                         const SessionOpGate* gate) {
+    Registry& r = GetRegistry();
+    std::lock_guard<std::mutex> lock(r.mtx);
+    for (const FIX::SessionID& id : ids) {
+      auto it = r.gates.find(id);
+      if (it != r.gates.end() && it->second.get() == gate) r.gates.erase(it);
+    }
+  }
+
+  // The gate of the engine owning `id`, or nullptr if no engine does.
+  static std::shared_ptr<SessionOpGate> Lookup(const FIX::SessionID& id) {
+    Registry& r = GetRegistry();
+    std::lock_guard<std::mutex> lock(r.mtx);
+    auto it = r.gates.find(id);
+    return it == r.gates.end() ? nullptr : it->second;
+  }
+
+  // Hold an OpScope on `gate` -- the registered owner of `id` when the
+  // caller looked it up on the JS thread -- or return nullptr if it no longer
+  // is (-> SessionNotFound). Constructing the scope may block (the owner is
+  // stopping); once it is held the registry is re-read, and the scope is kept
+  // only if the same gate is still registered. Otherwise the owner was
+  // destroyed while we waited -- possibly replaced by a new engine with the
+  // same id -- and the operation is refused (nullptr) rather than run against
+  // the new owner, mirroring SessionWrap::Resolve().
+  static std::unique_ptr<OpScope> Acquire(
+      const std::shared_ptr<SessionOpGate>& gate, const FIX::SessionID& id) {
+    auto scope = std::make_unique<OpScope>(gate);
+    if (Lookup(id) != gate) return nullptr;
+    return scope;
+  }
+
+ private:
+  struct Registry {
+    std::mutex mtx;
+    std::map<FIX::SessionID, std::shared_ptr<SessionOpGate>> gates;
+  };
+  static Registry& GetRegistry() {
+    static Registry registry;
+    return registry;
+  }
+
+  std::mutex mtx_;
+  std::condition_variable cv_;
+  int inflight_ = 0;
+  int frozen_ = 0;
+};
+
+}  // namespace napi_quickfix
+
+#endif  // NAPI_QUICKFIX_SESSION_OP_GATE_H

package/cpp/session_settings_wrap.cpp

@@ -0,0 +1,98 @@
+#include "session_settings_wrap.h"
+
+#include <set>
+#include <sstream>
+#include <string>
+
+#include "errors.h"
+#include "quickfix/SessionID.h"
+#include "session_id_wrap.h"
+
+namespace napi_quickfix {
+
+Napi::FunctionReference SessionSettingsWrap::constructor_;
+
+Napi::Object SessionSettingsWrap::Init(Napi::Env env, Napi::Object exports) {
+  Napi::Function func = DefineClass(
+      env, "SessionSettings",
+      {
+          StaticMethod("fromString", &SessionSettingsWrap::FromString),
+          StaticMethod("fromFile", &SessionSettingsWrap::FromFile),
+          InstanceMethod("getSessions", &SessionSettingsWrap::GetSessions),
+      });
+
+  constructor_ = Napi::Persistent(func);
+  constructor_.SuppressDestruct();
+
+  exports.Set("SessionSettingsWrap", func);
+  return exports;
+}
+
+SessionSettingsWrap* SessionSettingsWrap::UnwrapArg(Napi::Env env,
+                                                 Napi::Value value,
+                                                 const char* argName) {
+  if (!value.IsObject() ||
+      !value.As<Napi::Object>().InstanceOf(constructor_.Value())) {
+    throw Napi::TypeError::New(
+        env, std::string(argName) + " must be a SessionSettings instance");
+  }
+  return Napi::ObjectWrap<SessionSettingsWrap>::Unwrap(
+      value.As<Napi::Object>());
+}
+
+// Constructor is internal: (kind: "string"|"file", payload: string).
+// Users go through the static fromString/fromFile factories.
+SessionSettingsWrap::SessionSettingsWrap(const Napi::CallbackInfo& info)
+    : Napi::ObjectWrap<SessionSettingsWrap>(info) {
+  Napi::Env env = info.Env();
+  if (info.Length() < 2 || !info[0].IsString() || !info[1].IsString()) {
+    throw Napi::TypeError::New(
+        env,
+        "SessionSettings cannot be constructed directly; use "
+        "SessionSettings.fromString() or SessionSettings.fromFile()");
+  }
+  std::string kind = info[0].As<Napi::String>().Utf8Value();
+  std::string payload = info[1].As<Napi::String>().Utf8Value();
+
+  NQ_TRY(env) {
+    if (kind == "string") {
+      std::istringstream stream(payload);
+      settings_ = FIX::SessionSettings(stream);
+    } else {  // "file"
+      settings_ = FIX::SessionSettings(payload);
+    }
+  } NQ_CATCH(env)
+}
+
+Napi::Value SessionSettingsWrap::FromString(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  if (info.Length() < 1 || !info[0].IsString()) {
+    throw Napi::TypeError::New(env, "fromString(text: string)");
+  }
+  return constructor_.New(
+      {Napi::String::New(env, "string"), info[0].As<Napi::String>()});
+}
+
+Napi::Value SessionSettingsWrap::FromFile(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  if (info.Length() < 1 || !info[0].IsString()) {
+    throw Napi::TypeError::New(env, "fromFile(path: string)");
+  }
+  return constructor_.New(
+      {Napi::String::New(env, "file"), info[0].As<Napi::String>()});
+}
+
+Napi::Value SessionSettingsWrap::GetSessions(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  NQ_TRY(env) {
+    std::set<FIX::SessionID> sessions = settings_.getSessions();
+    Napi::Array arr = Napi::Array::New(env, sessions.size());
+    uint32_t i = 0;
+    for (const auto& id : sessions) {
+      arr.Set(i++, SessionIDWrap::NewInstance(env, id));
+    }
+    return arr;
+  } NQ_CATCH(env)
+}
+
+}  // namespace napi_quickfix

package/cpp/session_settings_wrap.h

@@ -0,0 +1,40 @@
+#ifndef NAPI_QUICKFIX_SESSION_SETTINGS_WRAP_H
+#define NAPI_QUICKFIX_SESSION_SETTINGS_WRAP_H
+
+#include <napi.h>
+
+#include "quickfix/SessionSettings.h"
+
+namespace napi_quickfix {
+
+// Napi::ObjectWrap over FIX::SessionSettings.
+//
+//   SessionSettings.fromString(text): SessionSettings
+//   SessionSettings.fromFile(path): SessionSettings
+//   settings.getSessions(): SessionID[]
+class SessionSettingsWrap : public Napi::ObjectWrap<SessionSettingsWrap> {
+ public:
+  static Napi::Object Init(Napi::Env env, Napi::Object exports);
+
+  explicit SessionSettingsWrap(const Napi::CallbackInfo& info);
+
+  FIX::SessionSettings& Settings() { return settings_; }
+  const FIX::SessionSettings& Settings() const { return settings_; }
+
+  static SessionSettingsWrap* UnwrapArg(Napi::Env env, Napi::Value value,
+                                     const char* argName);
+
+ private:
+  static Napi::FunctionReference constructor_;
+
+  static Napi::Value FromString(const Napi::CallbackInfo& info);
+  static Napi::Value FromFile(const Napi::CallbackInfo& info);
+
+  Napi::Value GetSessions(const Napi::CallbackInfo& info);
+
+  FIX::SessionSettings settings_;
+};
+
+}  // namespace napi_quickfix
+
+#endif  // NAPI_QUICKFIX_SESSION_SETTINGS_WRAP_H

package/cpp/session_static.cpp

@@ -0,0 +1,220 @@
+#include <napi.h>
+
+#include <memory>
+#include <set>
+#include <string>
+#include <utility>
+
+#include "errors.h"
+#include "field_map_ops.h"
+#include "message_wrap.h"
+#include "quickfix/Exceptions.h"
+#include "quickfix/Message.h"
+#include "quickfix/Session.h"
+#include "quickfix/SessionID.h"
+#include "session_id_wrap.h"
+#include "session_op_gate.h"
+#include "session_wrap.h"
+
+namespace napi_quickfix {
+
+namespace {
+
+// AsyncWorker for FIX::Session::sendToTarget. Runs OFF the JS main thread so the
+// event loop stays free to service the ApplicationBridge TSFN BlockingCall(s)
+// that toApp/toAdmin trigger during the send. Running on the main thread would
+// deadlock (main blocked in sendToTarget -> toApp -> BlockingCall -> waits for
+// main to run CallJs, which it can't).
+//
+// The FIX::Message (a fieldmap::CloneMessage, nested group entries kept
+// typed) and FIX::SessionID are COPIED on the JS thread before Queue()ing, so
+// Execute() never touches any JS object. toApp may mutate the worker's private
+// copy during send — that's fine, it's QuickFIX's business.
+//
+// Two upstream overloads are supported: by explicit SessionID, or by qualifier
+// (QuickFIX then resolves the session from the message's own header fields:
+// BeginString / SenderCompID / TargetCompID).
+//
+// Session::sendToTarget looks the session up in the process-wide registry and
+// uses the raw pointer, so Execute() runs under the owning engine's
+// SessionOpGate::OpScope to keep that engine alive until the send has returned.
+// That gate is resolved by SendToTarget() on the JS thread, before the worker
+// is queued (for the qualifier form after deriving the SessionID from the
+// message header, exactly as the upstream overload does): the send is thereby
+// bound to the engine that owned the session when it was called, and can
+// never run through an engine registered for the same id afterwards -- not
+// even if it sat in the libuv queue across the owner's stop() and that
+// engine's construction. Execute() only re-checks that the gate is still the
+// owner once the scope is held (see session_op_gate.h).
+class SendToTargetWorker : public Napi::AsyncWorker {
+ public:
+  SendToTargetWorker(Napi::Env env, FIX::Message message, FIX::SessionID id,
+                     std::shared_ptr<SessionOpGate> gate)
+      : Napi::AsyncWorker(env),
+        deferred_(Napi::Promise::Deferred::New(env)),
+        message_(std::move(message)),
+        id_(std::move(id)),
+        gate_(std::move(gate)) {}
+
+  Napi::Promise Promise() { return deferred_.Promise(); }
+
+  // Worker thread. NO Napi/JS access.
+  void Execute() override {
+    try {
+      std::unique_ptr<SessionOpGate::OpScope> inflight =
+          SessionOpGate::Acquire(gate_, id_);
+      if (!inflight) {
+        throw FIX::SessionNotFound(id_.toString());
+      }
+      result_ = FIX::Session::sendToTarget(message_, id_);
+    } catch (const std::exception& e) {
+      err_.Capture(e);
+    } catch (...) {
+      err_.has = true;
+      err_.message = "unknown native error";
+      err_.fixErrorName = "Error";
+    }
+  }
+
+  void OnOK() override {
+    Napi::Env env = Env();
+    Napi::HandleScope scope(env);
+    if (err_.has) {
+      deferred_.Reject(err_.ToError(env).Value());
+    } else {
+      deferred_.Resolve(Napi::Boolean::New(env, result_));
+    }
+  }
+
+  void OnError(const Napi::Error& e) override {
+    Napi::HandleScope scope(Env());
+    deferred_.Reject(e.Value());
+  }
+
+ private:
+  Napi::Promise::Deferred deferred_;
+  FIX::Message message_;
+  FIX::SessionID id_;
+  std::shared_ptr<SessionOpGate> gate_;
+  bool result_ = false;
+  CapturedError err_;
+};
+
+// sendToTarget(message: Message, sessionID: SessionID): Promise<boolean>
+// sendToTarget(message: Message, qualifier?: string): Promise<boolean>
+Napi::Value SendToTarget(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  MessageWrap* msg = MessageWrap::UnwrapArg(env, info[0], "message");
+
+  // Copy the message (and session id) by value on the JS thread so the worker
+  // never touches JS-owned objects.
+  FIX::Message message = fieldmap::CloneMessage(msg->Message());
+  const bool byQualifier = info.Length() < 2 || info[1].IsUndefined() ||
+                           info[1].IsString();
+  FIX::SessionID id;
+  if (!byQualifier) {
+    id = SessionIDWrap::UnwrapArg(env, info[1], "sessionID")->SessionID();
+  }
+
+  // Resolve the owning engine HERE, on the JS thread (see the worker's
+  // comment): a session that no engine owns is refused right away, with the
+  // same error the worker reports when the engine goes away under it.
+  std::shared_ptr<SessionOpGate> gate;
+  try {
+    if (byQualifier) {
+      // Mirrors FIX::Session::sendToTarget(Message&, const std::string&):
+      // a header missing tag 8/49/56 is a SessionNotFound.
+      const std::string qualifier =
+          info[1].IsString() ? info[1].As<Napi::String>().Utf8Value()
+                             : std::string();
+      try {
+        id = message.getSessionID(qualifier);
+      } catch (const FIX::FieldNotFound&) {
+        throw FIX::SessionNotFound();
+      }
+    }
+    gate = SessionOpGate::Lookup(id);
+    if (!gate) {
+      throw FIX::SessionNotFound(id.toString());
+    }
+  } catch (const FIX::Exception& e) {
+    CapturedError err;
+    err.Capture(e);
+    auto deferred = Napi::Promise::Deferred::New(env);
+    deferred.Reject(err.ToError(env).Value());
+    return deferred.Promise();
+  }
+
+  auto* worker = new SendToTargetWorker(env, std::move(message), std::move(id),
+                                        std::move(gate));
+  Napi::Promise promise = worker->Promise();
+  worker->Queue();
+  return promise;
+}
+
+// lookupSession(sessionID: SessionID): Session | undefined
+Napi::Value LookupSession(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  SessionIDWrap* id = SessionIDWrap::UnwrapArg(env, info[0], "sessionID");
+  NQ_TRY(env) {
+    // The gate of the engine owning the id; registered by every wrap
+    // constructor right after it created its sessions, unregistered right
+    // before they are destroyed, so (both on the JS thread) a session that
+    // exists has exactly one. No gate means no session.
+    std::shared_ptr<SessionOpGate> gate = SessionOpGate::Lookup(id->SessionID());
+    if (!gate || !FIX::Session::doesSessionExist(id->SessionID())) {
+      return env.Undefined();
+    }
+    return SessionWrap::NewInstance(env, id->SessionID(), std::move(gate));
+  } NQ_CATCH(env)
+}
+
+// doesSessionExist(sessionID: SessionID): boolean
+Napi::Value DoesSessionExist(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  SessionIDWrap* id = SessionIDWrap::UnwrapArg(env, info[0], "sessionID");
+  NQ_TRY(env) {
+    return Napi::Boolean::New(env,
+                              FIX::Session::doesSessionExist(id->SessionID()));
+  } NQ_CATCH(env)
+}
+
+// getSessions(): SessionID[]  -- every session registered in this process.
+Napi::Value GetSessions(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  NQ_TRY(env) {
+    const std::set<FIX::SessionID> ids = FIX::Session::getSessions();
+    Napi::Array out = Napi::Array::New(env, ids.size());
+    uint32_t i = 0;
+    for (const FIX::SessionID& id : ids) {
+      out.Set(i++, SessionIDWrap::NewInstance(env, id));
+    }
+    return out;
+  } NQ_CATCH(env)
+}
+
+// numSessions(): number
+Napi::Value NumSessions(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  NQ_TRY(env) {
+    return Napi::Number::New(env,
+                             static_cast<double>(FIX::Session::numSessions()));
+  } NQ_CATCH(env)
+}
+
+}  // namespace
+
+void RegisterSessionStatic(Napi::Env env, Napi::Object exports) {
+  exports.Set("sendToTarget",
+              Napi::Function::New(env, SendToTarget, "sendToTarget"));
+  exports.Set("lookupSession",
+              Napi::Function::New(env, LookupSession, "lookupSession"));
+  exports.Set("doesSessionExist",
+              Napi::Function::New(env, DoesSessionExist, "doesSessionExist"));
+  exports.Set("getSessions",
+              Napi::Function::New(env, GetSessions, "getSessions"));
+  exports.Set("numSessions",
+              Napi::Function::New(env, NumSessions, "numSessions"));
+}
+
+}  // namespace napi_quickfix