quickfix_ruby 1.14.3

data/ext/quickfix/ThreadedSocketAcceptor.cpp

@@ -0,0 +1,258 @@
+/****************************************************************************
+** 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 "ThreadedSocketAcceptor.h"
+#include "Settings.h"
+#include "Utility.h"
+
+namespace FIX
+{
+ThreadedSocketAcceptor::ThreadedSocketAcceptor(
+  Application& application,
+  MessageStoreFactory& factory,
+  const SessionSettings& settings ) throw( ConfigError )
+: Acceptor( application, factory, settings )
+{ socket_init(); }
+
+ThreadedSocketAcceptor::ThreadedSocketAcceptor(
+  Application& application,
+  MessageStoreFactory& factory,
+  const SessionSettings& settings,
+  LogFactory& logFactory ) throw( ConfigError )
+: Acceptor( application, factory, settings, logFactory )
+{ 
+  socket_init(); 
+}
+
+ThreadedSocketAcceptor::~ThreadedSocketAcceptor()
+{ 
+  socket_term(); 
+}
+
+void ThreadedSocketAcceptor::onConfigure( const SessionSettings& s )
+throw ( ConfigError )
+{
+  std::set<SessionID> sessions = s.getSessions();
+  std::set<SessionID>::iterator i;
+  for( i = sessions.begin(); i != sessions.end(); ++i )
+  {
+    const Dictionary& settings = s.get( *i );
+    settings.getInt( SOCKET_ACCEPT_PORT );
+    if( settings.has(SOCKET_REUSE_ADDRESS) )
+      settings.getBool( SOCKET_REUSE_ADDRESS );
+    if( settings.has(SOCKET_NODELAY) )
+      settings.getBool( SOCKET_NODELAY );
+  }
+}
+
+void ThreadedSocketAcceptor::onInitialize( const SessionSettings& s )
+throw ( RuntimeError )
+{
+  short port = 0;
+  std::set<int> ports;
+
+  std::set<SessionID> sessions = s.getSessions();
+  std::set<SessionID>::iterator i = sessions.begin();
+  for( ; i != sessions.end(); ++i )
+  {
+    const Dictionary& settings = s.get( *i );
+    port = (short)settings.getInt( SOCKET_ACCEPT_PORT );
+
+    m_portToSessions[port].insert( *i );
+
+    if( ports.find(port) != ports.end() )
+      continue;
+    ports.insert( port );
+
+    const bool reuseAddress = settings.has( SOCKET_REUSE_ADDRESS ) ? 
+      settings.getBool( SOCKET_REUSE_ADDRESS ) : true;
+
+    const bool noDelay = settings.has( SOCKET_NODELAY ) ? 
+      settings.getBool( SOCKET_NODELAY ) : false;
+
+    const int sendBufSize = settings.has( SOCKET_SEND_BUFFER_SIZE ) ?
+      settings.getInt( SOCKET_SEND_BUFFER_SIZE ) : 0;
+
+    const int rcvBufSize = settings.has( SOCKET_RECEIVE_BUFFER_SIZE ) ?
+      settings.getInt( SOCKET_RECEIVE_BUFFER_SIZE ) : 0;
+
+    int socket = socket_createAcceptor( port, reuseAddress );
+    if( socket < 0 )
+    {
+      SocketException e;
+      socket_close( socket );
+      throw RuntimeError( "Unable to create, bind, or listen to port " 
+                         + IntConvertor::convert( (unsigned short)port ) + " (" + e.what() + ")" );
+    }
+    if( noDelay )
+      socket_setsockopt( socket, TCP_NODELAY );
+    if( sendBufSize )
+      socket_setsockopt( socket, SO_SNDBUF, sendBufSize );
+    if( rcvBufSize )
+      socket_setsockopt( socket, SO_RCVBUF, rcvBufSize );
+
+    m_socketToPort[socket] = port;
+    m_sockets.insert( socket );
+  }    
+}
+
+void ThreadedSocketAcceptor::onStart()
+{
+  Sockets::iterator i;
+  for( i = m_sockets.begin(); i != m_sockets.end(); ++i )
+  {
+    Locker l( m_mutex );
+    int port = m_socketToPort[*i];
+    AcceptorThreadInfo* info = new AcceptorThreadInfo( this, *i, port );
+    thread_id thread;
+    thread_spawn( &socketAcceptorThread, info, thread );
+    addThread( *i, thread );
+  }
+}
+
+bool ThreadedSocketAcceptor::onPoll( double timeout )
+{
+  return false;
+}
+
+void ThreadedSocketAcceptor::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 );
+}
+
+void ThreadedSocketAcceptor::addThread( int s, thread_id t )
+{
+  Locker l(m_mutex);
+
+  m_threads[ s ] = t;
+}
+
+void ThreadedSocketAcceptor::removeThread( int 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 ThreadedSocketAcceptor::socketAcceptorThread( void* p )
+{
+  AcceptorThreadInfo * info = reinterpret_cast < AcceptorThreadInfo* > ( p );
+
+  ThreadedSocketAcceptor* pAcceptor = info->m_pAcceptor;
+  int s = info->m_socket;
+  int port = info->m_port;
+  delete info;
+
+  int noDelay = 0;
+  int sendBufSize = 0;
+  int rcvBufSize = 0;
+  socket_getsockopt( s, TCP_NODELAY, noDelay );
+  socket_getsockopt( s, SO_SNDBUF, sendBufSize );
+  socket_getsockopt( s, SO_RCVBUF, rcvBufSize );
+
+  int socket = 0;
+  while ( ( !pAcceptor->isStopped() && ( socket = socket_accept( s ) ) >= 0 ) )
+  {
+    if( noDelay )
+      socket_setsockopt( socket, TCP_NODELAY );
+    if( sendBufSize )
+      socket_setsockopt( socket, SO_SNDBUF, sendBufSize );
+    if( rcvBufSize )
+      socket_setsockopt( socket, SO_RCVBUF, rcvBufSize );
+
+    Sessions sessions = pAcceptor->m_portToSessions[port];
+
+    ThreadedSocketConnection * pConnection =
+      new ThreadedSocketConnection
+        ( socket, sessions, pAcceptor->getLog() );
+
+    ConnectionThreadInfo* info = new ConnectionThreadInfo( pAcceptor, pConnection );
+
+    {
+      Locker l( pAcceptor->m_mutex );
+
+      std::stringstream stream;
+      stream << "Accepted connection from " << socket_peername( socket ) << " on port " << port;
+
+      if( pAcceptor->getLog() )
+        pAcceptor->getLog()->onEvent( stream.str() );
+
+      thread_id thread;
+      if ( !thread_spawn( &socketConnectionThread, info, thread ) )
+        delete info;
+      pAcceptor->addThread( socket, thread );
+    }
+  }
+
+  if( !pAcceptor->isStopped() )
+    pAcceptor->removeThread( s );
+
+  return 0;
+}
+
+THREAD_PROC ThreadedSocketAcceptor::socketConnectionThread( void* p )
+{
+  ConnectionThreadInfo * info = reinterpret_cast < ConnectionThreadInfo* > ( p );
+
+  ThreadedSocketAcceptor* pAcceptor = info->m_pAcceptor;
+  ThreadedSocketConnection* pConnection = info->m_pConnection;
+  delete info;
+
+  int socket = pConnection->getSocket();
+
+  while ( pConnection->read() ) {}
+  delete pConnection;
+  if( !pAcceptor->isStopped() )
+    pAcceptor->removeThread( socket );
+  return 0;
+}
+}

data/ext/quickfix/ThreadedSocketAcceptor.h

@@ -0,0 +1,98 @@
+/* -*- 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_THREADEDSOCKETACCEPTOR_H
+#define FIX_THREADEDSOCKETACCEPTOR_H
+
+#ifdef _MSC_VER
+#pragma warning( disable : 4503 4355 4786 4290 )
+#endif
+
+#include "Acceptor.h"
+#include "ThreadedSocketConnection.h"
+#include "Mutex.h"
+
+namespace FIX
+{
+/// Threaded Socket implementation of Acceptor.
+class ThreadedSocketAcceptor : public Acceptor
+{
+  friend class SocketConnection;
+public:
+  ThreadedSocketAcceptor( Application&, MessageStoreFactory&,
+                          const SessionSettings& ) throw( ConfigError );
+  ThreadedSocketAcceptor( Application&, MessageStoreFactory&,
+                          const SessionSettings&,
+                          LogFactory& ) throw( ConfigError );
+
+  virtual ~ThreadedSocketAcceptor();
+
+private:
+  struct AcceptorThreadInfo
+  {
+    AcceptorThreadInfo( ThreadedSocketAcceptor* pAcceptor, int socket, int port )
+    : m_pAcceptor( pAcceptor ), m_socket( socket ), m_port( port ) {}
+
+    ThreadedSocketAcceptor* m_pAcceptor;
+    int m_socket;
+    int m_port;
+  };
+
+  struct ConnectionThreadInfo
+  {
+    ConnectionThreadInfo( ThreadedSocketAcceptor* pAcceptor, 
+                          ThreadedSocketConnection* pConnection )
+    : m_pAcceptor( pAcceptor ), m_pConnection( pConnection ) {}
+
+    ThreadedSocketAcceptor* m_pAcceptor;
+    ThreadedSocketConnection* m_pConnection;
+  };
+
+  bool readSettings( const SessionSettings& );
+
+  typedef std::set < int >  Sockets;
+  typedef std::set < SessionID > Sessions;
+  typedef std::map < int, Sessions > PortToSessions;
+  typedef std::map < int, int > SocketToPort;
+  typedef std::map < int, thread_id > SocketToThread;
+
+  void onConfigure( const SessionSettings& ) throw ( ConfigError );
+  void onInitialize( const SessionSettings& ) throw ( RuntimeError );
+
+  void onStart();
+  bool onPoll( double timeout );
+  void onStop();
+
+  void addThread( int s, thread_id t );
+  void removeThread( int s );
+  static THREAD_PROC socketAcceptorThread( void* p );
+  static THREAD_PROC socketConnectionThread( void* p );
+
+  Sockets m_sockets;
+  PortToSessions m_portToSessions;
+  SocketToPort m_socketToPort;
+  SocketToThread m_threads;
+  Mutex m_mutex;
+};
+/*! @} */
+}
+
+#endif //FIX_THREADEDSOCKETACCEPTOR_H

data/ext/quickfix/ThreadedSocketConnection.cpp

@@ -0,0 +1,209 @@
+/****************************************************************************
+** 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 "ThreadedSocketConnection.h"
+#include "ThreadedSocketAcceptor.h"
+#include "ThreadedSocketInitiator.h"
+#include "Session.h"
+#include "Utility.h"
+
+namespace FIX
+{
+ThreadedSocketConnection::ThreadedSocketConnection
+( int s, Sessions sessions, Log* pLog )
+: m_socket( s ), m_pLog( pLog ),
+  m_sessions( sessions ), m_pSession( 0 ),
+  m_disconnect( false )
+{
+  FD_ZERO( &m_fds );
+  FD_SET( m_socket, &m_fds );
+}
+
+ThreadedSocketConnection::ThreadedSocketConnection
+( const SessionID& sessionID, int s,
+  const std::string& address, short port, 
+  Log* pLog )
+  : m_socket( s ), m_address( address ), m_port( port ),
+    m_pLog( pLog ),
+    m_pSession( Session::lookupSession( sessionID ) ),
+    m_disconnect( false )
+{
+  FD_ZERO( &m_fds );
+  FD_SET( m_socket, &m_fds );
+  if ( m_pSession ) m_pSession->setResponder( this );
+}
+
+ThreadedSocketConnection::~ThreadedSocketConnection()
+{
+  if ( m_pSession )
+  {
+    m_pSession->setResponder( 0 );
+    Session::unregisterSession( m_pSession->getSessionID() );
+  }
+}
+
+bool ThreadedSocketConnection::send( const std::string& msg )
+{
+  int totalSent = 0;
+  while(totalSent < (int)msg.length())
+  {
+    ssize_t sent = socket_send( m_socket, msg.c_str() + totalSent, msg.length() );
+    if(sent < 0) return false;
+    totalSent += sent;
+  }
+
+  return true;
+}
+
+bool ThreadedSocketConnection::connect()
+{
+  return socket_connect(getSocket(), m_address.c_str(), m_port) >= 0;
+}
+
+void ThreadedSocketConnection::disconnect()
+{  
+  m_disconnect = true;
+  socket_close( m_socket );
+}
+
+bool ThreadedSocketConnection::read()
+{
+  struct timeval timeout = { 1, 0 };
+  fd_set readset = m_fds;
+
+  try
+  {
+    // Wait for input (1 second timeout)
+    int result = select( 1 + m_socket, &readset, 0, 0, &timeout );
+
+    if( result > 0 ) // Something to read
+    {
+      // We can read without blocking
+      ssize_t size = recv( m_socket, m_buffer, sizeof(m_buffer), 0 );
+      if ( size <= 0 ) { throw SocketRecvFailed( size ); }
+      m_parser.addToStream( m_buffer, size );
+    }
+    else if( result == 0 && m_pSession ) // Timeout
+    {
+      m_pSession->next();
+    }
+    else if( result < 0 ) // Error
+    {
+      throw SocketRecvFailed( result );
+    }
+
+    processStream();
+    return true;
+  }
+  catch ( SocketRecvFailed& e )
+  {
+    if( m_disconnect )
+      return false;
+
+    if( m_pSession )
+    {
+      m_pSession->getLog()->onEvent( e.what() );
+      m_pSession->disconnect();
+    }
+    else
+    {
+      disconnect();
+    }
+
+    return false;
+  }
+}
+
+bool ThreadedSocketConnection::readMessage( std::string& msg )
+throw( SocketRecvFailed )
+{
+  try
+  {
+    return m_parser.readFixMessage( msg );
+  }
+  catch ( MessageParseError& ) {}
+  return true;
+}
+
+void ThreadedSocketConnection::processStream()
+{
+  std::string msg;
+  while( readMessage(msg) )
+  {
+    if ( !m_pSession )
+    {
+      if ( !setSession( msg ) )
+      { disconnect(); continue; }
+    }
+    try
+    {
+      m_pSession->next( msg, UtcTimeStamp() );
+    }
+    catch( InvalidMessage& )
+    {
+      if( !m_pSession->isLoggedOn() )
+      {
+        disconnect();
+        return;
+      }
+    }
+  }
+}
+
+bool ThreadedSocketConnection::setSession( const std::string& msg )
+{
+  m_pSession = Session::lookupSession( msg, true );
+  if ( !m_pSession ) 
+  {
+    if( m_pLog )
+    {
+      m_pLog->onEvent( "Session not found for incoming message: " + msg );
+      m_pLog->onIncoming( msg );
+    }
+    return false;
+  }
+
+  SessionID sessionID = m_pSession->getSessionID();
+  m_pSession = 0;
+
+  // see if the session frees up within 5 seconds
+  for( int i = 1; i <= 5; i++ )
+  {
+    if( !Session::isSessionRegistered( sessionID ) )
+      m_pSession = Session::registerSession( sessionID );
+    if( m_pSession ) break;
+    process_sleep( 1 );
+  }
+
+  if ( !m_pSession ) 
+    return false;
+  if ( m_sessions.find(m_pSession->getSessionID()) == m_sessions.end() )
+    return false;
+
+  m_pSession->setResponder( this );
+  return true;
+}
+
+} // namespace FIX

data/ext/quickfix/ThreadedSocketConnection.h

@@ -0,0 +1,82 @@
+/* -*- 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_THREADEDSOCKETCONNECTION_H
+#define FIX_THREADEDSOCKETCONNECTION_H
+
+#ifdef _MSC_VER
+#pragma warning( disable : 4503 4355 4786 4290 )
+#endif
+
+#include "Parser.h"
+#include "Responder.h"
+#include "SessionID.h"
+#include <set>
+#include <map>
+
+namespace FIX
+{
+class ThreadedSocketAcceptor;
+class ThreadedSocketInitiator;
+class Session;
+class Application;
+class Log;
+
+/// Encapsulates a socket file descriptor (multi-threaded).
+class ThreadedSocketConnection : Responder
+{
+public:
+  typedef std::set<SessionID> Sessions;
+
+  ThreadedSocketConnection( int s, Sessions sessions, Log* pLog );
+  ThreadedSocketConnection( const SessionID&, int s, 
+                            const std::string& address, short port, 
+                            Log* pLog );
+  virtual ~ThreadedSocketConnection() ;
+
+  Session* getSession() const { return m_pSession; }
+  int getSocket() const { return m_socket; }
+  bool connect();
+  void disconnect();
+  bool read();
+
+private:
+  bool readMessage( std::string& msg ) throw( SocketRecvFailed );
+  void processStream();
+  bool send( const std::string& );
+  bool setSession( const std::string& msg );
+
+  int m_socket;
+  char m_buffer[BUFSIZ];
+
+  std::string m_address;
+  int m_port;
+
+  Log* m_pLog;
+  Parser m_parser;
+  Sessions m_sessions;
+  Session* m_pSession;
+  bool m_disconnect;
+  fd_set m_fds;
+};
+}
+
+#endif //FIX_THREADEDSOCKETCONNECTION_H