quickfix_ruby 1.14.3

data/ext/quickfix/Initiator.cpp

@@ -0,0 +1,289 @@
+/****************************************************************************
+** 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 "Initiator.h"
+#include "Utility.h"
+#include "Session.h"
+#include "SessionFactory.h"
+#include "HttpServer.h"
+#include <algorithm>
+#include <fstream>
+
+namespace FIX
+{
+Initiator::Initiator( Application& application,
+                      MessageStoreFactory& messageStoreFactory,
+                      const SessionSettings& settings ) throw( ConfigError )
+: m_threadid( 0 ),
+  m_application( application ),
+  m_messageStoreFactory( messageStoreFactory ),
+  m_settings( settings ),
+  m_pLogFactory( 0 ),
+  m_pLog( 0 ),
+  m_firstPoll( true ),
+  m_stop( true )
+{ initialize(); }
+
+Initiator::Initiator( Application& application,
+                      MessageStoreFactory& messageStoreFactory,
+                      const SessionSettings& settings,
+                      LogFactory& logFactory ) throw( ConfigError )
+: m_threadid( 0 ),
+  m_application( application ),
+  m_messageStoreFactory( messageStoreFactory ),
+  m_settings( settings ),
+  m_pLogFactory( &logFactory ),
+  m_pLog( logFactory.create() ),
+  m_firstPoll( true ),
+  m_stop( true )
+{ initialize(); }
+
+void Initiator::initialize() throw ( 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()) )
+      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 )
+{
+  Locker l(m_mutex);
+  return m_pending.find( sessionID ) != m_pending.end();
+}
+
+bool Initiator::isConnected( const SessionID& sessionID )
+{
+  Locker l(m_mutex);
+  return m_connected.find( sessionID ) != m_connected.end();
+}
+
+bool Initiator::isDisconnected( const SessionID& sessionID )
+{
+  Locker l(m_mutex);
+  return m_disconnected.find( sessionID ) != m_disconnected.end();
+}
+
+void Initiator::start() throw ( ConfigError, RuntimeError )
+{
+  m_stop = false;
+  onConfigure( m_settings );
+  onInitialize( m_settings );
+
+  HttpServer::startGlobal( m_settings );
+
+  if( !thread_spawn( &startThread, this, m_threadid ) )
+    throw RuntimeError("Unable to spawn thread");
+}
+
+
+void Initiator::block() throw ( ConfigError, RuntimeError )
+{
+  m_stop = false;
+  onConfigure( m_settings );
+  onInitialize( m_settings );
+
+  startThread(this);
+}
+
+bool Initiator::poll( double timeout ) throw ( ConfigError, RuntimeError )
+{
+  if( m_firstPoll )
+  {
+    m_stop = false;
+    onConfigure( m_settings );
+    onInitialize( m_settings );
+    connect();
+    m_firstPoll = false;
+  }
+
+  return onPoll( timeout );
+}
+
+void Initiator::stop( bool force )
+{
+  if( isStopped() ) return;
+
+  HttpServer::stopGlobal();
+
+  std::vector<Session*> enabledSessions;
+
+  SessionIDs 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;
+
+  std::vector<Session*>::iterator session = enabledSessions.begin();
+  for( ; session != enabledSessions.end(); ++session )
+    (*session)->logon();
+}
+
+bool Initiator::isLoggedOn()
+{
+  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 );
+  pInitiator->onStart();
+  return 0;
+}
+}

data/ext/quickfix/Initiator.h

@@ -0,0 +1,149 @@
+/* -*- 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 "MessageStore.h"
+#include "Log.h"
+#include "Responder.h"
+#include "SessionSettings.h"
+#include "Exceptions.h"
+#include "Mutex.h"
+#include "Session.h"
+#include <set>
+#include <map>
+#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& ) throw( ConfigError );
+  Initiator( Application&, MessageStoreFactory&,
+             const SessionSettings&, LogFactory& ) throw( ConfigError );
+
+  virtual ~Initiator();
+
+  /// Start initiator.
+  void start() throw ( ConfigError, RuntimeError );
+  /// Block on the initiator
+  void block() throw ( ConfigError, RuntimeError );
+  /// Poll the initiator
+  bool poll( double timeout = 0.0 ) throw ( ConfigError, RuntimeError );
+
+  /// Stop initiator.
+  void stop( bool force = false );
+
+  /// Check to see if any sessions are currently logged on
+  bool isLoggedOn();
+
+  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 )
+  { return m_sessions.find( id ) != m_sessions.end(); }
+
+  bool isStopped() { return m_stop; }
+
+public:
+  Application& getApplication() { return m_application; }
+  MessageStoreFactory& getMessageStoreFactory()
+  { 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& );
+  bool isConnected( const SessionID& );
+  bool isDisconnected( const SessionID& );
+  void connect();
+
+private:
+  void initialize() throw ( ConfigError );
+
+  /// Implemented to configure acceptor
+  virtual void onConfigure( const SessionSettings& ) throw ( ConfigError ) {};
+  /// Implemented to initialize initiator
+  virtual void onInitialize( const SessionSettings& ) throw ( RuntimeError ) {};
+  /// Implemented to start connecting to targets.
+  virtual void onStart() = 0;
+  /// Implemented to connect and poll for events.
+  virtual bool onPoll( double timeout ) = 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;
+  SessionSettings m_settings;
+  LogFactory* m_pLogFactory;
+  Log* m_pLog;
+  NullLog m_nullLog;
+  bool m_firstPoll;
+  bool m_stop;
+  Mutex m_mutex;
+};
+/*! @} */
+}
+
+#endif // FIX_INITIATOR_H

data/ext/quickfix/Log.cpp

@@ -0,0 +1,77 @@
+/****************************************************************************
+** 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 )
+{  
+  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

data/ext/quickfix/Log.h

@@ -0,0 +1,179 @@
+/* -*- 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_LOG_H
+#define FIX_LOG_H
+
+#ifdef _MSC_VER
+#pragma warning( disable : 4503 4355 4786 4290 )
+#endif
+
+#include "Message.h"
+#include "Mutex.h"
+#include "SessionSettings.h"
+#include <map>
+#include <vector>
+
+namespace FIX
+{
+class Log;
+
+/**
+ * This interface must be implemented to create a Log.
+ */
+class LogFactory
+{
+public:
+  virtual ~LogFactory() {}
+  virtual Log* create() = 0;
+  virtual Log* create( const SessionID& ) = 0;
+  virtual void destroy( Log* ) = 0;
+};
+
+/**
+ * Creates a screen based implementation of Log.
+ *
+ * This displays all log events onto the standard output
+ */
+class ScreenLogFactory : public LogFactory
+{
+public:
+  ScreenLogFactory( const SessionSettings& settings )
+: m_useSettings( true ), m_settings( settings ) {};
+  ScreenLogFactory( bool incoming, bool outgoing, bool event )
+: m_incoming( incoming ), m_outgoing( outgoing ), m_event( event ), m_useSettings( false ) {}
+
+  Log* create();
+  Log* create( const SessionID& );
+  void destroy( Log* log );
+
+private:
+  void init( const Dictionary& settings, bool& incoming, bool& outgoing, bool& event );
+
+  bool m_incoming;
+  bool m_outgoing;
+  bool m_event;
+  bool m_useSettings;
+  SessionSettings m_settings;
+};
+
+/**
+ * This interface must be implemented to log messages and events
+ */
+class Log
+{
+public:
+  virtual ~Log() {}
+
+  virtual void clear() = 0;
+  virtual void backup() = 0;
+  virtual void onIncoming( const std::string& ) = 0;
+  virtual void onOutgoing( const std::string& ) = 0;
+  virtual void onEvent( const std::string& ) = 0;
+};
+/*! @} */
+
+/**
+ * Null implementation of Log
+ *
+ * This is only for internal use. Used when no log factory is
+ * passed to the initiator or acceptor.
+ */
+class NullLog : public Log
+{
+public:
+  void clear() {}
+  void backup() {}
+  void onIncoming( const std::string& ) {}
+  void onOutgoing( const std::string& ) {}
+  void onEvent( const std::string& ) {}
+};
+
+/**
+ * Screen based implementation of Log.
+ *
+ * This will display all log information onto the standard output
+ */
+class ScreenLog : public Log
+{
+public:
+  ScreenLog( bool incoming, bool outgoing, bool event ) 
+: m_prefix( "GLOBAL" ),
+  m_incoming( incoming ), m_outgoing( outgoing ), m_event( event ), m_millisecondsInTimeStamp( true ) {}
+
+  ScreenLog( const SessionID& sessionID,
+             bool incoming, bool outgoing, bool event )
+: m_prefix( sessionID.toString() ),
+  m_incoming( incoming ), m_outgoing( outgoing ), m_event( event ), m_millisecondsInTimeStamp( true ) {}
+
+  void clear() {}
+  void backup() {}
+
+  void onIncoming( const std::string& value )
+  {
+    if ( !m_incoming ) return ;
+    Locker l( s_mutex );
+    m_time.setCurrent();
+    std::cout << "<" << UtcTimeStampConvertor::convert(m_time, m_millisecondsInTimeStamp)
+              << ", " << m_prefix
+              << ", " << "incoming>" << std::endl
+              << "  (" << value << ")" << std::endl;
+  }
+
+  void onOutgoing( const std::string& value )
+  {
+    if ( !m_outgoing ) return ;
+    Locker l( s_mutex );
+    m_time.setCurrent();
+    std::cout << "<" << UtcTimeStampConvertor::convert(m_time, m_millisecondsInTimeStamp)
+              << ", " << m_prefix
+              << ", " << "outgoing>" << std::endl
+              << "  (" << value << ")" << std::endl;
+  }
+
+  void onEvent( const std::string& value )
+  {
+    if ( !m_event ) return ;
+    Locker l( s_mutex );
+    m_time.setCurrent();
+    std::cout << "<" << UtcTimeStampConvertor::convert(m_time, m_millisecondsInTimeStamp)
+              << ", " << m_prefix
+              << ", " << "event>" << std::endl
+              << "  (" << value << ")" << std::endl;
+  }
+
+  bool getMillisecondsInTimeStamp() const
+  { return m_millisecondsInTimeStamp; }
+  void setMillisecondsInTimeStamp ( bool value )
+  { m_millisecondsInTimeStamp = value; }
+
+private:
+  std::string m_prefix;
+  UtcTimeStamp m_time;
+  bool m_incoming;
+  bool m_outgoing;
+  bool m_event;
+  static Mutex s_mutex;
+  bool m_millisecondsInTimeStamp;
+};
+}
+
+#endif //FIX_LOG_H