quickfix_ruby_ud 2.0.7

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6e5120f1bfc89a75f924b795da1c48e29c526a95b943bbd5e4deb13fc1e78578
+  data.tar.gz: 6da11fd94214a1203ff805a0be13b96557b9a9049a32594c075b00e5e25310fa
+SHA512:
+  metadata.gz: d6f1ae38e1721eb0eb60bec4e06a4523b111717c2856b6075863f34dc892022daae5c440e23c239de118ac4768cc5b446905fe2a6e4b4d1846caf9b7d197c0e4
+  data.tar.gz: '08179d127d0345d881513b9d8a1d2dd0e73d7b45584b675424584b4b7e65b585df01c7ea02b2c1bb24857d4d8df4d2e5d546e4829104145c34f759160c679d4a'

data/ext/quickfix/Acceptor.cpp

@@ -0,0 +1,257 @@
+/****************************************************************************
+** Copyright (c) 2001-2014
+**
+** This file is part of the QuickFIX FIX Engine
+**
+** This file may be distributed under the terms of the quickfixengine.org
+** license as defined by quickfixengine.org and appearing in the file
+** LICENSE included in the packaging of this file.
+**
+** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
+** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+**
+** See http://www.quickfixengine.org/LICENSE for licensing information.
+**
+** Contact ask@quickfixengine.org if any conditions of this licensing are
+** not clear to you.
+**
+****************************************************************************/
+
+#ifdef _MSC_VER
+#include "stdafx.h"
+#else
+#include "config.h"
+#endif
+
+#include "Acceptor.h"
+#include "HttpServer.h"
+#include "Session.h"
+#include "SessionFactory.h"
+#include "Utility.h"
+#include "scope_guard.hpp"
+
+#include <algorithm>
+#include <fstream>
+
+namespace FIX {
+Acceptor::Acceptor(Application &application, MessageStoreFactory &messageStoreFactory, const SessionSettings &settings)
+    EXCEPT(ConfigError)
+    : m_threadid(0),
+      m_application(application),
+      m_messageStoreFactory(messageStoreFactory),
+      m_settings(settings),
+      m_pLogFactory(0),
+      m_pLog(0),
+      m_processing(false),
+      m_firstPoll(true),
+      m_stop(true) {
+  initialize();
+}
+
+Acceptor::Acceptor(
+    Application &application,
+    MessageStoreFactory &messageStoreFactory,
+    const SessionSettings &settings,
+    LogFactory &logFactory) EXCEPT(ConfigError)
+    : m_threadid(0),
+      m_application(application),
+      m_messageStoreFactory(messageStoreFactory),
+      m_settings(settings),
+      m_pLogFactory(&logFactory),
+      m_pLog(logFactory.create()),
+      m_processing(false),
+      m_firstPoll(true),
+      m_stop(true) {
+  initialize();
+}
+
+void Acceptor::initialize() EXCEPT(ConfigError) {
+  std::set<SessionID> sessions = m_settings.getSessions();
+  std::set<SessionID>::iterator i;
+
+  if (!sessions.size()) {
+    throw ConfigError("No sessions defined");
+  }
+
+  SessionFactory factory(m_application, m_messageStoreFactory, m_pLogFactory);
+
+  for (i = sessions.begin(); i != sessions.end(); ++i) {
+    if (m_settings.get(*i).getString(CONNECTION_TYPE) == "acceptor") {
+      m_sessionIDs.insert(*i);
+      m_sessions[*i] = factory.create(*i, m_settings.get(*i));
+    }
+  }
+
+  if (!m_sessions.size()) {
+    throw ConfigError("No sessions defined for acceptor");
+  }
+}
+
+Acceptor::~Acceptor() {
+  Sessions::iterator i;
+  for (i = m_sessions.begin(); i != m_sessions.end(); ++i) {
+    delete i->second;
+  }
+
+  if (m_pLogFactory && m_pLog) {
+    m_pLogFactory->destroy(m_pLog);
+  }
+}
+
+Session *Acceptor::getSession(const std::string &msg, Responder &responder) {
+  Message message;
+  if (!message.setStringHeader(msg)) {
+    return 0;
+  }
+
+  try {
+    auto const &beginString = message.getHeader().getField<BeginString>();
+    auto const &clSenderCompID = message.getHeader().getField<SenderCompID>();
+    auto const &clTargetCompID = message.getHeader().getField<TargetCompID>();
+    auto const &msgType = message.getHeader().getField<MsgType>();
+    if (msgType != MsgType_Logon) {
+      return 0;
+    }
+
+    SenderCompID senderCompID(clTargetCompID);
+    TargetCompID targetCompID(clSenderCompID);
+    SessionID sessionID(beginString, senderCompID, targetCompID);
+
+    Sessions::iterator i = m_sessions.find(sessionID);
+    if (i != m_sessions.end()) {
+      i->second->setResponder(&responder);
+      return i->second;
+    }
+  } catch (FieldNotFound &) {}
+  return 0;
+}
+
+Session *Acceptor::getSession(const SessionID &sessionID) const {
+  Sessions::const_iterator i = m_sessions.find(sessionID);
+  if (i != m_sessions.end()) {
+    return i->second;
+  } else {
+    return 0;
+  }
+}
+
+const Dictionary *const Acceptor::getSessionSettings(const SessionID &sessionID) const {
+  try {
+    return &m_settings.get(sessionID);
+  } catch (ConfigError &) {
+    return 0;
+  }
+}
+
+void Acceptor::start() EXCEPT(ConfigError, RuntimeError) {
+  if (m_processing) {
+    throw RuntimeError("Acceptor::start called when already processing messages");
+  }
+
+  m_processing = true;
+  m_stop = false;
+
+  try {
+    onConfigure(m_settings);
+    onInitialize(m_settings);
+
+    HttpServer::startGlobal(m_settings);
+  } catch (...) {
+    m_processing = false;
+    throw;
+  }
+
+  if (!thread_spawn(&startThread, this, m_threadid)) {
+    m_processing = false;
+    throw RuntimeError("Unable to spawn thread");
+  }
+}
+
+void Acceptor::block() EXCEPT(ConfigError, RuntimeError) {
+  if (m_processing) {
+    throw RuntimeError("Acceptor::block called when already processing messages");
+  }
+
+  m_processing = true;
+  m_stop = false;
+  onConfigure(m_settings);
+  onInitialize(m_settings);
+
+  startThread(this);
+}
+
+bool Acceptor::poll() EXCEPT(ConfigError, RuntimeError) {
+  if (m_processing) {
+    throw RuntimeError("Acceptor::poll called when already processing messages");
+  }
+
+  {
+    auto guard = sg::make_scope_guard([this]() { m_processing = false; });
+
+    m_processing = true;
+    if (m_firstPoll) {
+      m_stop = false;
+      onConfigure(m_settings);
+      onInitialize(m_settings);
+      m_firstPoll = false;
+    }
+  }
+
+  return onPoll();
+}
+
+void Acceptor::stop(bool force) {
+  if (isStopped()) {
+    return;
+  }
+
+  HttpServer::stopGlobal();
+
+  std::vector<Session *> enabledSessions;
+
+  Sessions sessions = m_sessions;
+  Sessions::iterator i = sessions.begin();
+  for (; i != sessions.end(); ++i) {
+    Session *pSession = Session::lookupSession(i->first);
+    if (pSession && pSession->isEnabled()) {
+      enabledSessions.push_back(pSession);
+      pSession->logout();
+      Session::unregisterSession(pSession->getSessionID());
+    }
+  }
+
+  if (!force) {
+    for (int second = 1; second <= 10 && isLoggedOn(); ++second) {
+      process_sleep(1);
+    }
+  }
+
+  m_stop = true;
+  onStop();
+  if (m_threadid) {
+    thread_join(m_threadid);
+  }
+  m_threadid = 0;
+
+  for (Session *session : enabledSessions) {
+    session->logon();
+  }
+}
+
+bool Acceptor::isLoggedOn() const {
+  Sessions sessions = m_sessions;
+  for (Sessions::value_type const &sessionIDWithSession : sessions) {
+    if (sessionIDWithSession.second->isLoggedOn()) {
+      return true;
+    }
+  }
+  return false;
+}
+
+THREAD_PROC Acceptor::startThread(void *p) {
+  Acceptor *pAcceptor = static_cast<Acceptor *>(p);
+  auto guard = sg::make_scope_guard([pAcceptor]() { pAcceptor->m_processing = false; });
+  pAcceptor->onStart();
+  return 0;
+}
+} // namespace FIX

data/ext/quickfix/Acceptor.h

@@ -0,0 +1,127 @@
+/* -*- C++ -*- */
+
+/****************************************************************************
+** Copyright (c) 2001-2014
+**
+** This file is part of the QuickFIX FIX Engine
+**
+** This file may be distributed under the terms of the quickfixengine.org
+** license as defined by quickfixengine.org and appearing in the file
+** LICENSE included in the packaging of this file.
+**
+** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
+** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+**
+** See http://www.quickfixengine.org/LICENSE for licensing information.
+**
+** Contact ask@quickfixengine.org if any conditions of this licensing are
+** not clear to you.
+**
+****************************************************************************/
+
+#ifndef FIX_ACCEPTOR_H
+#define FIX_ACCEPTOR_H
+
+#ifdef _MSC_VER
+#pragma warning(disable : 4503 4355 4786 4290)
+#endif
+
+#include "Application.h"
+#include "Exceptions.h"
+#include "Log.h"
+#include "MessageStore.h"
+#include "Responder.h"
+#include "SessionSettings.h"
+#include <map>
+#include <string>
+
+namespace FIX {
+class Client;
+class Session;
+
+/**
+ * Base for classes which act as an acceptor for incoming connections.
+ *
+ * Most users will not need to implement one of these.  The default
+ * SocketAcceptor implementation will be used in most cases.
+ */
+class Acceptor {
+public:
+  Acceptor(Application &, MessageStoreFactory &, const SessionSettings &) EXCEPT(ConfigError);
+  Acceptor(Application &, MessageStoreFactory &, const SessionSettings &, LogFactory &) EXCEPT(ConfigError);
+
+  virtual ~Acceptor();
+
+  Log *getLog() {
+    if (m_pLog) {
+      return m_pLog;
+    }
+    return &m_nullLog;
+  }
+
+  /// Start acceptor.
+  void start() EXCEPT(ConfigError, RuntimeError);
+  /// Block on the acceptor
+  void block() EXCEPT(ConfigError, RuntimeError);
+  /// Poll the acceptor
+  bool poll() EXCEPT(ConfigError, RuntimeError);
+
+  /// Stop acceptor.
+  void stop(bool force = false);
+
+  /// Check to see if any sessions are currently logged on
+  bool isLoggedOn() const;
+
+  Session *getSession(const std::string &msg, Responder &);
+
+  const std::set<SessionID> &getSessions() const { return m_sessionIDs; }
+  Session *getSession(const SessionID &sessionID) const;
+  const Dictionary *const getSessionSettings(const SessionID &sessionID) const;
+
+  bool has(const SessionID &id) const { return m_sessions.find(id) != m_sessions.end(); }
+
+  bool isStopped() const { return m_stop; }
+
+  Application &getApplication() const { return m_application; }
+  MessageStoreFactory &getMessageStoreFactory() const { return m_messageStoreFactory; }
+
+private:
+  void initialize() EXCEPT(ConfigError);
+
+  /// Implemented to configure acceptor
+  virtual void onConfigure(const SessionSettings &) EXCEPT(ConfigError) {};
+  /// Implemented to initialize acceptor
+  virtual void onInitialize(const SessionSettings &) EXCEPT(RuntimeError) {};
+  /// Implemented to start listening for connections.
+  virtual void onStart() = 0;
+  /// Implemented to connect and poll for events.
+  virtual bool onPoll() = 0;
+  /// Implemented to stop a running acceptor.
+  virtual void onStop() = 0;
+
+  static THREAD_PROC startThread(void *p);
+
+  typedef std::set<SessionID> SessionIDs;
+  typedef std::map<SessionID, Session *> Sessions;
+
+  thread_id m_threadid;
+  Sessions m_sessions;
+  SessionIDs m_sessionIDs;
+  Application &m_application;
+  MessageStoreFactory &m_messageStoreFactory;
+
+protected:
+  SessionSettings m_settings;
+
+private:
+  LogFactory *m_pLogFactory;
+  Log *m_pLog;
+  NullLog m_nullLog;
+  std::atomic<bool> m_processing;
+  std::atomic<bool> m_firstPoll;
+  std::atomic<bool> m_stop;
+};
+/*! @} */
+} // namespace FIX
+
+#endif // FIX_ACCEPTOR_H

data/ext/quickfix/Allocator.h

@@ -0,0 +1,9 @@
+/* #undef ENABLE_BITMAP_ALLOCATOR */
+/* #undef ENABLE_BOOST_FAST_POOL_ALLOCATOR */
+/* #undef ENABLE_BOOST_POOL_ALLOCATOR */
+/* #undef ENABLE_DEBUG_ALLOCATOR */
+/* #undef ENABLE_MT_ALLOCATOR */
+/* #undef ENABLE_NEW_ALLOCATOR */
+/* #undef ENABLE_POOL_ALLOCATOR */
+/* #undef ENABLE_TBB_ALLOCATOR */
+/* #undef HAVE_ALLOCATOR_CONFIG */

data/ext/quickfix/Application.h

@@ -0,0 +1,137 @@
+/* -*- C++ -*- */
+
+/****************************************************************************
+** Copyright (c) 2001-2014
+**
+** This file is part of the QuickFIX FIX Engine
+**
+** This file may be distributed under the terms of the quickfixengine.org
+** license as defined by quickfixengine.org and appearing in the file
+** LICENSE included in the packaging of this file.
+**
+** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
+** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+**
+** See http://www.quickfixengine.org/LICENSE for licensing information.
+**
+** Contact ask@quickfixengine.org if any conditions of this licensing are
+** not clear to you.
+**
+****************************************************************************/
+
+#ifndef FIX_APPLICATION_H
+#define FIX_APPLICATION_H
+
+#include "Message.h"
+#include "Mutex.h"
+#include "SessionID.h"
+
+namespace FIX {
+/**
+ * This interface must be implemented to define what your %FIX application
+ * does.
+ *
+ * These methods notify your application about events that happen on
+ * active %FIX sessions. There is no guarantee how many threads will be calling
+ * these functions. If the application is sharing resources among multiple sessions,
+ * you must synchronize those resources. You can also use the SynchronizedApplication
+ * class to automatically synchronize all function calls into your application.
+ * The various MessageCracker classes can be used to parse the generic message
+ * structure into specific %FIX messages.
+ */
+class Application {
+public:
+  virtual ~Application() {};
+  /// Notification of a session begin created
+  virtual void onCreate(const SessionID &) = 0;
+  /// Notification of a session successfully logging on
+  virtual void onLogon(const SessionID &) = 0;
+  /// Notification of a session logging off or disconnecting
+  virtual void onLogout(const SessionID &) = 0;
+  /// Notification of admin message being sent to target
+  virtual void toAdmin(Message &, const SessionID &) = 0;
+  /// Notification of app message being sent to target
+  virtual void toApp(Message &, const SessionID &) EXCEPT(DoNotSend) = 0;
+  /// Notification of admin message being received from target
+  virtual void fromAdmin(const Message &, const SessionID &)
+      EXCEPT(FieldNotFound, IncorrectDataFormat, IncorrectTagValue, RejectLogon)
+      = 0;
+  /// Notification of app message being received from target
+  virtual void fromApp(const Message &, const SessionID &)
+      EXCEPT(FieldNotFound, IncorrectDataFormat, IncorrectTagValue, UnsupportedMessageType)
+      = 0;
+};
+
+/**
+ * This is a special implementation of the Application interface that takes
+ * in another Application interface and synchronizes all of its callbacks. This
+ * will guarantee that only one thread will access the applications code at a time.
+ *
+ * This class is a great convenience for writing applications where you
+ * don't want to worry about synchronization. There is of course a tradeoff
+ * in that you may be synchronizing more than you need to. There is also a very
+ * minor performance penalty due to the extra virtual table lookup.
+ */
+class SynchronizedApplication : public Application {
+public:
+  SynchronizedApplication(Application &app)
+      : m_app(app) {}
+
+  void onCreate(const SessionID &sessionID) {
+    Locker l(m_mutex);
+    app().onCreate(sessionID);
+  }
+  void onLogon(const SessionID &sessionID) {
+    Locker l(m_mutex);
+    app().onLogon(sessionID);
+  }
+  void onLogout(const SessionID &sessionID) {
+    Locker l(m_mutex);
+    app().onLogout(sessionID);
+  }
+  void toAdmin(Message &message, const SessionID &sessionID) {
+    Locker l(m_mutex);
+    app().toAdmin(message, sessionID);
+  }
+  void toApp(Message &message, const SessionID &sessionID) EXCEPT(DoNotSend) {
+    Locker l(m_mutex);
+    app().toApp(message, sessionID);
+  }
+  void fromAdmin(const Message &message, const SessionID &sessionID)
+      EXCEPT(FieldNotFound, IncorrectDataFormat, IncorrectTagValue, RejectLogon) {
+    Locker l(m_mutex);
+    app().fromAdmin(message, sessionID);
+  }
+  void fromApp(const Message &message, const SessionID &sessionID)
+      EXCEPT(FieldNotFound, IncorrectDataFormat, IncorrectTagValue, UnsupportedMessageType) {
+    Locker l(m_mutex);
+    app().fromApp(message, sessionID);
+  }
+
+  Mutex m_mutex;
+
+  Application &app() { return m_app; }
+  Application &m_app;
+};
+
+/**
+ * An empty implementation of an Application. This can be used if you
+ * do not want to provide an implementation for all the callback methods.
+ * It is also useful for unit tests where the callback
+ * values of some or all methods are not of interest.
+ */
+class NullApplication : public Application {
+  void onCreate(const SessionID &) {}
+  void onLogon(const SessionID &) {}
+  void onLogout(const SessionID &) {}
+  void toAdmin(Message &, const SessionID &) {}
+  void toApp(Message &, const SessionID &) EXCEPT(DoNotSend) {}
+  void fromAdmin(const Message &, const SessionID &)
+      EXCEPT(FieldNotFound, IncorrectDataFormat, IncorrectTagValue, RejectLogon) {}
+  void fromApp(const Message &, const SessionID &)
+      EXCEPT(FieldNotFound, IncorrectDataFormat, IncorrectTagValue, UnsupportedMessageType) {}
+};
+/*! @} */
+} // namespace FIX
+
+#endif // FIX_APPLICATION_H

data/ext/quickfix/DOMDocument.h

@@ -0,0 +1,70 @@
+/* -*- C++ -*- */
+
+/****************************************************************************
+** Copyright (c) 2001-2014
+**
+** This file is part of the QuickFIX FIX Engine
+**
+** This file may be distributed under the terms of the quickfixengine.org
+** license as defined by quickfixengine.org and appearing in the file
+** LICENSE included in the packaging of this file.
+**
+** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
+** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+**
+** See http://www.quickfixengine.org/LICENSE for licensing information.
+**
+** Contact ask@quickfixengine.org if any conditions of this licensing are
+** not clear to you.
+**
+****************************************************************************/
+
+#ifndef FIX_DOMDOCUMENT_H
+#define FIX_DOMDOCUMENT_H
+
+#include <iostream>
+#include <map>
+#include <memory>
+#include <string>
+
+namespace FIX {
+/// Interface that represents attribute from underlying XML parser.
+class DOMAttributes {
+public:
+  typedef std::map<std::string, std::string> map;
+
+  virtual ~DOMAttributes() {}
+
+  virtual bool get(const std::string &, std::string &) = 0;
+  virtual map toMap() = 0;
+};
+typedef std::unique_ptr<DOMAttributes> DOMAttributesPtr;
+
+/// Interface that represents node from underlying XML parser.
+class DOMNode {
+public:
+  virtual ~DOMNode() {}
+
+  virtual std::unique_ptr<DOMNode> getFirstChildNode() = 0;
+  virtual std::unique_ptr<DOMNode> getNextSiblingNode() = 0;
+  virtual std::unique_ptr<DOMAttributes> getAttributes() = 0;
+  virtual std::string getName() = 0;
+  virtual std::string getText() = 0;
+};
+typedef std::unique_ptr<DOMNode> DOMNodePtr;
+
+/// Interface that represents document of underlying XML parser.
+class DOMDocument {
+public:
+  virtual ~DOMDocument() {}
+
+  virtual bool load(std::istream &) = 0;
+  virtual bool load(const std::string &) = 0;
+  virtual bool xml(std::ostream &) = 0;
+
+  virtual std::unique_ptr<DOMNode> getNode(const std::string &) = 0;
+};
+typedef std::unique_ptr<DOMDocument> DOMDocumentPtr;
+} // namespace FIX
+
+#endif