quickfix_ruby 1.14.3

data/ext/quickfix/MySQLStore.cpp

@@ -0,0 +1,331 @@
+/****************************************************************************
+** 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_MYSQL
+
+#include "MySQLStore.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 MySQLStoreFactory::DEFAULT_DATABASE = "quickfix";
+const std::string MySQLStoreFactory::DEFAULT_USER = "";
+const std::string MySQLStoreFactory::DEFAULT_PASSWORD = "";
+const std::string MySQLStoreFactory::DEFAULT_HOST = "localhost";
+const short MySQLStoreFactory::DEFAULT_PORT = 3306;
+
+MySQLStore::MySQLStore
+( const SessionID& s, const DatabaseConnectionID& d, MySQLConnectionPool* p )
+  : m_pConnectionPool( p ), m_sessionID( s )
+{
+  m_pConnection = m_pConnectionPool->create( d );
+  populateCache();
+}
+
+MySQLStore::MySQLStore
+( const SessionID& s, const std::string& database, const std::string& user,
+  const std::string& password, const std::string& host, short port )
+  : m_pConnectionPool( 0 ), m_sessionID( s )
+{
+  m_pConnection = new MySQLConnection( database, user, password, host, port );
+  populateCache();
+}
+
+MySQLStore::~MySQLStore()
+{
+  if( m_pConnectionPool )
+    m_pConnectionPool->destroy( m_pConnection );
+  else
+    delete m_pConnection;
+}
+
+void MySQLStore::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() << "\"";
+
+  MySQLQuery query( queryString.str() );
+  if( !m_pConnection->execute(query) )
+    throw ConfigError( "No entries found for session in database" );
+
+  int rows = query.rows();
+  if( rows > 1 )
+    throw ConfigError( "Multiple entries found for session in database" );
+
+  if( rows == 1 )
+  {
+    struct tm time;
+    std::string sqlTime = query.getValue( 0, 0 );
+    strptime( sqlTime.c_str(), "%Y-%m-%d %H:%M:%S", &time );
+    m_cache.setCreationTime (UtcTimeStamp (&time));
+    m_cache.setNextTargetMsgSeqNum( atol( query.getValue( 0, 1 ) ) );
+    m_cache.setNextSenderMsgSeqNum( atol( query.getValue( 0, 2 ) ) );
+  }
+  else
+  {
+    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() << "\","
+    << "'" << sqlTime << "',"
+    << m_cache.getNextTargetMsgSeqNum() << ","
+    << m_cache.getNextSenderMsgSeqNum() << ")";
+
+    MySQLQuery query2( queryString2.str() );
+    if( !m_pConnection->execute(query2) )
+      throw ConfigError( "Unable to create session in database" );
+  }
+}
+
+MessageStore* MySQLStoreFactory::create( const SessionID& s )
+{
+  if( m_useSettings )
+    return create( s, m_settings.get(s) );
+  else if( m_useDictionary )
+    return create( s, m_dictionary );
+  else
+  {
+    DatabaseConnectionID id( m_database, m_user, m_password, m_host, m_port );
+    return new MySQLStore( s, id, m_connectionPoolPtr.get() );
+  }
+}
+
+MessageStore* MySQLStoreFactory::create( const SessionID& s, const Dictionary& settings )
+{
+  std::string database = DEFAULT_DATABASE;
+  std::string user = DEFAULT_USER;
+  std::string password = DEFAULT_PASSWORD;
+  std::string host = DEFAULT_HOST;
+  short port = DEFAULT_PORT;
+
+  try { database = settings.getString( MYSQL_STORE_DATABASE ); }
+  catch( ConfigError& ) {}
+
+  try { user = settings.getString( MYSQL_STORE_USER ); }
+  catch( ConfigError& ) {}
+
+  try { password = settings.getString( MYSQL_STORE_PASSWORD ); }
+  catch( ConfigError& ) {}
+
+  try { host = settings.getString( MYSQL_STORE_HOST ); }
+  catch( ConfigError& ) {}
+
+  try { port = ( short ) settings.getInt( MYSQL_STORE_PORT ); }
+  catch( ConfigError& ) {}
+
+  DatabaseConnectionID id( database, user, password, host, port );
+  return new MySQLStore( s, id, m_connectionPoolPtr.get() );
+}
+
+void MySQLStoreFactory::destroy( MessageStore* pStore )
+{
+  delete pStore;
+}
+
+bool MySQLStore::set( int msgSeqNum, const std::string& msg )
+throw ( IOException )
+{
+  char* msgCopy = new char[ (msg.size() * 2) + 1 ];
+  mysql_escape_string( msgCopy, msg.c_str(), msg.size() );
+
+  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 << "\")";
+
+  delete [] msgCopy;
+
+  MySQLQuery query( queryString.str() );
+  if( !m_pConnection->execute(query) )
+  {
+    std::stringstream queryString2;
+    queryString2 << "UPDATE messages SET message=\"" << msg << "\" 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;
+    MySQLQuery query2( queryString2.str() );
+    if( !m_pConnection->execute(query2) )
+      query2.throwException();
+  }
+  return true;
+}
+
+void MySQLStore::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";
+
+  MySQLQuery query( queryString.str() );
+  if( !m_pConnection->execute(query) )
+    query.throwException();
+
+  int rows = query.rows();
+  for( int row = 0; row < rows; row++ )
+    result.push_back( query.getValue( row, 0 ) );
+}
+
+int MySQLStore::getNextSenderMsgSeqNum() const throw ( IOException )
+{
+  return m_cache.getNextSenderMsgSeqNum();
+}
+
+int MySQLStore::getNextTargetMsgSeqNum() const throw ( IOException )
+{
+  return m_cache.getNextTargetMsgSeqNum();
+}
+
+void MySQLStore::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() << "\"";
+  MySQLQuery query( queryString.str() );
+  if( !m_pConnection->execute(query) )
+    query.throwException();
+  m_cache.setNextSenderMsgSeqNum( value );
+}
+
+void MySQLStore::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() << "\"";
+
+  MySQLQuery query( queryString.str() );
+  if( !m_pConnection->execute(query) )
+    query.throwException();
+
+  m_cache.setNextTargetMsgSeqNum( value );
+}
+
+void MySQLStore::incrNextSenderMsgSeqNum() throw ( IOException )
+{
+  m_cache.incrNextSenderMsgSeqNum();
+  setNextSenderMsgSeqNum( m_cache.getNextSenderMsgSeqNum() );
+}
+
+void MySQLStore::incrNextTargetMsgSeqNum() throw ( IOException )
+{
+  m_cache.incrNextTargetMsgSeqNum();
+  setNextTargetMsgSeqNum( m_cache.getNextTargetMsgSeqNum() );
+}
+
+UtcTimeStamp MySQLStore::getCreationTime() const throw ( IOException )
+{
+  return m_cache.getCreationTime();
+}
+
+void MySQLStore::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() << "\"";
+
+  MySQLQuery query( queryString.str() );
+  if( !m_pConnection->execute(query) )
+    query.throwException();
+
+  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='" << 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() << "\"";
+
+  MySQLQuery query2( queryString2.str() );
+  if( !m_pConnection->execute(query2) )
+    query2.throwException();
+}
+
+void MySQLStore::refresh() throw ( IOException )
+{
+  m_cache.reset();
+  populateCache(); 
+}
+
+}
+
+#endif

data/ext/quickfix/MySQLStore.h

@@ -0,0 +1,142 @@
+/* -*- 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_MYSQL
+#error MySQLStore.h included, but HAVE_MYSQL not defined
+#endif
+
+#ifdef HAVE_MYSQL
+#ifndef FIX_MYSQLSTORE_H
+#define FIX_MYSQLSTORE_H
+
+#ifdef _MSC_VER
+#pragma warning( disable : 4503 4355 4786 4290 )
+#pragma comment( lib, "libMySQL" )
+#endif
+
+#include "MessageStore.h"
+#include "SessionSettings.h"
+#include "MySQLConnection.h"
+#include <fstream>
+#include <string>
+
+namespace FIX
+{
+/// Creates a MySQL based implementation of MessageStore.
+class MySQLStoreFactory : public MessageStoreFactory
+{
+public:
+  static const std::string DEFAULT_DATABASE;
+  static const std::string DEFAULT_USER;
+  static const std::string DEFAULT_PASSWORD;
+  static const std::string DEFAULT_HOST;
+  static const short DEFAULT_PORT;
+
+  MySQLStoreFactory( const SessionSettings& settings )
+: m_settings( settings ), m_useSettings( true ), m_useDictionary( false ) 
+  {
+    bool poolConnections = false;
+    try { poolConnections = settings.get().getBool(MYSQL_STORE_USECONNECTIONPOOL); }
+    catch( ConfigError& ) {}
+
+    m_connectionPoolPtr = MySQLConnectionPoolPtr
+      ( new MySQLConnectionPool(poolConnections) );
+  }
+
+  MySQLStoreFactory( const Dictionary& dictionary )
+: m_dictionary( dictionary ), m_useSettings( false ), m_useDictionary( true ) 
+  {
+    m_connectionPoolPtr = MySQLConnectionPoolPtr
+      ( new MySQLConnectionPool(false) );
+  }
+
+  MySQLStoreFactory( const std::string& database, const std::string& user,
+                     const std::string& password, const std::string& host,
+                     short port )
+: m_database( database ), m_user( user ), m_password( password ), m_host( host ), m_port( port ),
+  m_useSettings( false ), m_useDictionary( false ) 
+  {
+    m_connectionPoolPtr = MySQLConnectionPoolPtr
+      ( new MySQLConnectionPool(false) );
+  }
+
+  MySQLStoreFactory()
+: m_database( DEFAULT_DATABASE ), m_user( DEFAULT_USER ), m_password( DEFAULT_PASSWORD ),
+  m_host( DEFAULT_HOST ), m_port( DEFAULT_PORT ), m_useSettings( false ), m_useDictionary( false ) 
+  {
+    m_connectionPoolPtr = MySQLConnectionPoolPtr
+      ( new MySQLConnectionPool(false) );
+  }
+
+  MessageStore* create( const SessionID& );
+  void destroy( MessageStore* );
+private:
+  MessageStore* create( const SessionID& s, const Dictionary& );
+
+  MySQLConnectionPoolPtr m_connectionPoolPtr;
+  SessionSettings m_settings;
+  Dictionary m_dictionary;
+  std::string m_database;
+  std::string m_user;
+  std::string m_password;
+  std::string m_host;
+  short m_port;
+  bool m_useSettings;
+  bool m_useDictionary;
+};
+/*! @} */
+
+/// MySQL based implementation of MessageStore.
+class MySQLStore : public MessageStore
+{
+public:
+  MySQLStore( const SessionID& s, const DatabaseConnectionID& d, MySQLConnectionPool* p );
+  MySQLStore( const SessionID& s, const std::string& database, const std::string& user,
+                   const std::string& password, const std::string& host, short port );
+  ~MySQLStore();
+
+  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();
+
+  MemoryStore m_cache;
+  MySQLConnection* m_pConnection;
+  MySQLConnectionPool* m_pConnectionPool;
+  SessionID m_sessionID;
+};
+}
+
+#endif //FIX_MYSQLSTORE_H
+#endif //HAVE_MYSQL

data/ext/quickfix/NullStore.cpp

@@ -0,0 +1,54 @@
+/****************************************************************************
+** 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 "NullStore.h"
+
+namespace FIX
+{
+
+MessageStore* NullStoreFactory::create( const SessionID& )
+{
+  return new NullStore();
+}
+
+void NullStoreFactory::destroy( MessageStore* pStore )
+{
+  delete pStore;
+}
+
+bool NullStore::set( int msgSeqNum, const std::string& msg )
+throw( IOException )
+{
+  return true;
+}
+
+void NullStore::get( int begin, int end,
+                       std::vector < std::string > & messages ) const
+throw( IOException )
+{
+  messages.clear();
+}
+
+} //namespace FIX

data/ext/quickfix/NullStore.h

@@ -0,0 +1,99 @@
+/* -*- 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_NULLSTORE_H
+#define FIX_NULLSTORE_H
+
+#ifdef _MSC_VER
+#pragma warning( disable : 4503 4355 4786 4290 )
+#endif
+
+#include "MessageStore.h"
+#include "SessionSettings.h"
+#include <string>
+
+namespace FIX
+{
+class Session;
+
+/**
+ * Null implementation of MessageStore.
+ *
+ * Will not actually store messages.  Useful for admin-only or market
+ * data-only applications.
+ */
+class NullStoreFactory : public MessageStoreFactory
+{
+public:
+  MessageStore* create( const SessionID& );
+  void destroy( MessageStore* );
+};
+/*! @} */
+
+
+/**
+ * Null implementation of MessageStore.
+ *
+ * Will not actually store messages.  Useful for admin-only or market
+ * data-only applications.
+ */
+class NullStore : public MessageStore
+{
+public:
+  NullStore() : m_nextSenderMsgSeqNum( 1 ), m_nextTargetMsgSeqNum( 1 ) {}
+
+  bool set( int, const std::string& ) throw ( IOException );
+  void get( int, int, std::vector < std::string > & ) const throw ( IOException );
+
+  int getNextSenderMsgSeqNum() const throw ( IOException )
+  { return m_nextSenderMsgSeqNum; }
+  int getNextTargetMsgSeqNum() const throw ( IOException )
+  { return m_nextTargetMsgSeqNum; }
+  void setNextSenderMsgSeqNum( int value ) throw ( IOException )
+  { m_nextSenderMsgSeqNum = value; }
+  void setNextTargetMsgSeqNum( int value ) throw ( IOException )
+  { m_nextTargetMsgSeqNum = value; }
+  void incrNextSenderMsgSeqNum() throw ( IOException )
+  { ++m_nextSenderMsgSeqNum; }
+  void incrNextTargetMsgSeqNum() throw ( IOException )
+  { ++m_nextTargetMsgSeqNum; }
+
+  void setCreationTime( const UtcTimeStamp& creationTime ) throw ( IOException )
+  { m_creationTime = creationTime; }
+  UtcTimeStamp getCreationTime() const throw ( IOException )
+  { return m_creationTime; }
+
+  void reset() throw ( IOException )
+  {
+    m_nextSenderMsgSeqNum = 1; m_nextTargetMsgSeqNum = 1;
+    m_creationTime.setCurrent();
+  }
+  void refresh() throw ( IOException ) {}
+
+private:
+  int m_nextSenderMsgSeqNum;
+  int m_nextTargetMsgSeqNum;
+  UtcTimeStamp m_creationTime;
+};
+}
+
+#endif // FIX_NULLSTORE_H
+