quickfix_ruby_ud 2.0.7-x86_64-linux

data/ext/quickfix/ThreadedSocketInitiator.cpp

@@ -0,0 +1,238 @@
+/****************************************************************************
+** 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 "Session.h"
+#include "Settings.h"
+#include "ThreadedSocketInitiator.h"
+
+namespace FIX {
+ThreadedSocketInitiator::ThreadedSocketInitiator(
+    Application &application,
+    MessageStoreFactory &factory,
+    const SessionSettings &settings) EXCEPT(ConfigError)
+    : Initiator(application, factory, settings),
+      m_lastConnect(0),
+      m_reconnectInterval(30),
+      m_noDelay(false),
+      m_sendBufSize(0),
+      m_rcvBufSize(0) {
+  socket_init();
+}
+
+ThreadedSocketInitiator::ThreadedSocketInitiator(
+    Application &application,
+    MessageStoreFactory &factory,
+    const SessionSettings &settings,
+    LogFactory &logFactory) EXCEPT(ConfigError)
+    : Initiator(application, factory, settings, logFactory),
+      m_lastConnect(0),
+      m_reconnectInterval(30),
+      m_noDelay(false),
+      m_sendBufSize(0),
+      m_rcvBufSize(0) {
+  socket_init();
+}
+
+ThreadedSocketInitiator::~ThreadedSocketInitiator() { socket_term(); }
+
+void ThreadedSocketInitiator::onConfigure(const SessionSettings &s) EXCEPT(ConfigError) {
+  const Dictionary &dict = s.get();
+
+  if (dict.has(RECONNECT_INTERVAL)) // ReconnectInterval in [DEFAULT]
+  {
+    m_reconnectInterval = dict.getInt(RECONNECT_INTERVAL);
+  }
+  if (dict.has(SOCKET_NODELAY)) {
+    m_noDelay = dict.getBool(SOCKET_NODELAY);
+  }
+  if (dict.has(SOCKET_SEND_BUFFER_SIZE)) {
+    m_sendBufSize = dict.getInt(SOCKET_SEND_BUFFER_SIZE);
+  }
+  if (dict.has(SOCKET_RECEIVE_BUFFER_SIZE)) {
+    m_rcvBufSize = dict.getInt(SOCKET_RECEIVE_BUFFER_SIZE);
+  }
+}
+
+void ThreadedSocketInitiator::onInitialize(const SessionSettings &s) EXCEPT(RuntimeError) {}
+
+void ThreadedSocketInitiator::onStart() {
+  while (!isStopped()) {
+    time_t now;
+    ::time(&now);
+
+    if ((now - m_lastConnect) >= m_reconnectInterval) {
+      Locker l(m_mutex);
+      connect();
+      m_lastConnect = now;
+    }
+
+    process_sleep(1);
+  }
+}
+
+bool ThreadedSocketInitiator::onPoll() { return false; }
+
+void ThreadedSocketInitiator::onStop() {
+  SocketToThread threads;
+  SocketToThread::iterator i;
+
+  {
+    Locker l(m_mutex);
+
+    time_t start = 0;
+    time_t now = 0;
+
+    ::time(&start);
+    while (isLoggedOn()) {
+      if (::time(&now) - 5 >= start) {
+        break;
+      }
+    }
+
+    threads = m_threads;
+    m_threads.clear();
+  }
+
+  for (i = threads.begin(); i != threads.end(); ++i) {
+    socket_close(i->first);
+  }
+
+  for (i = threads.begin(); i != threads.end(); ++i) {
+    thread_join(i->second);
+  }
+  threads.clear();
+}
+
+void ThreadedSocketInitiator::doConnect(const SessionID &s, const Dictionary &d) {
+  try {
+    Session *session = Session::lookupSession(s);
+    if (!session->isSessionTime(UtcTimeStamp::now())) {
+      return;
+    }
+
+    Log *log = session->getLog();
+
+    HostDetails host = m_hostDetailsProvider.getHost(s, d);
+    if (d.has(RECONNECT_INTERVAL)) // ReconnectInterval in [SESSION]
+    {
+      m_reconnectInterval = d.getInt(RECONNECT_INTERVAL);
+    }
+
+    socket_handle socket = socket_createConnector();
+    if (m_noDelay) {
+      socket_setsockopt(socket, TCP_NODELAY);
+    }
+    if (m_sendBufSize) {
+      socket_setsockopt(socket, SO_SNDBUF, m_sendBufSize);
+    }
+    if (m_rcvBufSize) {
+      socket_setsockopt(socket, SO_RCVBUF, m_rcvBufSize);
+    }
+
+    setPending(s);
+    log->onEvent(
+        "Connecting to " + host.address + " on port " + IntConvertor::convert((unsigned short)host.port) + " (Source "
+        + host.sourceAddress + ":" + IntConvertor::convert((unsigned short)host.sourcePort)
+        + ") ReconnectInterval=" + IntConvertor::convert((int)m_reconnectInterval));
+
+    ThreadedSocketConnection *pConnection = new ThreadedSocketConnection(
+        s,
+        socket,
+        host.address,
+        host.port,
+        getLog(),
+        host.sourceAddress,
+        host.sourcePort);
+
+    ThreadPair *pair = new ThreadPair(this, pConnection);
+
+    {
+      Locker l(m_mutex);
+      thread_id thread;
+      if (thread_spawn(&socketThread, pair, thread)) {
+        addThread(socket, thread);
+      } else {
+        delete pair;
+        pConnection->disconnect();
+        delete pConnection;
+        setDisconnected(s);
+      }
+    }
+  } catch (std::exception &) {}
+}
+
+void ThreadedSocketInitiator::addThread(socket_handle s, thread_id t) {
+  Locker l(m_mutex);
+
+  m_threads[s] = t;
+}
+
+void ThreadedSocketInitiator::removeThread(socket_handle s) {
+  Locker l(m_mutex);
+  SocketToThread::iterator i = m_threads.find(s);
+
+  if (i != m_threads.end()) {
+    thread_detach(i->second);
+    m_threads.erase(i);
+  }
+}
+
+THREAD_PROC ThreadedSocketInitiator::socketThread(void *p) {
+  ThreadPair *pair = reinterpret_cast<ThreadPair *>(p);
+
+  ThreadedSocketInitiator *pInitiator = pair->first;
+  ThreadedSocketConnection *pConnection = pair->second;
+  FIX::SessionID sessionID = pConnection->getSession()->getSessionID();
+  FIX::Session *pSession = FIX::Session::lookupSession(sessionID);
+  socket_handle socket = pConnection->getSocket();
+  delete pair;
+
+  pInitiator->lock();
+
+  if (!pConnection->connect()) {
+    pInitiator->getLog()->onEvent("Connection failed");
+    pConnection->disconnect();
+    delete pConnection;
+    pInitiator->removeThread(socket);
+    pInitiator->setDisconnected(sessionID);
+    return 0;
+  }
+
+  pInitiator->setConnected(sessionID);
+  pInitiator->getLog()->onEvent("Connection succeeded");
+
+  pSession->next(UtcTimeStamp::now());
+
+  while (pConnection->read()) {}
+
+  delete pConnection;
+  if (!pInitiator->isStopped()) {
+    pInitiator->removeThread(socket);
+  }
+
+  pInitiator->setDisconnected(sessionID);
+  return 0;
+}
+} // namespace FIX

data/ext/quickfix/ThreadedSocketInitiator.h

@@ -0,0 +1,78 @@
+/* -*- 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_THREADEDSOCKETINITIATOR_H
+#define FIX_THREADEDSOCKETINITIATOR_H
+
+#ifdef _MSC_VER
+#pragma warning(disable : 4503 4355 4786 4290)
+#endif
+
+#include "HostDetailsProvider.h"
+#include "Initiator.h"
+#include "ThreadedSocketConnection.h"
+#include <map>
+
+namespace FIX {
+/*! \addtogroup user
+ *  @{
+ */
+/// Threaded Socket implementation of Initiator.
+class ThreadedSocketInitiator : public Initiator {
+public:
+  ThreadedSocketInitiator(Application &, MessageStoreFactory &, const SessionSettings &) EXCEPT(ConfigError);
+  ThreadedSocketInitiator(Application &, MessageStoreFactory &, const SessionSettings &, LogFactory &)
+      EXCEPT(ConfigError);
+
+  virtual ~ThreadedSocketInitiator();
+
+private:
+  typedef std::map<socket_handle, thread_id> SocketToThread;
+  typedef std::pair<ThreadedSocketInitiator *, ThreadedSocketConnection *> ThreadPair;
+
+  void onConfigure(const SessionSettings &) EXCEPT(ConfigError);
+  void onInitialize(const SessionSettings &) EXCEPT(RuntimeError);
+
+  void onStart();
+  bool onPoll();
+  void onStop();
+
+  void doConnect(const SessionID &s, const Dictionary &d);
+
+  void addThread(socket_handle s, thread_id t);
+  void removeThread(socket_handle s);
+  void lock() { Locker l(m_mutex); }
+  static THREAD_PROC socketThread(void *p);
+
+  SessionSettings m_settings;
+  HostDetailsProvider m_hostDetailsProvider;
+  time_t m_lastConnect;
+  int m_reconnectInterval;
+  bool m_noDelay;
+  int m_sendBufSize;
+  int m_rcvBufSize;
+  SocketToThread m_threads;
+  Mutex m_mutex;
+};
+/*! @} */
+} // namespace FIX
+
+#endif // FIX_THREADEDSOCKETINITIATOR_H

data/ext/quickfix/TimeRange.cpp

@@ -0,0 +1,227 @@
+/****************************************************************************
+** 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 "TimeRange.h"
+#include "Utility.h"
+
+namespace FIX {
+TimeRange::TimeRange(const UtcTimeOnly &startTime, const UtcTimeOnly &endTime, int startDay, int endDay)
+    : m_startTime(startTime),
+      m_endTime(endTime),
+      m_startDay(startDay),
+      m_endDay(endDay),
+      m_useLocalTime(false) {
+  if (startDay > 0 && endDay > 0 && startDay == endDay && endTime > startTime) {
+    m_endTime = m_startTime;
+  }
+}
+
+TimeRange::TimeRange(const LocalTimeOnly &startTime, const LocalTimeOnly &endTime, int startDay, int endDay)
+    : m_startTime(startTime),
+      m_endTime(endTime),
+      m_startDay(startDay),
+      m_endDay(endDay),
+      m_useLocalTime(true) {
+  if (startDay > 0 && endDay > 0 && startDay == endDay && endTime > startTime) {
+    m_endTime = m_startTime;
+  }
+}
+
+int TimeRange::getRangeStartDate(const DateTime &time, int startDay, const DateTime &startTime) {
+  if (time.getWeekDay() > startDay) {
+    return time.getJulianDate() - time.getWeekDay() + startDay;
+  } else if (time.getWeekDay() < startDay) {
+    return time.getJulianDate() - time.getWeekDay() + startDay - 7;
+  } else {
+    if (UtcTimeOnly(time) >= UtcTimeOnly(startTime)) {
+      return time.getJulianDate();
+    } else {
+      return time.getJulianDate() - 7;
+    }
+  }
+}
+
+bool TimeRange::isInRange(const DateTime &start, const DateTime &end, const DateTime &time) {
+  UtcTimeOnly timeOnly(time);
+
+  if (start < end) {
+    return (timeOnly >= start && timeOnly <= end);
+  } else {
+    return (timeOnly >= start || timeOnly <= end);
+  }
+}
+
+bool TimeRange::isInRange(
+    const DateTime &startTime,
+    const DateTime &endTime,
+    int startDay,
+    int endDay,
+    const DateTime &time,
+    int day) {
+  UtcTimeOnly timeOnly(time);
+
+  if (startDay == endDay) {
+    if (day != startDay) {
+      return true;
+    }
+    return isInRange(startTime, endTime, time);
+  } else if (startDay < endDay) {
+    if (day < startDay || day > endDay) {
+      return false;
+    } else if (day == startDay && timeOnly < startTime) {
+      return false;
+    } else if (day == endDay && timeOnly > endTime) {
+      return false;
+    }
+  } else if (startDay > endDay) {
+    if (day < startDay && day > endDay) {
+      return false;
+    } else if (day == startDay && timeOnly < startTime) {
+      return false;
+    } else if (day == endDay && timeOnly > endTime) {
+      return false;
+    }
+  }
+  return true;
+}
+
+bool TimeRange::isInRange(
+    const DateTime &startTime,
+    const DateTime &endTime,
+    int startDay,
+    int endDay,
+    const DateTime &time) {
+  return isInRange(startTime, endTime, startDay, endDay, time, time.getWeekDay());
+}
+
+bool TimeRange::isInSameRange(
+    const DateTime &start,
+    const DateTime &end,
+    const DateTime &time1,
+    const DateTime &time2) {
+  if (!isInRange(start, end, time1)) {
+    return false;
+  }
+  if (!isInRange(start, end, time2)) {
+    return false;
+  }
+
+  if (time1 == time2) {
+    return true;
+  }
+
+  if (start < end || start == end) {
+    UtcDate time1Date(time1);
+    UtcDate time2Date(time2);
+
+    return time1Date == time2Date;
+  } else {
+    int sessionLength = DateTime::SECONDS_PER_DAY - (start - end);
+
+    if (time1 > time2) {
+      UtcTimeOnly time2TimeOnly = UtcTimeOnly(time2);
+
+      long delta = time2TimeOnly - start;
+      if (delta < 0) {
+        delta = DateTime::SECONDS_PER_DAY - labs(delta);
+      }
+
+      return (time1 - time2) < (sessionLength - delta);
+    } else {
+      return (time2 - time1) < sessionLength;
+    }
+  }
+}
+
+bool TimeRange::isInSameRange(
+    const DateTime &startTime,
+    const DateTime &endTime,
+    int startDay,
+    int endDay,
+    const DateTime &time1,
+    const DateTime &time2) {
+  if (!isInRange(startTime, endTime, startDay, endDay, time1, time1.getWeekDay())) {
+    return false;
+  }
+
+  if (!isInRange(startTime, endTime, startDay, endDay, time2, time2.getWeekDay())) {
+    return false;
+  }
+
+  if (startDay != endDay) {
+    int time1RangeStartDate = getRangeStartDate(time1, startDay, startTime);
+    int time2RangeStartDate = getRangeStartDate(time2, startDay, startTime);
+    return time1RangeStartDate == time2RangeStartDate;
+  } else {
+    int day1 = time1.getJulianDate();
+    int day2 = time2.getJulianDate();
+
+    // session start and end day are the same day, which is also both of these time's day
+    if (time1.getJulianDate() == time2.getJulianDate() && startDay == time1.getWeekDay()) {
+      auto time1_utcTimeOnly = UtcTimeOnly(time1);
+      auto time2_utcTimeOnly = UtcTimeOnly(time2);
+      auto startTime_utcTimeOnly = UtcTimeOnly(startTime);
+      auto endTime_utcTimeOnly = UtcTimeOnly(endTime);
+      bool bothBeforeEndOfRange = time1_utcTimeOnly <= endTime_utcTimeOnly && time2_utcTimeOnly <= endTime_utcTimeOnly;
+      bool bothAfterStartOfRange
+          = time1_utcTimeOnly >= startTime_utcTimeOnly && time2_utcTimeOnly >= startTime_utcTimeOnly;
+      return bothBeforeEndOfRange || bothAfterStartOfRange;
+    }
+
+    // session start and end day are the same day, which is neither of these time's day
+    else if (day1 == day2 && startDay != time1.getWeekDay()) {
+      return true;
+    }
+
+    // session start and end day are 7 days apart, so times greater than 7 days apart means different range
+    else if (abs(day1 - day2) > 7) {
+      return false;
+    }
+
+    else if (abs(day1 - day2) == 7) {
+      if (time1.getWeekDay() != startDay) {
+        return false;
+      }
+
+      // a week apart on start days
+      DateTime earlierTime, laterTime;
+      if (day2 > day1) {
+        earlierTime = time1;
+        laterTime = time2;
+      } else {
+        earlierTime = time2;
+        laterTime = time1;
+      }
+      return UtcTimeOnly(earlierTime) >= UtcTimeOnly(startTime) && UtcTimeOnly(laterTime) <= UtcTimeOnly(endTime);
+    }
+    // session start and end day are the same day, which is between these times
+    else {
+      int time1RangeStartDate = getRangeStartDate(time1, startDay, startTime);
+      int time2RangeStartDate = getRangeStartDate(time2, startDay, startTime);
+      return time1RangeStartDate == time2RangeStartDate;
+    }
+  }
+}
+} // namespace FIX