quickfix_ruby_ud 2.0.7-aarch64-linux

data/ext/quickfix/HttpServer.h

@@ -0,0 +1,76 @@
+/* -*- 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_HTTPSERVER_H
+#define FIX_HTTPSERVER_H
+
+#ifdef _MSC_VER
+#pragma warning(disable : 4503 4355 4786 4290)
+#endif
+
+#include "Exceptions.h"
+#include "Mutex.h"
+#include "SessionSettings.h"
+#include "SocketServer.h"
+
+namespace FIX {
+/// Basic HTTP Server
+class HttpServer : public SocketServer::Strategy {
+public:
+  HttpServer(const SessionSettings &) EXCEPT(ConfigError);
+
+  static void startGlobal(const SessionSettings &) EXCEPT(ConfigError, RuntimeError);
+  static void stopGlobal();
+
+  void start() EXCEPT(ConfigError, RuntimeError);
+  void stop();
+
+private:
+  void onConfigure(const SessionSettings &) EXCEPT(ConfigError);
+  void onInitialize(const SessionSettings &) EXCEPT(RuntimeError);
+
+  void onStart();
+  bool onPoll();
+  void onStop();
+
+  void onConnect(SocketServer &, socket_handle, socket_handle);
+  void onWrite(SocketServer &, socket_handle);
+  bool onData(SocketServer &, socket_handle);
+  void onDisconnect(SocketServer &, socket_handle);
+  void onError(SocketServer &);
+  void onTimeout(SocketServer &);
+
+  static THREAD_PROC startThread(void *p);
+
+  SocketServer *m_pServer;
+  SessionSettings m_settings;
+  thread_id m_threadid;
+  int m_port;
+  bool m_stop;
+
+  static Mutex s_mutex;
+  static int s_count;
+  static HttpServer *s_pServer;
+};
+/*! @} */
+} // namespace FIX
+
+#endif // FIX_HTTPSERVER_H

data/ext/quickfix/Initiator.cpp

@@ -0,0 +1,310 @@
+/****************************************************************************
+** 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 "HttpServer.h"
+#include "Initiator.h"
+#include "Session.h"
+#include "SessionFactory.h"
+#include "Utility.h"
+#include "scope_guard.hpp"
+
+#include <algorithm>
+#include <fstream>
+
+namespace FIX {
+Initiator::Initiator(
+    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();
+}
+
+Initiator::Initiator(
+    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 Initiator::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("ConnectionType") == "initiator") {
+      m_sessionIDs.insert(*i);
+      m_sessions[*i] = factory.create(*i, m_settings.get(*i));
+      setDisconnected(*i);
+    }
+  }
+
+  if (!m_sessions.size()) {
+    throw ConfigError("No sessions defined for initiator");
+  }
+}
+
+Initiator::~Initiator() {
+  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 *Initiator::getSession(const SessionID &sessionID, Responder &responder) {
+  Sessions::iterator i = m_sessions.find(sessionID);
+  if (i != m_sessions.end()) {
+    i->second->setResponder(&responder);
+    return i->second;
+  }
+  return 0;
+}
+
+Session *Initiator::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 Initiator::getSessionSettings(const SessionID &sessionID) const {
+  try {
+    return &m_settings.get(sessionID);
+  } catch (ConfigError &) {
+    return 0;
+  }
+}
+
+void Initiator::connect() {
+  Locker l(m_mutex);
+
+  SessionIDs disconnected = m_disconnected;
+  SessionIDs::iterator i = disconnected.begin();
+  for (; i != disconnected.end(); ++i) {
+    Session *pSession = Session::lookupSession(*i);
+    if (pSession->isEnabled() && pSession->isSessionTime(UtcTimeStamp::now())) {
+      doConnect(*i, m_settings.get(*i));
+    }
+  }
+}
+
+void Initiator::setPending(const SessionID &sessionID) {
+  Locker l(m_mutex);
+
+  m_pending.insert(sessionID);
+  m_connected.erase(sessionID);
+  m_disconnected.erase(sessionID);
+}
+
+void Initiator::setConnected(const SessionID &sessionID) {
+  Locker l(m_mutex);
+
+  m_pending.erase(sessionID);
+  m_connected.insert(sessionID);
+  m_disconnected.erase(sessionID);
+}
+
+void Initiator::setDisconnected(const SessionID &sessionID) {
+  Locker l(m_mutex);
+
+  m_pending.erase(sessionID);
+  m_connected.erase(sessionID);
+  m_disconnected.insert(sessionID);
+}
+
+bool Initiator::isPending(const SessionID &sessionID) const {
+  Locker l(m_mutex);
+  return m_pending.find(sessionID) != m_pending.end();
+}
+
+bool Initiator::isConnected(const SessionID &sessionID) const {
+  Locker l(m_mutex);
+  return m_connected.find(sessionID) != m_connected.end();
+}
+
+bool Initiator::isDisconnected(const SessionID &sessionID) const {
+  Locker l(m_mutex);
+  return m_disconnected.find(sessionID) != m_disconnected.end();
+}
+
+void Initiator::start() EXCEPT(ConfigError, RuntimeError) {
+  if (m_processing) {
+    throw RuntimeError("Initiator::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 Initiator::block() EXCEPT(ConfigError, RuntimeError) {
+  if (m_processing) {
+    throw RuntimeError("Initiator::block called when already processing messages");
+  }
+
+  auto guard = sg::make_scope_guard([this]() { m_processing = false; });
+
+  m_processing = true;
+  m_stop = false;
+
+  onConfigure(m_settings);
+  onInitialize(m_settings);
+
+  startThread(this);
+}
+
+bool Initiator::poll() EXCEPT(ConfigError, RuntimeError) {
+  if (m_processing) {
+    throw RuntimeError("Initiator::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);
+    connect();
+    m_firstPoll = false;
+  }
+
+  return onPoll();
+}
+
+void Initiator::stop(bool force) {
+  if (isStopped()) {
+    return;
+  }
+
+  HttpServer::stopGlobal();
+
+  std::vector<Session *> enabledSessions;
+
+  SessionIDs connected;
+
+  {
+    Locker l(m_mutex);
+    connected = m_connected;
+  }
+
+  SessionIDs::iterator i = connected.begin();
+  for (; i != connected.end(); ++i) {
+    Session *pSession = Session::lookupSession(*i);
+    if (pSession && pSession->isEnabled()) {
+      enabledSessions.push_back(pSession);
+      pSession->logout();
+    }
+  }
+
+  if (!force) {
+    for (int second = 1; second <= 10 && isLoggedOn(); ++second) {
+      process_sleep(1);
+    }
+  }
+
+  {
+    Locker l(m_mutex);
+    for (i = connected.begin(); i != connected.end(); ++i) {
+      setDisconnected(Session::lookupSession(*i)->getSessionID());
+    }
+  }
+
+  m_stop = true;
+  onStop();
+  if (m_threadid) {
+    thread_join(m_threadid);
+  }
+  m_threadid = 0;
+
+  for (Session *session : enabledSessions) {
+    session->logon();
+  }
+}
+
+bool Initiator::isLoggedOn() const {
+  Locker l(m_mutex);
+
+  SessionIDs connected = m_connected;
+  SessionIDs::iterator i = connected.begin();
+  for (; i != connected.end(); ++i) {
+    if (Session::lookupSession(*i)->isLoggedOn()) {
+      return true;
+    }
+  }
+  return false;
+}
+
+THREAD_PROC Initiator::startThread(void *p) {
+  Initiator *pInitiator = static_cast<Initiator *>(p);
+  auto guard = sg::make_scope_guard([pInitiator]() { pInitiator->m_processing = false; });
+  pInitiator->onStart();
+  return 0;
+}
+} // namespace FIX

data/ext/quickfix/Initiator.h

@@ -0,0 +1,151 @@
+/* -*- 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_INITIATOR_H
+#define FIX_INITIATOR_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 "Mutex.h"
+#include "Responder.h"
+#include "Session.h"
+#include "SessionSettings.h"
+
+#include <atomic>
+#include <map>
+#include <set>
+#include <string>
+
+namespace FIX {
+class Client;
+
+/**
+ * Base for classes which act as an initiator for establishing connections.
+ *
+ * Most users will not need to implement one of these.  The default
+ * SocketInitiator implementation will be used in most cases.
+ */
+class Initiator {
+public:
+  Initiator(Application &, MessageStoreFactory &, const SessionSettings &) EXCEPT(ConfigError);
+  Initiator(Application &, MessageStoreFactory &, const SessionSettings &, LogFactory &) EXCEPT(ConfigError);
+
+  virtual ~Initiator();
+
+  /// Start initiator.
+  void start() EXCEPT(ConfigError, RuntimeError);
+  /// Block on the initiator
+  void block() EXCEPT(ConfigError, RuntimeError);
+  /// Poll the initiator
+  bool poll() EXCEPT(ConfigError, RuntimeError);
+
+  /// Stop initiator.
+  void stop(bool force = false);
+
+  /// Check to see if any sessions are currently logged on
+  bool isLoggedOn() const;
+
+  Session *getSession(const SessionID &sessionID, 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; }
+
+public:
+  Application &getApplication() const { return m_application; }
+  MessageStoreFactory &getMessageStoreFactory() const { return m_messageStoreFactory; }
+
+  Log *getLog() {
+    if (m_pLog) {
+      return m_pLog;
+    }
+    return &m_nullLog;
+  }
+
+protected:
+  void setPending(const SessionID &);
+  void setConnected(const SessionID &);
+  void setDisconnected(const SessionID &);
+
+  bool isPending(const SessionID &) const;
+  bool isConnected(const SessionID &) const;
+  bool isDisconnected(const SessionID &) const;
+  void connect();
+
+private:
+  void initialize() EXCEPT(ConfigError);
+
+  /// Implemented to configure acceptor
+  virtual void onConfigure(const SessionSettings &) EXCEPT(ConfigError) {};
+  /// Implemented to initialize initiator
+  virtual void onInitialize(const SessionSettings &) EXCEPT(RuntimeError) {};
+  /// Implemented to start connecting to targets.
+  virtual void onStart() = 0;
+  /// Implemented to connect and poll for events.
+  virtual bool onPoll() = 0;
+  /// Implemented to stop a running initiator.
+  virtual void onStop() = 0;
+  /// Implemented to connect a session to its target.
+  virtual void doConnect(const SessionID &, const Dictionary &) = 0;
+
+  static THREAD_PROC startThread(void *p);
+
+  typedef std::set<SessionID> SessionIDs;
+  typedef std::map<SessionID, int> SessionState;
+  typedef std::map<SessionID, Session *> Sessions;
+
+  Sessions m_sessions;
+  SessionIDs m_sessionIDs;
+  SessionIDs m_pending;
+  SessionIDs m_connected;
+  SessionIDs m_disconnected;
+  SessionState m_sessionState;
+
+  thread_id m_threadid;
+  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;
+  mutable Mutex m_mutex;
+};
+/*! @} */
+} // namespace FIX
+
+#endif // FIX_INITIATOR_H

data/ext/quickfix/Log.cpp

@@ -0,0 +1,71 @@
+/****************************************************************************
+** 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 "Log.h"
+
+namespace FIX {
+Mutex ScreenLog::s_mutex;
+
+Log *ScreenLogFactory::create() {
+  bool incoming, outgoing, event;
+  init(m_settings.get(), incoming, outgoing, event);
+  return new ScreenLog(incoming, outgoing, event);
+}
+
+Log *ScreenLogFactory::create(const SessionID &sessionID) {
+  Dictionary settings;
+  if (m_settings.has(sessionID)) {
+    settings = m_settings.get(sessionID);
+  }
+
+  bool incoming, outgoing, event;
+  init(settings, incoming, outgoing, event);
+  return new ScreenLog(sessionID, incoming, outgoing, event);
+}
+
+void ScreenLogFactory::init(const Dictionary &settings, bool &incoming, bool &outgoing, bool &event) const {
+  if (m_useSettings) {
+    incoming = true;
+    outgoing = true;
+    event = true;
+
+    if (settings.has(SCREEN_LOG_SHOW_INCOMING)) {
+      incoming = settings.getBool(SCREEN_LOG_SHOW_INCOMING);
+    }
+    if (settings.has(SCREEN_LOG_SHOW_OUTGOING)) {
+      outgoing = settings.getBool(SCREEN_LOG_SHOW_OUTGOING);
+    }
+    if (settings.has(SCREEN_LOG_SHOW_EVENTS)) {
+      event = settings.getBool(SCREEN_LOG_SHOW_EVENTS);
+    }
+  } else {
+    incoming = m_incoming;
+    outgoing = m_outgoing;
+    event = m_event;
+  }
+}
+
+void ScreenLogFactory::destroy(Log *pLog) { delete pLog; }
+} // namespace FIX