quickfix_ruby 1.14.3

data/ext/quickfix/MySQLConnection.h

@@ -0,0 +1,194 @@
+/* -*- 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 MySQLConnection.h included, but HAVE_MYSQL not defined
+#endif
+
+#ifdef HAVE_MYSQL
+#ifndef FIX_MYSQLCONNECTION_H
+#define FIX_MYSQLCONNECTION_H
+
+#ifdef _MSC_VER
+#pragma warning( disable : 4503 4355 4786 4290 )
+#pragma comment( lib, "libMySQL" )
+#endif
+
+#include <mysql.h>
+#include <errmsg.h>
+#include "DatabaseConnectionID.h"
+#include "DatabaseConnectionPool.h"
+#include "Mutex.h"
+
+#undef MYSQL_PORT
+
+namespace FIX
+{
+class MySQLQuery
+{
+public:
+  MySQLQuery( const std::string& query ) 
+  : m_result( 0 ), m_query( query ) 
+  {}
+
+  ~MySQLQuery()
+  {
+    if( m_result )
+      mysql_free_result( m_result );
+  }
+
+  bool execute( MYSQL* pConnection )
+  {
+    int retry = 0;
+    
+    do
+    {
+      if( m_result ) mysql_free_result( m_result );
+      int errcode = mysql_query( pConnection, m_query.c_str() );
+      m_result = mysql_store_result( pConnection );
+      if( errcode == 0 )
+        return true;
+      m_status = mysql_errno( pConnection );
+      m_reason = mysql_error( pConnection );
+      mysql_ping( pConnection );
+      retry++;
+    } while( retry <= 1 );
+    return success();
+  }
+
+  bool success()
+  {
+    return m_status == 0;
+  }
+
+  int rows()
+  {
+    return (int)mysql_num_rows( m_result );
+  }
+
+  const std::string& reason()
+  {
+    return m_reason;
+  }
+
+  char* getValue( int row, int column )
+  {
+    if( m_rows.empty() )
+    {
+      MYSQL_ROW row = 0;
+      while( (row = mysql_fetch_row( m_result )) )
+        m_rows.push_back(row);
+    }
+    return m_rows[row][column];
+  }
+
+  void throwException() throw( IOException )
+  {
+    if( !success() )
+      throw IOException( "Query failed [" + m_query + "] " + reason() );
+  }
+
+private:
+  MYSQL_RES* m_result;
+  int m_status;
+  std::string m_query; 
+  std::string m_reason;
+  std::vector<MYSQL_ROW> m_rows;
+};
+
+class MySQLConnection
+{
+public:
+  MySQLConnection
+  ( const DatabaseConnectionID& id )
+  : m_connectionID( id )
+  {
+    connect();
+  }
+
+  MySQLConnection
+  ( const std::string& database, const std::string& user,
+    const std::string& password, const std::string& host, short port )
+  : m_connectionID( database, user, password, host, port )
+  {
+    connect();
+  }
+
+  ~MySQLConnection()
+  {
+    if( m_pConnection )
+      mysql_close( m_pConnection );
+  }
+
+  const DatabaseConnectionID& connectionID()
+  {
+    return m_connectionID;
+  }
+
+  bool connected()
+  {
+    Locker locker( m_mutex );
+    return mysql_ping( m_pConnection ) == 0;
+  }
+
+  bool reconnect()
+  {
+    Locker locker( m_mutex );
+    return mysql_ping( m_pConnection ) == 0;
+  }
+
+  bool execute( MySQLQuery& pQuery )
+  {
+    Locker locker( m_mutex );
+    return pQuery.execute( m_pConnection );
+  }
+
+private:
+  void connect()
+  {
+    short port = m_connectionID.getPort();
+    m_pConnection = mysql_init( NULL );
+    if( !mysql_real_connect
+      ( m_pConnection, m_connectionID.getHost().c_str(), m_connectionID.getUser().c_str(), 
+        m_connectionID.getPassword().c_str(), m_connectionID.getDatabase().c_str(), port, 0, 0 ) )
+    {
+        if( !connected() )
+          throw ConfigError( std::string("Unable to connect to database [") + mysql_error(m_pConnection) + "]" );
+    }
+    #if( MYSQL_VERSION_ID > 50000 )
+    my_bool reconnect = 1;
+    mysql_options( m_pConnection, MYSQL_OPT_RECONNECT, static_cast<char*>(&reconnect) );
+    #endif
+  }
+
+  MYSQL* m_pConnection;
+  DatabaseConnectionID m_connectionID;
+  Mutex m_mutex;
+};
+
+typedef DatabaseConnectionPool<MySQLConnection>
+  MySQLConnectionPool;
+typedef std::auto_ptr< MySQLConnectionPool >
+  MySQLConnectionPoolPtr;
+}
+
+#endif //FIX_MYSQLCONNECTION_H
+#endif //HAVE_MYSQL

data/ext/quickfix/MySQLLog.cpp

@@ -0,0 +1,275 @@
+/****************************************************************************
+** 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 "MySQLLog.h"
+#include "SessionID.h"
+#include "SessionSettings.h"
+#include "Utility.h"
+#include "strptime.h"
+#include <fstream>
+
+namespace FIX
+{
+
+const std::string MySQLLogFactory::DEFAULT_DATABASE = "quickfix";
+const std::string MySQLLogFactory::DEFAULT_USER = "root";
+const std::string MySQLLogFactory::DEFAULT_PASSWORD = "";
+const std::string MySQLLogFactory::DEFAULT_HOST = "localhost";
+const short MySQLLogFactory::DEFAULT_PORT = 0;
+
+MySQLLog::MySQLLog
+( const SessionID& s, const DatabaseConnectionID& d, MySQLConnectionPool* p )
+: m_pConnectionPool( p )
+{
+  init();
+  m_pSessionID = new SessionID( s );
+  m_pConnection = m_pConnectionPool->create( d );
+}
+
+MySQLLog::MySQLLog
+( const DatabaseConnectionID& d, MySQLConnectionPool* p )
+: m_pConnectionPool( p ), m_pSessionID( 0 )
+{
+  init();
+  m_pConnection = m_pConnectionPool->create( d );
+}
+
+MySQLLog::MySQLLog
+( const SessionID& s, const std::string& database, const std::string& user,
+  const std::string& password, const std::string& host, short port )
+  : m_pConnectionPool( 0 )
+{
+  init();
+  m_pSessionID = new SessionID( s );
+  m_pConnection = new MySQLConnection( database, user, password, host, port );
+}
+
+MySQLLog::MySQLLog
+( const std::string& database, const std::string& user,
+  const std::string& password, const std::string& host, short port )
+  : m_pConnectionPool( 0 ), m_pSessionID( 0 )
+{
+  m_pConnection = new MySQLConnection( database, user, password, host, port );
+}
+
+void MySQLLog::init()
+{
+  setIncomingTable( "messages_log" );
+  setOutgoingTable( "messages_log" );
+  setEventTable( "event_log" );
+}
+
+MySQLLog::~MySQLLog()
+{
+  if( m_pConnectionPool )
+    m_pConnectionPool->destroy( m_pConnection );
+  else
+    delete m_pConnection;
+  delete m_pSessionID;
+}
+
+Log* MySQLLogFactory::create()
+{
+  std::string database;
+  std::string user;
+  std::string password;
+  std::string host;
+  short port;
+
+  init( m_settings.get(), database, user, password, host, port );
+  DatabaseConnectionID id( database, user, password, host, port );
+  MySQLLog* result = new MySQLLog( id, m_connectionPoolPtr.get() );
+  initLog( m_settings.get(), *result );
+  return result;
+}
+
+Log* MySQLLogFactory::create( const SessionID& s )
+{
+  std::string database;
+  std::string user;
+  std::string password;
+  std::string host;
+  short port;
+
+  Dictionary settings;
+  if( m_settings.has(s) ) 
+    settings = m_settings.get( s );
+
+  init( settings, database, user, password, host, port );
+  DatabaseConnectionID id( database, user, password, host, port );
+  MySQLLog* result = new MySQLLog( s, id, m_connectionPoolPtr.get() );
+  initLog( settings, *result );
+  return result;
+}
+
+void MySQLLogFactory::init( const Dictionary& settings, 
+                            std::string& database, 
+                            std::string& user,
+                            std::string& password,
+                            std::string& host,
+                            short &port )
+{
+  database = DEFAULT_DATABASE;
+  user = DEFAULT_USER;
+  password = DEFAULT_PASSWORD;
+  host = DEFAULT_HOST;
+  port = DEFAULT_PORT;
+
+  if( m_useSettings )
+  {
+    try { database = settings.getString( MYSQL_LOG_DATABASE ); }
+    catch( ConfigError& ) {}
+
+    try { user = settings.getString( MYSQL_LOG_USER ); }
+    catch( ConfigError& ) {}
+
+    try { password = settings.getString( MYSQL_LOG_PASSWORD ); }
+    catch( ConfigError& ) {}
+
+    try { host = settings.getString( MYSQL_LOG_HOST ); }
+    catch( ConfigError& ) {}
+
+    try { port = ( short ) settings.getInt( MYSQL_LOG_PORT ); }
+    catch( ConfigError& ) {}
+  }
+  else
+  {
+    database = m_database;
+    user = m_user;
+    password = m_password;
+    host = m_host;
+    port = m_port;
+  }
+}
+
+void MySQLLogFactory::initLog( const Dictionary& settings, MySQLLog& log )
+{
+  try { log.setIncomingTable( settings.getString( MYSQL_LOG_INCOMING_TABLE ) ); }
+  catch( ConfigError& ) {}
+
+  try { log.setOutgoingTable( settings.getString( MYSQL_LOG_OUTGOING_TABLE ) ); }
+  catch( ConfigError& ) {}
+
+  try { log.setEventTable( settings.getString( MYSQL_LOG_EVENT_TABLE ) ); }
+  catch( ConfigError& ) {}
+}
+
+void MySQLLogFactory::destroy( Log* pLog )
+{
+  delete pLog;
+}
+
+void MySQLLog::clear()
+{
+  std::stringstream whereClause;
+
+  whereClause << "WHERE ";
+
+  if( m_pSessionID )
+  {
+    whereClause
+    << "BeginString = \"" << m_pSessionID->getBeginString().getValue() << "\" " 
+    << "AND SenderCompID = \"" << m_pSessionID->getSenderCompID().getValue() << "\" "
+    << "AND TargetCompID = \"" << m_pSessionID->getTargetCompID().getValue() << "\" ";
+
+    if( m_pSessionID->getSessionQualifier().size() )
+      whereClause << "AND SessionQualifier = \"" << m_pSessionID->getSessionQualifier() << "\"";
+  }
+  else
+  {
+    whereClause << "BeginString = NULL AND SenderCompID = NULL && TargetCompID = NULL";
+  }
+
+  std::stringstream incomingQuery;
+  std::stringstream outgoingQuery;
+  std::stringstream eventQuery;
+
+  incomingQuery 
+    << "DELETE FROM " << m_incomingTable << " " << whereClause.str();
+  outgoingQuery 
+    << "DELETE FROM " << m_outgoingTable << " " << whereClause.str();
+  eventQuery 
+    << "DELETE FROM " << m_eventTable << " " << whereClause.str();
+
+  MySQLQuery incoming( incomingQuery.str() );
+  MySQLQuery outgoing( outgoingQuery.str() );
+  MySQLQuery event( eventQuery.str() );
+  m_pConnection->execute( incoming );
+  m_pConnection->execute( outgoing );
+  m_pConnection->execute( event );
+}
+
+void MySQLLog::backup()
+{
+}
+
+void MySQLLog::insert( const std::string& table, const std::string value )
+{
+  UtcTimeStamp time;
+  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 );
+
+  char* valueCopy = new char[ (value.size() * 2) + 1 ];
+  mysql_escape_string( valueCopy, value.c_str(), value.size() );
+
+  std::stringstream queryString;
+  queryString << "INSERT INTO " << table << " "
+  << "(time, time_milliseconds, beginstring, sendercompid, targetcompid, session_qualifier, text) "
+  << "VALUES ("
+  << "'" << sqlTime << "','" << millis << "',";
+
+  if( m_pSessionID )
+  {
+    queryString
+    << "\"" << m_pSessionID->getBeginString().getValue() << "\","
+    << "\"" << m_pSessionID->getSenderCompID().getValue() << "\","
+    << "\"" << m_pSessionID->getTargetCompID().getValue() << "\",";
+    if( m_pSessionID->getSessionQualifier() == "" )
+      queryString << "NULL" << ",";
+    else
+      queryString << "\"" << m_pSessionID->getSessionQualifier() << "\",";
+  }
+  else
+  {
+    queryString << "NULL, NULL, NULL, NULL, ";
+  }
+
+  queryString << "\"" << valueCopy << "\")";
+  delete [] valueCopy;
+
+  MySQLQuery query( queryString.str() );
+  m_pConnection->execute( query );
+}
+
+} //namespace FIX
+
+#endif //HAVE_MYSQL

data/ext/quickfix/MySQLLog.h

@@ -0,0 +1,145 @@
+/* -*- 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 MySQLLog.h included, but HAVE_MYSQL not defined
+#endif
+
+#ifdef HAVE_MYSQL
+#ifndef FIX_MYSQLLOG_H
+#define FIX_MYSQLLOG_H
+
+#ifdef _MSC_VER
+#pragma warning( disable : 4503 4355 4786 4290 )
+#pragma comment( lib, "libMySQL" )
+#endif
+
+#include "Log.h"
+#include "SessionSettings.h"
+#include "MySQLConnection.h"
+#include <fstream>
+#include <string>
+
+namespace FIX
+{
+/// MySQL based implementation of Log.
+class MySQLLog : public Log
+{
+public:
+  MySQLLog( const SessionID& s, const DatabaseConnectionID& d, MySQLConnectionPool* p );
+  MySQLLog( const DatabaseConnectionID& d, MySQLConnectionPool* p );
+  MySQLLog( const SessionID& s, const std::string& database, const std::string& user,
+            const std::string& password, const std::string& host, short port );
+  MySQLLog( const std::string& database, const std::string& user,
+            const std::string& password, const std::string& host, short port );
+
+  ~MySQLLog();
+
+  void clear();
+  void backup();
+  void setIncomingTable( const std::string& incomingTable )
+  { m_incomingTable = incomingTable; }
+  void setOutgoingTable( const std::string& outgoingTable )
+  { m_outgoingTable = outgoingTable; }
+  void setEventTable( const std::string& eventTable )
+  { m_eventTable = eventTable; }
+
+  void onIncoming( const std::string& value )
+  { insert( m_incomingTable, value ); }
+  void onOutgoing( const std::string& value )
+  { insert( m_outgoingTable, value ); }
+  void onEvent( const std::string& value )
+  { insert( m_eventTable, value ); }
+
+private:
+  void init();
+  void insert( const std::string& table, const std::string value );
+
+  std::string m_incomingTable;
+  std::string m_outgoingTable;
+  std::string m_eventTable;
+  MySQLConnection* m_pConnection;
+  MySQLConnectionPool* m_pConnectionPool;
+  SessionID* m_pSessionID;
+};
+
+/// Creates a MySQL based implementation of Log.
+class MySQLLogFactory : public LogFactory
+{
+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;
+
+  MySQLLogFactory( const SessionSettings& settings )
+: m_settings( settings ), m_useSettings( true ) 
+  {
+    bool poolConnections = false;
+    try { poolConnections = settings.get().getBool(MYSQL_LOG_USECONNECTIONPOOL); }
+    catch( ConfigError& ) {}
+
+    m_connectionPoolPtr = MySQLConnectionPoolPtr
+      ( new MySQLConnectionPool(poolConnections) );
+  }
+
+  MySQLLogFactory( 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_connectionPoolPtr = MySQLConnectionPoolPtr
+      ( new MySQLConnectionPool(false) );
+  }
+
+  MySQLLogFactory()
+: m_database( DEFAULT_DATABASE ), m_user( DEFAULT_USER ), m_password( DEFAULT_PASSWORD ),
+  m_host( DEFAULT_HOST ), m_port( DEFAULT_PORT ), m_useSettings( false ) 
+  {
+    m_connectionPoolPtr = MySQLConnectionPoolPtr
+      ( new MySQLConnectionPool(false) );
+  }
+
+  Log* create();
+  Log* create( const SessionID& );
+  void destroy( Log* );
+private:
+  void init( const Dictionary& settings, std::string& database,
+             std::string& user, std::string& password,
+             std::string& host, short& port );
+
+  void initLog( const Dictionary& settings, MySQLLog& log );
+
+  MySQLConnectionPoolPtr m_connectionPoolPtr;
+  SessionSettings m_settings;
+  std::string m_database;
+  std::string m_user;
+  std::string m_password;
+  std::string m_host;
+  short m_port;
+  bool m_useSettings;
+};
+}
+
+#endif //FIX_MYSQLLOG_H
+#endif //HAVE_MYSQL