quickfix_ruby 1.14.3

data/ext/quickfix/OdbcStore.cpp

@@ -0,0 +1,338 @@
+/****************************************************************************
+** 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
+
+#ifdef HAVE_ODBC
+
+#ifndef SQLLEN
+#define SQLLEN SQLINTEGER
+#endif
+
+#include "OdbcStore.h"
+#include "SessionID.h"
+#include "SessionSettings.h"
+#include "FieldConvertors.h"
+#include "Parser.h"
+#include "Utility.h"
+#include "strptime.h"
+#include <fstream>
+
+namespace FIX
+{
+
+const std::string OdbcStoreFactory::DEFAULT_USER = "sa";
+const std::string OdbcStoreFactory::DEFAULT_PASSWORD = "";
+const std::string OdbcStoreFactory::DEFAULT_CONNECTION_STRING 
+  = "DATABASE=quickfix;DRIVER={SQL Server};SERVER=(local);";
+
+OdbcStore::OdbcStore
+( const SessionID& s, const std::string& user, const std::string& password, 
+  const std::string& connectionString )
+  : m_sessionID( s )
+{
+  m_pConnection = new OdbcConnection( user, password, connectionString );
+  populateCache();
+}
+
+OdbcStore::~OdbcStore()
+{
+  delete m_pConnection;
+}
+
+void OdbcStore::populateCache()
+{
+  std::stringstream queryString;
+
+  queryString << "SELECT creation_time, incoming_seqnum, outgoing_seqnum FROM sessions WHERE "
+  << "beginstring=" << "'" << m_sessionID.getBeginString().getValue() << "' and "
+  << "sendercompid=" << "'" << m_sessionID.getSenderCompID().getValue() << "' and "
+  << "targetcompid=" << "'" << m_sessionID.getTargetCompID().getValue() << "' and "
+  << "session_qualifier=" << "'" << m_sessionID.getSessionQualifier() << "'";
+
+  OdbcQuery query( queryString.str() );
+
+  if( !m_pConnection->execute(query) )
+    throw ConfigError( "Unable to connect to database" );
+  
+  int rows = 0;
+  while( query.fetch() )
+  {
+    rows++;
+    if( rows > 1 )
+      throw ConfigError( "Multiple entries found for session in database" );
+
+    SQL_TIMESTAMP_STRUCT creationTime;  
+    SQLLEN creationTimeLength;
+    SQLGetData( query.statement(), 1, SQL_C_TYPE_TIMESTAMP, &creationTime, 0, &creationTimeLength );
+    SQLLEN incomingSeqNum;
+    SQLLEN incomingSeqNumLength;
+    SQLGetData( query.statement(), 2, SQL_C_SLONG, &incomingSeqNum, 0, &incomingSeqNumLength );
+
+    SQLLEN outgoingSeqNum;
+    SQLLEN outgoingSeqNumLength;
+    SQLGetData( query.statement(), 3, SQL_C_SLONG, &outgoingSeqNum, 0, &outgoingSeqNumLength );
+
+    UtcTimeStamp time;
+    time.setYMD( creationTime.year, creationTime.month, creationTime.day );
+    time.setHMS( creationTime.hour, creationTime.minute, creationTime.second, creationTime.fraction );
+    m_cache.setCreationTime( time );
+    m_cache.setNextTargetMsgSeqNum( incomingSeqNum );
+    m_cache.setNextSenderMsgSeqNum( outgoingSeqNum );
+  }
+  query.close();
+
+  if( rows == 0 )
+  {
+    UtcTimeStamp time = m_cache.getCreationTime();
+    char sqlTime[ 20 ];
+    int year, month, day, hour, minute, second, millis;
+    time.getYMD (year, month, day);
+    time.getHMS (hour, minute, second, millis);
+    STRING_SPRINTF (sqlTime, "%d-%02d-%02d %02d:%02d:%02d",
+             year, month, day, hour, minute, second);
+    std::stringstream queryString2;
+    queryString2 << "INSERT INTO sessions (beginstring, sendercompid, targetcompid, session_qualifier,"
+    << "creation_time, incoming_seqnum, outgoing_seqnum) VALUES("
+    << "'" << m_sessionID.getBeginString().getValue() << "',"
+    << "'" << m_sessionID.getSenderCompID().getValue() << "',"
+    << "'" << m_sessionID.getTargetCompID().getValue() << "',"
+    << "'" << m_sessionID.getSessionQualifier() << "',"
+    << "{ts '" << sqlTime << "'},"
+    << m_cache.getNextTargetMsgSeqNum() << ","
+    << m_cache.getNextSenderMsgSeqNum() << ")";
+
+    OdbcQuery query2( queryString2.str() );
+    if( !m_pConnection->execute(query2) )
+      throw ConfigError( "Unable to create session in database" );
+  }
+}
+
+MessageStore* OdbcStoreFactory::create( const SessionID& s )
+{
+  if( m_useSettings )
+    return create( s, m_settings.get(s) );
+  else if( m_useDictionary )
+    return create( s, m_dictionary );
+  else
+    return new OdbcStore( s, m_user, m_password, m_connectionString );
+}
+
+void OdbcStoreFactory::destroy( MessageStore* pStore )
+{
+  delete pStore;
+}
+
+MessageStore* OdbcStoreFactory::create( const SessionID& s, const Dictionary& settings )
+{
+  std::string user = DEFAULT_USER;
+  std::string password = DEFAULT_PASSWORD;
+  std::string connectionString = DEFAULT_CONNECTION_STRING;
+
+  try { user = settings.getString( ODBC_STORE_USER ); }
+  catch( ConfigError& ) {}
+
+  try { password = settings.getString( ODBC_STORE_PASSWORD ); }
+  catch( ConfigError& ) {}
+
+  try { connectionString = settings.getString( ODBC_STORE_CONNECTION_STRING ); }
+  catch( ConfigError& ) {}
+
+  return new OdbcStore( s, user, password, connectionString );
+}
+
+bool OdbcStore::set( int msgSeqNum, const std::string& msg )
+throw ( IOException )
+{
+  std::string msgCopy = msg;
+  string_replace( "'", "''", msgCopy );
+
+  std::stringstream queryString;
+  queryString << "INSERT INTO messages "
+  << "(beginstring, sendercompid, targetcompid, session_qualifier, msgseqnum, message) "
+  << "VALUES ("
+  << "'" << m_sessionID.getBeginString().getValue() << "',"
+  << "'" << m_sessionID.getSenderCompID().getValue() << "',"
+  << "'" << m_sessionID.getTargetCompID().getValue() << "',"
+  << "'" << m_sessionID.getSessionQualifier() << "',"
+  << msgSeqNum << ","
+  << "'" << msgCopy << "')";
+
+  OdbcQuery query( queryString.str() );
+  if( !m_pConnection->execute(query) )
+  {
+    query.close();
+    std::stringstream queryString2;
+    queryString2 << "UPDATE messages SET message='" << msgCopy << "' WHERE "
+    << "beginstring=" << "'" << m_sessionID.getBeginString().getValue() << "' and "
+    << "sendercompid=" << "'" << m_sessionID.getSenderCompID().getValue() << "' and "
+    << "targetcompid=" << "'" << m_sessionID.getTargetCompID().getValue() << "' and "
+    << "session_qualifier=" << "'" << m_sessionID.getSessionQualifier() << "' and "
+    << "msgseqnum=" << msgSeqNum;
+    OdbcQuery query2( queryString2.str() );
+    if( !m_pConnection->execute(query2) )
+      query2.throwException();
+  }
+  return true;
+}
+
+void OdbcStore::get( int begin, int end,
+                    std::vector < std::string > & result ) const
+throw ( IOException )
+{
+  result.clear();
+  std::stringstream queryString;
+  queryString << "SELECT message FROM messages WHERE "
+  << "beginstring=" << "'" << m_sessionID.getBeginString().getValue() << "' and "
+  << "sendercompid=" << "'" << m_sessionID.getSenderCompID().getValue() << "' and "
+  << "targetcompid=" << "'" << m_sessionID.getTargetCompID().getValue() << "' and "
+  << "session_qualifier=" << "'" << m_sessionID.getSessionQualifier() << "' and "
+  << "msgseqnum>=" << begin << " and " << "msgseqnum<=" << end << " "
+  << "ORDER BY msgseqnum";
+
+  OdbcQuery query( queryString.str() );
+
+  if( !m_pConnection->execute(query) )
+    query.throwException();
+
+  while( query.fetch() )
+  {
+    std::string message;
+    SQLVARCHAR messageBuffer[4096];
+    SQLLEN messageLength;
+
+    while( odbcSuccess(SQLGetData( query.statement(), 1, SQL_C_CHAR, &messageBuffer, 4095, &messageLength)) )
+    {  
+      messageBuffer[messageLength] = 0;
+      message += (char*)messageBuffer;
+    }
+
+    result.push_back( message );
+  }
+}
+
+int OdbcStore::getNextSenderMsgSeqNum() const throw ( IOException )
+{
+  return m_cache.getNextSenderMsgSeqNum();
+}
+
+int OdbcStore::getNextTargetMsgSeqNum() const throw ( IOException )
+{
+  return m_cache.getNextTargetMsgSeqNum();
+}
+
+void OdbcStore::setNextSenderMsgSeqNum( int value ) throw ( IOException )
+{
+  std::stringstream queryString;
+  queryString << "UPDATE sessions SET outgoing_seqnum=" << value << " WHERE "
+  << "beginstring=" << "'" << m_sessionID.getBeginString().getValue() << "' and "
+  << "sendercompid=" << "'" << m_sessionID.getSenderCompID().getValue() << "' and "
+  << "targetcompid=" << "'" << m_sessionID.getTargetCompID().getValue() << "' and "
+  << "session_qualifier=" << "'" << m_sessionID.getSessionQualifier() << "'";
+  OdbcQuery query( queryString.str() );
+  if( !m_pConnection->execute(query) )
+    query.throwException();
+  m_cache.setNextSenderMsgSeqNum( value );
+}
+
+void OdbcStore::setNextTargetMsgSeqNum( int value ) throw ( IOException )
+{
+  std::stringstream queryString;
+  queryString << "UPDATE sessions SET incoming_seqnum=" << value << " WHERE "
+  << "beginstring=" << "'" << m_sessionID.getBeginString().getValue() << "' and "
+  << "sendercompid=" << "'" << m_sessionID.getSenderCompID().getValue() << "' and "
+  << "targetcompid=" << "'" << m_sessionID.getTargetCompID().getValue() << "' and "
+  << "session_qualifier=" << "'" << m_sessionID.getSessionQualifier() << "'";
+
+  OdbcQuery query( queryString.str() );
+  if( !m_pConnection->execute(query) )
+    query.throwException();
+
+  m_cache.setNextTargetMsgSeqNum( value );
+}
+
+void OdbcStore::incrNextSenderMsgSeqNum() throw ( IOException )
+{
+  m_cache.incrNextSenderMsgSeqNum();
+  setNextSenderMsgSeqNum( m_cache.getNextSenderMsgSeqNum() );
+}
+
+void OdbcStore::incrNextTargetMsgSeqNum() throw ( IOException )
+{
+  m_cache.incrNextTargetMsgSeqNum();
+  setNextTargetMsgSeqNum( m_cache.getNextTargetMsgSeqNum() );
+}
+
+UtcTimeStamp OdbcStore::getCreationTime() const throw ( IOException )
+{
+  return m_cache.getCreationTime();
+}
+
+void OdbcStore::reset() throw ( IOException )
+{
+  std::stringstream queryString;
+  queryString << "DELETE FROM messages WHERE "
+  << "beginstring=" << "'" << m_sessionID.getBeginString().getValue() << "' and "
+  << "sendercompid=" << "'" << m_sessionID.getSenderCompID().getValue() << "' and "
+  << "targetcompid=" << "'" << m_sessionID.getTargetCompID().getValue() << "' and "
+  << "session_qualifier=" << "'" << m_sessionID.getSessionQualifier() << "'";
+
+  OdbcQuery query( queryString.str() );
+  if( !m_pConnection->execute(query) )
+    query.throwException();
+  query.close();
+
+  m_cache.reset();
+  UtcTimeStamp time = m_cache.getCreationTime();
+
+  int year, month, day, hour, minute, second, millis;
+  time.getYMD( year, month, day );
+  time.getHMS( hour, minute, second, millis );
+
+  char sqlTime[ 20 ];
+  STRING_SPRINTF( sqlTime, "%d-%02d-%02d %02d:%02d:%02d",
+           year, month, day, hour, minute, second );
+
+  std::stringstream queryString2;
+  queryString2 << "UPDATE sessions SET creation_time={ts '" << sqlTime << "'}, "
+  << "incoming_seqnum=" << m_cache.getNextTargetMsgSeqNum() << ", "
+  << "outgoing_seqnum=" << m_cache.getNextSenderMsgSeqNum() << " WHERE "
+  << "beginstring=" << "'" << m_sessionID.getBeginString().getValue() << "' and "
+  << "sendercompid=" << "'" << m_sessionID.getSenderCompID().getValue() << "' and "
+  << "targetcompid=" << "'" << m_sessionID.getTargetCompID().getValue() << "' and "
+  << "session_qualifier=" << "'" << m_sessionID.getSessionQualifier() << "'";
+
+  OdbcQuery query2( queryString2.str() );
+  if( !m_pConnection->execute(query2) )
+    query2.throwException();
+}
+
+void OdbcStore::refresh() throw ( IOException )
+{
+  m_cache.reset();
+  populateCache(); 
+}
+
+}
+
+#endif

data/ext/quickfix/OdbcStore.h

@@ -0,0 +1,113 @@
+/* -*- 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 HAVE_ODBC
+#error OdbcStore.h included, but HAVE_ODBC not defined
+#endif
+
+#ifdef HAVE_ODBC
+#ifndef FIX_ODBCSTORE_H
+#define FIX_ODBCSTORE_H
+
+#ifdef _MSC_VER
+#pragma warning( disable : 4503 4355 4786 4290 )
+#endif
+
+#include "OdbcConnection.h"
+#include "MessageStore.h"
+#include "SessionSettings.h"
+#include <fstream>
+#include <string>
+
+namespace FIX
+{
+/// Creates a Odbc based implementation of MessageStore.
+class OdbcStoreFactory : public MessageStoreFactory
+{
+public:
+  static const std::string DEFAULT_USER;
+  static const std::string DEFAULT_PASSWORD;
+  static const std::string DEFAULT_CONNECTION_STRING;
+
+  OdbcStoreFactory( const SessionSettings& settings )
+: m_settings( settings ), m_useSettings( true ), m_useDictionary( false ) {}
+
+  OdbcStoreFactory( const Dictionary& dictionary )
+: m_dictionary( dictionary ), m_useSettings( false ), m_useDictionary( true ) {}
+
+  OdbcStoreFactory( const std::string& user, const std::string& password, 
+                    const std::string& connectionString )
+: m_user( user ), m_password( password ), m_connectionString( connectionString ),
+  m_useSettings( false ), m_useDictionary( false ) {}
+
+  OdbcStoreFactory()
+: m_user( DEFAULT_USER ), m_password( DEFAULT_PASSWORD ),
+  m_connectionString( DEFAULT_CONNECTION_STRING ), m_useSettings( false ), m_useDictionary( false ) {}
+
+  MessageStore* create( const SessionID& );
+  void destroy( MessageStore* );
+private:
+  MessageStore* create( const SessionID& s, const Dictionary& );
+
+  Dictionary m_dictionary;
+  SessionSettings m_settings;
+  std::string m_user;
+  std::string m_password;
+  std::string m_connectionString;
+  bool m_useSettings;
+  bool m_useDictionary;
+};
+/*! @} */
+
+/// Odbc based implementation of MessageStore.
+class OdbcStore : public MessageStore
+{
+public:
+  OdbcStore( const SessionID& s, const std::string& user, const std::string& password, 
+             const std::string& connectionString );
+  ~OdbcStore();
+
+  bool set( int, const std::string& ) throw ( IOException );
+  void get( int, int, std::vector < std::string > & ) const throw ( IOException );
+
+  int getNextSenderMsgSeqNum() const throw ( IOException );
+  int getNextTargetMsgSeqNum() const throw ( IOException );
+  void setNextSenderMsgSeqNum( int value ) throw ( IOException );
+  void setNextTargetMsgSeqNum( int value ) throw ( IOException );
+  void incrNextSenderMsgSeqNum() throw ( IOException );
+  void incrNextTargetMsgSeqNum() throw ( IOException );
+
+  UtcTimeStamp getCreationTime() const throw ( IOException );
+
+  void reset() throw ( IOException );
+  void refresh() throw ( IOException );
+
+private:
+  void populateCache();
+
+  OdbcConnection* m_pConnection;
+  MemoryStore m_cache;
+  SessionID m_sessionID;
+};
+}
+
+#endif
+#endif

data/ext/quickfix/PUGIXML_DOMDocument.cpp

@@ -0,0 +1,112 @@
+/****************************************************************************
+** 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 "PUGIXML_DOMDocument.h"
+#include <sstream>
+
+namespace FIX
+{
+  bool PUGIXML_DOMAttributes::get( const std::string& name, std::string& value )
+  {
+    pugi::xml_attribute result = m_pNode.attribute(name.c_str());
+    if( !result ) return false;
+    value = result.value();
+    return true;
+  }
+
+  DOMAttributes::map PUGIXML_DOMAttributes::toMap()
+  {
+    return DOMAttributes::map();
+  }
+
+  DOMNodePtr PUGIXML_DOMNode::getFirstChildNode()
+  {
+    pugi::xml_node pNode = m_pNode.first_child();
+    if( !pNode ) return DOMNodePtr();
+    return DOMNodePtr(new PUGIXML_DOMNode(pNode));
+  }
+
+  DOMNodePtr PUGIXML_DOMNode::getNextSiblingNode()
+  {
+    pugi::xml_node pNode = m_pNode.next_sibling();
+    if( !pNode ) return DOMNodePtr();
+    return DOMNodePtr(new PUGIXML_DOMNode(pNode));
+  }
+
+  DOMAttributesPtr PUGIXML_DOMNode::getAttributes()
+  {
+    return DOMAttributesPtr(new PUGIXML_DOMAttributes(m_pNode));
+  }
+
+  std::string PUGIXML_DOMNode::getName()
+  {
+    return m_pNode.name();
+  }
+
+  std::string PUGIXML_DOMNode::getText()
+  {
+    return m_pNode.value();
+  }
+
+  PUGIXML_DOMDocument::PUGIXML_DOMDocument() throw( ConfigError )
+  {
+  }
+
+  PUGIXML_DOMDocument::~PUGIXML_DOMDocument()
+  {
+    //xmlFreeDoc(m_pDoc);
+  }
+
+  bool PUGIXML_DOMDocument::load( std::istream& stream )
+  {
+    try
+    {
+      return m_pDoc.load(stream);
+    }
+    catch( ... ) { return false; }
+  }
+
+  bool PUGIXML_DOMDocument::load( const std::string& url )
+  {
+    try
+    {
+      return m_pDoc.load_file(url.c_str());
+    }
+    catch( ... ) { return false; }
+  }
+
+  bool PUGIXML_DOMDocument::xml( std::ostream& out )
+  {
+    return false;
+  }
+
+  DOMNodePtr PUGIXML_DOMDocument::getNode( const std::string& XPath )
+  {
+    pugi::xpath_node result = m_pDoc.select_single_node(XPath.c_str());
+    if( !result ) return DOMNodePtr();
+
+    return DOMNodePtr(new PUGIXML_DOMNode(result.node()));
+  }
+}

data/ext/quickfix/PUGIXML_DOMDocument.h

@@ -0,0 +1,81 @@
+/* -*- 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_PUGIXMLDOMDOCUMENT_H
+#define FIX_PUGIXMLDOMDOCUMENT_H
+
+#include "DOMDocument.h"
+#include "Exceptions.h"
+#include "pugixml.hpp"
+
+namespace FIX
+{
+  /// XML attribute as represented by pugixml.
+  class PUGIXML_DOMAttributes : public DOMAttributes
+  {
+  public:
+    PUGIXML_DOMAttributes( pugi::xml_node pNode )
+    : m_pNode(pNode) {}
+
+    bool get( const std::string&, std::string& );
+    DOMAttributes::map toMap();
+
+  private:
+    pugi::xml_node m_pNode;
+  };
+
+  /// XML node as represented by pugixml.
+  class PUGIXML_DOMNode : public DOMNode
+  {
+  public:
+    PUGIXML_DOMNode( pugi::xml_node pNode )
+    : m_pNode(pNode) {}
+    ~PUGIXML_DOMNode() {}
+
+    DOMNodePtr getFirstChildNode();
+    DOMNodePtr getNextSiblingNode();
+    DOMAttributesPtr getAttributes();
+    std::string getName();
+    std::string getText();
+
+  private:
+    pugi::xml_node m_pNode;
+  };
+
+  /// XML document as represented by pugixml.
+  class PUGIXML_DOMDocument : public DOMDocument
+  {
+  public:
+    PUGIXML_DOMDocument() throw( ConfigError );
+    ~PUGIXML_DOMDocument();
+
+    bool load( std::istream& );
+    bool load( const std::string& );
+    bool xml( std::ostream& );
+
+    DOMNodePtr getNode( const std::string& );
+
+  private:
+    pugi::xml_document m_pDoc;
+  };
+}
+
+#endif