quickfix_ruby 1.14.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 273ec93036845c75bb3992748ac4a18b5a27721c
+  data.tar.gz: 67cdb7e016febd27f95b432b64a7bb6898d150da
+SHA512:
+  metadata.gz: fdf77c96cbcff9b6ed2310b101cdde95d2aa23b82b3a63525ebf53e60b5f2e943d1b914e72128a462081719e127f307e07906e22502d035ab4552138ed52fa71
+  data.tar.gz: 5a416f856999eaffe2485505634a7f05ade0a92263de45ed98b2b7215c30784a95b3d95347b609f77401e4c5514e5470fc722422142c3428008f900d1f92f1bd

data/ext/quickfix/Acceptor.cpp

@@ -0,0 +1,248 @@
+/****************************************************************************
+** 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 "Acceptor.h"
+#include "Utility.h"
+#include "Session.h"
+#include "SessionFactory.h"
+#include "HttpServer.h"
+#include <algorithm>
+#include <fstream>
+
+namespace FIX
+{
+Acceptor::Acceptor( 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();
+}
+
+Acceptor::Acceptor( 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 Acceptor::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( CONNECTION_TYPE ) == "acceptor" )
+    {
+      m_sessionIDs.insert( *i );
+      m_sessions[ *i ] = factory.create( *i, m_settings.get( *i ) );
+    }
+  }
+
+  if ( !m_sessions.size() )
+    throw ConfigError( "No sessions defined for acceptor" );
+}
+
+Acceptor::~Acceptor()
+{
+  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* Acceptor::getSession
+( const std::string& msg, Responder& responder )
+{
+  Message message;
+  if ( !message.setStringHeader( msg ) )
+    return 0;
+
+  BeginString beginString;
+  SenderCompID clSenderCompID;
+  TargetCompID clTargetCompID;
+  MsgType msgType;
+  try
+  {
+    message.getHeader().getField( beginString );
+    message.getHeader().getField( clSenderCompID );
+    message.getHeader().getField( clTargetCompID );
+    message.getHeader().getField( msgType );
+    if ( msgType != "A" ) return 0;
+
+    SenderCompID senderCompID( clTargetCompID );
+    TargetCompID targetCompID( clSenderCompID );
+    SessionID sessionID( beginString, senderCompID, targetCompID );
+
+    Sessions::iterator i = m_sessions.find( sessionID );
+    if ( i != m_sessions.end() )
+    {
+      i->second->setResponder( &responder );
+      return i->second;
+    }
+  }
+  catch ( FieldNotFound& ) {}
+  return 0;
+}
+
+Session* Acceptor::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 Acceptor::getSessionSettings( const SessionID& sessionID ) const
+{
+  try
+  {
+    return &m_settings.get( sessionID );
+  }
+  catch( ConfigError& )
+  {
+    return 0;
+  }
+}
+
+void Acceptor::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 Acceptor::block() throw ( ConfigError, RuntimeError )
+{
+  m_stop = false;
+  onConfigure( m_settings );
+  onInitialize( m_settings );
+
+  startThread(this);
+}
+
+bool Acceptor::poll( double timeout ) throw ( ConfigError, RuntimeError )
+{
+  if( m_firstPoll )
+  {
+    m_stop = false;
+    onConfigure( m_settings );
+    onInitialize( m_settings );
+    m_firstPoll = false;
+  }
+
+  return onPoll( timeout );
+}
+
+void Acceptor::stop( bool force )
+{
+  if( isStopped() ) return;
+
+  HttpServer::stopGlobal();
+
+  std::vector<Session*> enabledSessions;
+
+  Sessions sessions = m_sessions;
+  Sessions::iterator i = sessions.begin();
+  for ( ; i != sessions.end(); ++i )
+  {
+    Session* pSession = Session::lookupSession(i->first);
+    if( pSession && pSession->isEnabled() )
+    {
+      enabledSessions.push_back( pSession );
+      pSession->logout();
+      Session::unregisterSession( pSession->getSessionID() );
+    }
+  }
+
+  if( !force )
+  {
+    for ( int second = 1; second <= 10 && isLoggedOn(); ++second )
+      process_sleep( 1 );
+  }
+
+  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 Acceptor::isLoggedOn()
+{
+  Sessions sessions = m_sessions;
+  Sessions::iterator i = sessions.begin();
+  for ( ; i != sessions.end(); ++i )
+  {
+    if( i->second->isLoggedOn() )
+      return true;
+  }
+  return false;
+}
+
+THREAD_PROC Acceptor::startThread( void* p )
+{
+  Acceptor * pAcceptor = static_cast < Acceptor* > ( p );
+  pAcceptor->onStart();
+  return 0;
+}
+}

data/ext/quickfix/Acceptor.h

@@ -0,0 +1,127 @@
+/* -*- 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_ACCEPTOR_H
+#define FIX_ACCEPTOR_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 <map>
+#include <string>
+
+namespace FIX
+{
+class Client;
+class Session;
+
+/**
+ * Base for classes which act as an acceptor for incoming connections.
+ *
+ * Most users will not need to implement one of these.  The default
+ * SocketAcceptor implementation will be used in most cases.
+ */
+class Acceptor
+{
+public:
+  Acceptor( Application&, MessageStoreFactory&,
+            const SessionSettings& ) throw( ConfigError );
+  Acceptor( Application&, MessageStoreFactory&,
+            const SessionSettings&, LogFactory& ) throw( ConfigError );
+
+  virtual ~Acceptor();
+
+  Log* getLog() 
+  { 
+    if( m_pLog ) return m_pLog;
+    return &m_nullLog;
+  }
+
+  /// Start acceptor.
+  void start() throw ( ConfigError, RuntimeError );
+  /// Block on the acceptor
+  void block() throw ( ConfigError, RuntimeError );
+  /// Poll the acceptor
+  bool poll( double timeout = 0.0 ) throw ( ConfigError, RuntimeError );
+
+  /// Stop acceptor.
+  void stop( bool force = false );
+
+  /// Check to see if any sessions are currently logged on
+  bool isLoggedOn();
+
+  Session* getSession( const std::string& msg, 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; }
+
+  Application& getApplication() { return m_application; }
+  MessageStoreFactory& getMessageStoreFactory()
+  { return m_messageStoreFactory; }
+
+private:
+  void initialize() throw ( ConfigError );
+
+  /// Implemented to configure acceptor
+  virtual void onConfigure( const SessionSettings& ) throw ( ConfigError ) {};
+  /// Implemented to initialize acceptor
+  virtual void onInitialize( const SessionSettings& ) throw ( RuntimeError ) {};
+  /// Implemented to start listening for connections.
+  virtual void onStart() = 0;
+  /// Implemented to connect and poll for events.
+  virtual bool onPoll( double second ) = 0;
+  /// Implemented to stop a running acceptor.
+  virtual void onStop() = 0;
+
+  static THREAD_PROC startThread( void* p );
+
+  typedef std::set < SessionID > SessionIDs;
+  typedef std::map < SessionID, Session* > Sessions;
+
+  thread_id m_threadid;
+  Sessions m_sessions;
+  SessionIDs m_sessionIDs;
+  Application& m_application;
+  MessageStoreFactory& m_messageStoreFactory;
+  SessionSettings m_settings;
+  LogFactory* m_pLogFactory;
+  Log* m_pLog;
+  NullLog m_nullLog;
+  bool m_firstPoll;
+  bool m_stop;
+};
+/*! @} */
+}
+
+#endif // FIX_ACCEPTOR_H

data/ext/quickfix/Allocator.h

@@ -0,0 +1,9 @@
+/* #undef ENABLE_BITMAP_ALLOCATOR */
+/* #undef ENABLE_BOOST_FAST_POOL_ALLOCATOR */
+/* #undef ENABLE_BOOST_POOL_ALLOCATOR */
+/* #undef ENABLE_DEBUG_ALLOCATOR */
+/* #undef ENABLE_MT_ALLOCATOR */
+/* #undef ENABLE_NEW_ALLOCATOR */
+/* #undef ENABLE_POOL_ALLOCATOR */
+/* #undef ENABLE_TBB_ALLOCATOR */
+/* #undef HAVE_ALLOCATOR_CONFIG */

data/ext/quickfix/Application.h

@@ -0,0 +1,127 @@
+/* -*- 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_APPLICATION_H
+#define FIX_APPLICATION_H
+
+#include "Message.h"
+#include "SessionID.h"
+#include "Mutex.h"
+
+namespace FIX
+{
+/**
+ * This interface must be implemented to define what your %FIX application
+ * does.
+ *
+ * These methods notify your application about events that happen on
+ * active %FIX sessions. There is no guarantee how many threads will be calling
+ * these functions. If the application is sharing resources among multiple sessions,
+ * you must synchronize those resources. You can also use the SynchronizedApplication
+ * class to automatically synchronize all function calls into your application.
+ * The various MessageCracker classes can be used to parse the generic message
+ * structure into specific %FIX messages.
+ */
+class Application
+{
+public:
+  virtual ~Application() {};
+  /// Notification of a session begin created
+  virtual void onCreate( const SessionID& ) = 0;
+  /// Notification of a session successfully logging on
+  virtual void onLogon( const SessionID& ) = 0;
+  /// Notification of a session logging off or disconnecting
+  virtual void onLogout( const SessionID& ) = 0;
+  /// Notification of admin message being sent to target
+  virtual void toAdmin( Message&, const SessionID& ) = 0;
+  /// Notification of app message being sent to target
+  virtual void toApp( Message&, const SessionID& )
+  throw( DoNotSend ) = 0;
+  /// Notification of admin message being received from target
+  virtual void fromAdmin( const Message&, const SessionID& )
+  throw( FieldNotFound, IncorrectDataFormat, IncorrectTagValue, RejectLogon ) = 0;
+  /// Notification of app message being received from target
+  virtual void fromApp( const Message&, const SessionID& )
+  throw( FieldNotFound, IncorrectDataFormat, IncorrectTagValue, UnsupportedMessageType ) = 0;
+};
+
+/**
+* This is a special implementation of the Application interface that takes
+* in another Application interface and synchronizes all of its callbacks. This
+* will guarantee that only one thread will access the applications code at a time.
+*
+* This class is a great convenience for writing applications where you
+* don't want to worry about synchronization. There is of course a tradeoff
+* in that you may be synchronizing more than you need to. There is also a very
+* minor performance penalty due to the extra virtual table lookup.
+*/
+class SynchronizedApplication : public Application
+{
+public:
+  SynchronizedApplication( Application& app ) : m_app( app ) {}
+
+  void onCreate( const SessionID& sessionID )
+  { Locker l( m_mutex ); app().onCreate( sessionID ); }
+  void onLogon( const SessionID& sessionID )
+  { Locker l( m_mutex ); app().onLogon( sessionID ); }
+  void onLogout( const SessionID& sessionID )
+  { Locker l( m_mutex ); app().onLogout( sessionID ); }
+  void toAdmin( Message& message, const SessionID& sessionID )
+  { Locker l( m_mutex ); app().toAdmin( message, sessionID ); }
+  void toApp( Message& message, const SessionID& sessionID )
+  throw( DoNotSend )
+  { Locker l( m_mutex ); app().toApp( message, sessionID ); }
+  void fromAdmin( const Message& message, const SessionID& sessionID )
+  throw( FieldNotFound, IncorrectDataFormat, IncorrectTagValue, RejectLogon )
+  { Locker l( m_mutex ); app().fromAdmin( message, sessionID ); }
+  void fromApp( const Message& message, const SessionID& sessionID )
+  throw( FieldNotFound, IncorrectDataFormat, IncorrectTagValue, UnsupportedMessageType )
+  { Locker l( m_mutex ); app().fromApp( message, sessionID ); }
+
+  Mutex m_mutex;
+
+  Application& app() { return m_app; }
+  Application& m_app;
+};
+
+/**
+* An empty implementation of an Application. This can be used if you
+* do not want to provide an implementation for all the callback methods.
+* It is also useful for unit tests writing unit tests where the callback
+* values of some or all methods are not of interest.
+*/
+class NullApplication : public Application
+{
+  void onCreate( const SessionID& ) {}
+  void onLogon( const SessionID& ) {}
+  void onLogout( const SessionID& ) {}
+  void toAdmin( Message&, const SessionID& ) {}
+  void toApp( Message&, const SessionID& )
+  throw( DoNotSend ) {}
+  void fromAdmin( const Message&, const SessionID& )
+  throw( FieldNotFound, IncorrectDataFormat, IncorrectTagValue, RejectLogon ) {}
+  void fromApp( const Message&, const SessionID& )
+  throw( FieldNotFound, IncorrectDataFormat, IncorrectTagValue, UnsupportedMessageType ) {}
+};
+/*! @} */
+}
+
+#endif //FIX_APPLICATION_H

data/ext/quickfix/AtomicCount.h

@@ -0,0 +1,109 @@
+/* -*- 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 ATOMIC_COUNT
+#define ATOMIC_COUNT
+
+#include "Mutex.h"
+
+namespace FIX
+{
+  /// Atomic count class - consider using interlocked functions
+
+#ifdef ENABLE_BOOST_ATOMIC_COUNT
+
+#include <boost/smart_ptr/detail/atomic_count.hpp>
+typedef boost::detail::atomic_count atomic_count;
+
+#elif _MSC_VER 
+
+  //atomic counter based on interlocked functions for Win32
+  class atomic_count
+  {
+  public:
+    explicit atomic_count( long v ): m_counter( v )
+    {
+    }
+
+    long operator++()
+    {
+      return ::InterlockedIncrement( &m_counter );
+    }
+
+    long operator--()
+    {
+      return ::InterlockedDecrement( &m_counter );
+    }
+
+    operator long() const
+    {
+      return static_cast<long const volatile &>( m_counter );
+    }
+
+  private:
+
+    atomic_count( atomic_count const & );
+    atomic_count & operator=( atomic_count const & );
+
+    long volatile m_counter;
+  };
+
+#else
+  // general purpose atomic counter using mutexes
+  class atomic_count
+  {
+  public:
+    explicit atomic_count( long v ): m_counter( v )
+    {
+    }
+
+    long operator++()
+    {
+      Locker _lock(m_mutex);
+      return ++m_counter;
+    }
+
+    long operator--()
+    {
+      Locker _lock(m_mutex);
+      return --m_counter;
+    }
+
+    operator long() const
+    {
+      return static_cast<long const volatile &>( m_counter );
+    }
+
+  private:
+
+    atomic_count( atomic_count const & );
+    atomic_count & operator=( atomic_count const & );
+
+    Mutex m_mutex;
+    long m_counter;
+  };
+
+#endif
+
+}
+
+#endif
+

data/ext/quickfix/DOMDocument.h

@@ -0,0 +1,74 @@
+/* -*- 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_DOMDOCUMENT_H
+#define FIX_DOMDOCUMENT_H
+
+#include <string>
+#include <map>
+#include <iostream>
+#include <memory>
+
+namespace FIX
+{
+  /// Interface that represents attribute from underlying XML parser.
+  class DOMAttributes
+  {
+  public:
+    typedef std::map<std::string, std::string> map;
+
+    virtual ~DOMAttributes() {}
+
+    virtual bool get( const std::string&, std::string& ) = 0;
+    virtual map toMap() = 0;
+  };
+  typedef std::auto_ptr<DOMAttributes> DOMAttributesPtr;
+
+  /// Interface that represents node from underlying XML parser.
+  class DOMNode
+  {
+  public:
+    virtual ~DOMNode() {}
+
+    virtual std::auto_ptr<DOMNode> getFirstChildNode() = 0;
+    virtual std::auto_ptr<DOMNode> getNextSiblingNode() = 0;
+    virtual std::auto_ptr<DOMAttributes> getAttributes() = 0;
+    virtual std::string getName() = 0;
+    virtual std::string getText() = 0;
+  };
+  typedef std::auto_ptr<DOMNode> DOMNodePtr;
+
+  /// Interface that represents document of underlying XML parser.
+  class DOMDocument
+  {
+  public:
+    virtual ~DOMDocument() {}
+
+    virtual bool load( std::istream& ) = 0;
+    virtual bool load( const std::string& ) = 0;
+    virtual bool xml( std::ostream& ) = 0;
+
+    virtual std::auto_ptr<DOMNode> getNode( const std::string& ) = 0;
+  };
+  typedef std::auto_ptr<DOMDocument> DOMDocumentPtr;
+}
+
+#endif