quickfix_ruby_ud 2.0.7-x86_64-linux

data/ext/quickfix/SocketInitiator.cpp

@@ -0,0 +1,241 @@
+/****************************************************************************
+** 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 "SocketInitiator.h"
+
+namespace FIX {
+SocketInitiator::SocketInitiator(
+    Application &application,
+    MessageStoreFactory &factory,
+    const SessionSettings &settings) EXCEPT(ConfigError)
+    : Initiator(application, factory, settings),
+      m_connector(1),
+      m_lastConnect(0),
+      m_reconnectInterval(30),
+      m_noDelay(false),
+      m_sendBufSize(0),
+      m_rcvBufSize(0) {}
+
+SocketInitiator::SocketInitiator(
+    Application &application,
+    MessageStoreFactory &factory,
+    const SessionSettings &settings,
+    LogFactory &logFactory) EXCEPT(ConfigError)
+    : Initiator(application, factory, settings, logFactory),
+      m_connector(1),
+      m_lastConnect(0),
+      m_reconnectInterval(30),
+      m_noDelay(false),
+      m_sendBufSize(0),
+      m_rcvBufSize(0) {}
+
+SocketInitiator::~SocketInitiator() {
+  SocketConnections::iterator i;
+  for (i = m_connections.begin(); i != m_connections.end(); ++i) {
+    delete i->second;
+  }
+
+  for (i = m_pendingConnections.begin(); i != m_pendingConnections.end(); ++i) {
+    delete i->second;
+  }
+}
+
+void SocketInitiator::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 SocketInitiator::onInitialize(const SessionSettings &s) EXCEPT(RuntimeError) {}
+
+void SocketInitiator::onStart() {
+  connect();
+
+  while (!isStopped()) {
+    m_connector.block(*this, false, 1.0);
+    onTimeout(m_connector);
+  }
+
+  time_t start = 0;
+  time_t now = 0;
+
+  ::time(&start);
+  while (isLoggedOn()) {
+    m_connector.block(*this);
+    if (::time(&now) - 5 >= start) {
+      break;
+    }
+  }
+}
+
+bool SocketInitiator::onPoll() {
+  time_t start = 0;
+  time_t now = 0;
+
+  if (isStopped()) {
+    if (start == 0) {
+      ::time(&start);
+    }
+    if (!isLoggedOn()) {
+      return false;
+    }
+    if (::time(&now) - 5 >= start) {
+      return false;
+    }
+  }
+
+  m_connector.block(*this, true);
+  return true;
+}
+
+void SocketInitiator::onStop() {}
+
+void SocketInitiator::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);
+    }
+
+    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));
+    socket_handle result = m_connector.connect(
+        host.address,
+        host.port,
+        m_noDelay,
+        m_sendBufSize,
+        m_rcvBufSize,
+        host.sourceAddress,
+        host.sourcePort);
+    setPending(s);
+
+    m_pendingConnections[result] = new SocketConnection(*this, s, result, &m_connector.getMonitor());
+  } catch (std::exception &) {}
+}
+
+void SocketInitiator::onConnect(SocketConnector &, socket_handle s) {
+  SocketConnections::iterator i = m_pendingConnections.find(s);
+  if (i == m_pendingConnections.end()) {
+    return;
+  }
+  SocketConnection *pSocketConnection = i->second;
+
+  m_connections[s] = pSocketConnection;
+  m_pendingConnections.erase(i);
+  setConnected(pSocketConnection->getSession()->getSessionID());
+  pSocketConnection->onTimeout();
+}
+
+void SocketInitiator::onWrite(SocketConnector &connector, socket_handle s) {
+  SocketConnections::iterator i = m_connections.find(s);
+  if (i == m_connections.end()) {
+    return;
+  }
+  SocketConnection *pSocketConnection = i->second;
+  if (pSocketConnection->processQueue()) {
+    pSocketConnection->unsignal();
+  }
+}
+
+bool SocketInitiator::onData(SocketConnector &connector, socket_handle s) {
+  SocketConnections::iterator i = m_connections.find(s);
+  if (i == m_connections.end()) {
+    return false;
+  }
+  SocketConnection *pSocketConnection = i->second;
+  return pSocketConnection->read(connector);
+}
+
+void SocketInitiator::onDisconnect(SocketConnector &, socket_handle s) {
+  SocketConnections::iterator i = m_connections.find(s);
+  SocketConnections::iterator j = m_pendingConnections.find(s);
+
+  SocketConnection *pSocketConnection = 0;
+  if (i != m_connections.end()) {
+    pSocketConnection = i->second;
+  }
+  if (j != m_pendingConnections.end()) {
+    pSocketConnection = j->second;
+  }
+  if (!pSocketConnection) {
+    return;
+  }
+
+  setDisconnected(pSocketConnection->getSession()->getSessionID());
+
+  Session *pSession = pSocketConnection->getSession();
+  if (pSession) {
+    pSession->disconnect();
+    setDisconnected(pSession->getSessionID());
+  }
+
+  delete pSocketConnection;
+  m_connections.erase(s);
+  m_pendingConnections.erase(s);
+}
+
+void SocketInitiator::onError(SocketConnector &connector) { onTimeout(connector); }
+
+void SocketInitiator::onTimeout(SocketConnector &) {
+  time_t now;
+  ::time(&now);
+
+  if ((now - m_lastConnect) >= m_reconnectInterval) {
+    connect();
+    m_lastConnect = now;
+  }
+
+  SocketConnections::iterator i;
+  for (i = m_connections.begin(); i != m_connections.end(); ++i) {
+    i->second->onTimeout();
+  }
+}
+
+} // namespace FIX

data/ext/quickfix/SocketInitiator.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_SOCKETINITIATOR_H
+#define FIX_SOCKETINITIATOR_H
+
+#ifdef _MSC_VER
+#pragma warning(disable : 4503 4355 4786 4290)
+#endif
+
+#include "HostDetailsProvider.h"
+#include "Initiator.h"
+#include "SocketConnection.h"
+#include "SocketConnector.h"
+
+namespace FIX {
+/// Socket implementation of Initiator.
+class SocketInitiator : public Initiator, SocketConnector::Strategy {
+public:
+  SocketInitiator(Application &, MessageStoreFactory &, const SessionSettings &) EXCEPT(ConfigError);
+  SocketInitiator(Application &, MessageStoreFactory &, const SessionSettings &, LogFactory &) EXCEPT(ConfigError);
+
+  virtual ~SocketInitiator();
+
+private:
+  typedef std::map<socket_handle, SocketConnection *> SocketConnections;
+
+  void onConfigure(const SessionSettings &) EXCEPT(ConfigError);
+  void onInitialize(const SessionSettings &) EXCEPT(RuntimeError);
+
+  void onStart();
+  bool onPoll();
+  void onStop();
+
+  void doConnect(const SessionID &, const Dictionary &d);
+  void onConnect(SocketConnector &, socket_handle);
+  void onWrite(SocketConnector &, socket_handle);
+  bool onData(SocketConnector &, socket_handle);
+  void onDisconnect(SocketConnector &, socket_handle);
+  void onError(SocketConnector &);
+  void onTimeout(SocketConnector &);
+
+  SessionSettings m_settings;
+
+  HostDetailsProvider m_hostDetailsProvider;
+  SocketConnector m_connector;
+  SocketConnections m_pendingConnections;
+  SocketConnections m_connections;
+  time_t m_lastConnect;
+  int m_reconnectInterval;
+  bool m_noDelay;
+  int m_sendBufSize;
+  int m_rcvBufSize;
+};
+/*! @} */
+} // namespace FIX
+
+#endif // FIX_SOCKETINITIATOR_H

data/ext/quickfix/SocketMonitor.h

@@ -0,0 +1,26 @@
+/* -*- 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.
+**
+****************************************************************************/
+
+#ifdef _MSC_VER
+#include "SocketMonitor_WIN32.h"
+#else
+#include "SocketMonitor_UNIX.h"
+#endif

data/ext/quickfix/SocketMonitor_UNIX.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.
+**
+****************************************************************************/
+
+#ifndef _MSC_VER
+
+#include "config.h"
+
+#include "SocketMonitor.h"
+#include "Utility.h"
+#include <algorithm>
+#include <exception>
+#include <iostream>
+#include <set>
+
+namespace FIX {
+SocketMonitor::SocketMonitor(int timeout)
+    : m_timeout(timeout) {
+  socket_init();
+
+  std::pair<socket_handle, socket_handle> sockets = socket_createpair();
+  m_signal = sockets.first;
+  m_interrupt = sockets.second;
+  socket_setnonblock(m_signal);
+  socket_setnonblock(m_interrupt);
+  m_readSockets.insert(m_interrupt);
+
+  m_ticks = clock();
+}
+
+SocketMonitor::~SocketMonitor() {
+  Sockets::iterator i;
+  for (i = m_readSockets.begin(); i != m_readSockets.end(); ++i) {
+    socket_close(*i);
+  }
+
+  socket_close(m_signal);
+  socket_term();
+}
+
+bool SocketMonitor::addConnect(socket_handle s) {
+  socket_setnonblock(s);
+  Sockets::iterator i = m_connectSockets.find(s);
+  if (i != m_connectSockets.end()) {
+    return false;
+  }
+
+  m_connectSockets.insert(s);
+  return true;
+}
+
+bool SocketMonitor::addRead(socket_handle s) {
+  socket_setnonblock(s);
+  Sockets::iterator i = m_readSockets.find(s);
+  if (i != m_readSockets.end()) {
+    return false;
+  }
+
+  m_readSockets.insert(s);
+  return true;
+}
+
+bool SocketMonitor::addWrite(socket_handle s) {
+  if (m_readSockets.find(s) == m_readSockets.end()) {
+    return false;
+  }
+
+  socket_setnonblock(s);
+  Sockets::iterator i = m_writeSockets.find(s);
+  if (i != m_writeSockets.end()) {
+    return false;
+  }
+
+  m_writeSockets.insert(s);
+  return true;
+}
+
+bool SocketMonitor::drop(socket_handle s) {
+  Sockets::iterator i = m_readSockets.find(s);
+  Sockets::iterator j = m_writeSockets.find(s);
+  Sockets::iterator k = m_connectSockets.find(s);
+
+  if (i != m_readSockets.end() || j != m_writeSockets.end() || k != m_connectSockets.end()) {
+    socket_close(s);
+    m_readSockets.erase(s);
+    m_writeSockets.erase(s);
+    m_connectSockets.erase(s);
+    m_dropped.push(s);
+    return true;
+  }
+  return false;
+}
+
+inline int SocketMonitor::getTimeval(bool poll, double timeout) {
+  if (poll) {
+    return 0;
+  }
+
+  timeout = m_timeout;
+
+  if (!timeout) {
+    return 0;
+  }
+
+  double elapsed = (double)(clock() - m_ticks) / (double)CLOCKS_PER_SEC;
+  if (elapsed >= timeout || elapsed == 0.0) {
+    m_ticks = clock();
+    return (timeout * 1000);
+  } else {
+    return ((timeout - elapsed) * 1000);
+  }
+  return (timeout * 1000);
+}
+
+bool SocketMonitor::sleepIfEmpty(bool poll) {
+  if (poll) {
+    return false;
+  }
+
+  if (m_readSockets.empty() && m_writeSockets.empty() && m_connectSockets.empty()) {
+    process_sleep(m_timeout);
+    return true;
+  } else {
+    return false;
+  }
+}
+
+void SocketMonitor::signal(socket_handle socket) { socket_send(m_signal, (char *)&socket, sizeof(socket)); }
+
+void SocketMonitor::unsignal(socket_handle s) {
+  Sockets::iterator i = m_writeSockets.find(s);
+  if (i == m_writeSockets.end()) {
+    return;
+  }
+
+  m_writeSockets.erase(s);
+}
+
+void SocketMonitor::block(Strategy &strategy, bool should_poll, double timeout) {
+  while (m_dropped.size()) {
+    strategy.onError(*this, m_dropped.front());
+    m_dropped.pop();
+    if (m_dropped.size() == 0) {
+      return;
+    }
+  }
+
+  int pfds_size = m_readSockets.size() + m_connectSockets.size() + m_writeSockets.size();
+  struct pollfd pfds[pfds_size];
+  buildSet(m_readSockets, pfds, POLLPRI | POLLIN);
+  buildSet(m_connectSockets, pfds + m_readSockets.size(), POLLOUT | POLLERR);
+  buildSet(m_writeSockets, pfds + m_readSockets.size() + m_connectSockets.size(), POLLOUT);
+
+  if (sleepIfEmpty(should_poll)) {
+    strategy.onTimeout(*this);
+    return;
+  }
+
+  int result = poll(pfds, pfds_size, getTimeval(should_poll, timeout));
+
+  if (result == 0) {
+    strategy.onTimeout(*this);
+    return;
+  } else if (result > 0) {
+    processPollList(strategy, pfds, pfds_size);
+  } else {
+    strategy.onError(*this);
+  }
+}
+
+void SocketMonitor::processRead(Strategy &strategy, socket_handle socket_fd) {
+  int s = socket_fd;
+  if (s == m_interrupt) {
+    socket_handle socket = 0;
+    recv(s, (char *)&socket, sizeof(socket), 0);
+    addWrite(socket);
+  } else {
+    strategy.onEvent(*this, s);
+  }
+}
+
+void SocketMonitor::processWrite(Strategy &strategy, socket_handle socket_fd) {
+  socket_handle s = socket_fd;
+  if (m_connectSockets.find(s) != m_connectSockets.end()) {
+    m_connectSockets.erase(s);
+    m_readSockets.insert(s);
+    strategy.onConnect(*this, s);
+  } else {
+    strategy.onWrite(*this, s);
+  }
+}
+
+void SocketMonitor::processError(Strategy &strategy, socket_handle socket_fd) { strategy.onError(*this, socket_fd); }
+
+void SocketMonitor::processPollList(Strategy &strategy, struct pollfd *pfds, unsigned pfds_size) {
+  for (unsigned i = 0; i < pfds_size; ++i) {
+    if ((pfds[i].revents & POLLIN) || (pfds[i].revents & POLLPRI)) {
+      processRead(strategy, pfds[i].fd);
+    }
+
+    if ((pfds[i].revents & POLLOUT)) {
+      processWrite(strategy, pfds[i].fd);
+    }
+    if ((pfds[i].revents & POLLERR)) {
+      processError(strategy, pfds[i].fd);
+    }
+  }
+}
+
+void SocketMonitor::buildSet(const Sockets &sockets, struct pollfd *pfds, short events) {
+  Sockets::const_iterator iter;
+  unsigned int i = 0;
+  for (iter = sockets.begin(); iter != sockets.end(); ++iter) {
+    pfds[i].fd = *iter;
+    pfds[i].events = events;
+    pfds[i].revents = 0;
+    i += 1;
+  }
+}
+
+} // namespace FIX
+
+#endif

data/ext/quickfix/SocketMonitor_UNIX.h

@@ -0,0 +1,101 @@
+/* -*- 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_SOCKETMONITOR_UNIX_H
+#define FIX_SOCKETMONITOR_UNIX_H
+
+#ifndef _MSC_VER
+
+#include <arpa/inet.h>
+#include <netinet/in.h>
+#include <sys/socket.h>
+#include <sys/time.h>
+#include <sys/types.h>
+
+#include <poll.h>
+#include <queue>
+#include <set>
+#include <time.h>
+
+#include "Utility.h"
+
+namespace FIX {
+/// Monitors events on a collection of sockets.
+class SocketMonitor {
+public:
+  class Strategy;
+
+  SocketMonitor(int timeout = 0);
+  virtual ~SocketMonitor();
+
+  bool addConnect(socket_handle socket);
+  bool addRead(socket_handle socket);
+  bool addWrite(socket_handle socket);
+  bool drop(socket_handle socket);
+  void signal(socket_handle socket);
+  void unsignal(socket_handle socket);
+  void block(Strategy &strategy, bool poll = 0, double timeout = 0.0);
+
+  size_t numSockets() { return m_readSockets.size() - 1; }
+
+private:
+  typedef std::set<socket_handle> Sockets;
+  typedef std::queue<socket_handle> Queue;
+
+  void setsockopt();
+  bool bind();
+  bool listen();
+  void buildSet(const Sockets &, struct pollfd *pfds, short events);
+  inline int getTimeval(bool poll, double timeout);
+  inline bool sleepIfEmpty(bool poll);
+
+  void processRead(Strategy &, socket_handle socket_fd);
+  void processWrite(Strategy &, socket_handle socket_fd);
+  void processError(Strategy &, socket_handle socket_fd);
+  void processPollList(Strategy &strategy, struct pollfd *pfds, unsigned pfds_size);
+
+  int m_timeout;
+  clock_t m_ticks;
+
+  socket_handle m_signal;
+  socket_handle m_interrupt;
+  Sockets m_connectSockets;
+  Sockets m_readSockets;
+  Sockets m_writeSockets;
+  Queue m_dropped;
+
+public:
+  class Strategy {
+  public:
+    virtual ~Strategy() {}
+    virtual void onConnect(SocketMonitor &, socket_handle socket) = 0;
+    virtual void onEvent(SocketMonitor &, socket_handle socket) = 0;
+    virtual void onWrite(SocketMonitor &, socket_handle socket) = 0;
+    virtual void onError(SocketMonitor &, socket_handle socket) = 0;
+    virtual void onError(SocketMonitor &) = 0;
+    virtual void onTimeout(SocketMonitor &) {}
+  };
+};
+} // namespace FIX
+
+#endif //_MSC_VER
+
+#endif // FIX_SOCKETMONITOR_UNIX_H