quickfix_ruby 1.14.3

data/ext/quickfix/OdbcConnection.h

@@ -0,0 +1,266 @@
+/* -*- 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 OdbcConnection.h included, but HAVE_ODBC not defined
+#endif
+
+#ifdef HAVE_ODBC
+#ifndef FIX_ODBCCONNECTION_H
+#define FIX_ODBCCONNECTION_H
+
+#ifdef _MSC_VER
+#pragma warning( disable : 4503 4355 4786 4290 )
+#pragma comment( lib, "Odbc32" )
+#endif
+
+#include "Utility.h"
+#include <sql.h>
+#include <sqlext.h>
+#include <sqltypes.h>
+#include <sstream>
+#include "DatabaseConnectionID.h"
+#include "DatabaseConnectionPool.h"
+#include "Exceptions.h"
+#include "Mutex.h"
+
+namespace FIX
+{
+
+inline std::string odbcError( SQLSMALLINT statementType, SQLHANDLE handle )
+{
+  SQLCHAR state[6];
+  SQLINTEGER error;
+  SQLCHAR text[SQL_MAX_MESSAGE_LENGTH];
+  SQLSMALLINT textLength;
+  RETCODE result = SQLGetDiagRec
+    ( statementType, handle, 1, state, &error, text, sizeof(text), &textLength );
+  if( result == SQL_SUCCESS || result == SQL_SUCCESS_WITH_INFO )
+    return std::string( (char*)text );
+  return "";
+}
+
+inline bool odbcSuccess( RETCODE result )
+{
+  return result == SQL_SUCCESS || result == SQL_SUCCESS_WITH_INFO;
+}
+
+class OdbcQuery
+{
+public:
+  OdbcQuery( const std::string& query ) 
+  : m_statement( 0 ), m_result( 0 ), m_query( query ) 
+  {}
+
+  ~OdbcQuery()
+  {
+    close();
+  }
+
+  void close()
+  {
+    if( m_statement )
+    {
+      SQLFreeHandle( SQL_HANDLE_STMT, m_statement );
+      m_statement = 0;
+      m_result = 0;
+    }
+  }
+
+  bool execute( HDBC connection )
+  {
+    if( m_statement ) SQLFreeHandle( SQL_HANDLE_STMT, m_statement );
+    SQLAllocHandle( SQL_HANDLE_STMT, connection, &m_statement );
+    m_result = SQLExecDirect( m_statement, (SQLCHAR*)m_query.c_str(), m_query.size() );
+    if( success() || m_result == SQL_NO_DATA )
+      return true;
+    m_reason = odbcError( SQL_HANDLE_STMT, m_statement );
+    SQLFreeHandle( SQL_HANDLE_STMT, m_statement );
+    m_statement = 0;
+    return success();
+  }
+
+  bool success()
+  {
+    return odbcSuccess( m_result );
+  }
+
+  /*int rows()
+  {
+    return (int)mysql_num_rows( m_result );
+  }*/
+
+  const std::string& reason()
+  {
+    return m_reason;
+  }
+
+  bool fetch()
+  {
+    return odbcSuccess( SQLFetch(m_statement) );
+  }
+
+  /*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];
+  }*/
+
+  HSTMT statement()
+  {
+    return m_statement;
+  }
+
+  void throwException() throw( IOException )
+  {
+    if( !success() )
+      throw IOException( "Query failed [" + m_query + "] " + reason() );
+  }
+
+private:
+  HSTMT m_statement;
+  RETCODE m_result;
+  std::string m_query; 
+  std::string m_reason;
+};
+
+class OdbcConnection
+{
+public:
+  OdbcConnection
+  ( const DatabaseConnectionID& id )
+    : m_connection( 0 ), m_environment( 0 ), m_connectionID( id )
+  {
+    connect();
+  }
+
+  OdbcConnection
+  ( const std::string& user, const std::string& password, 
+    const std::string& connectionString )
+  : m_connection( 0 ), m_environment( 0 ), m_connectionID( "", user, password, connectionString, 0 )
+  {
+    connect();
+  }
+
+  ~OdbcConnection()
+  {
+    if( m_connection )
+    {
+      SQLDisconnect( m_connection );
+      SQLFreeHandle( SQL_HANDLE_DBC, m_connection );
+      SQLFreeHandle( SQL_HANDLE_ENV, m_environment );
+    }
+  }
+
+  const DatabaseConnectionID& connectionID()
+  {
+    return m_connectionID;
+  }
+
+  bool connected()
+  {
+    Locker locker( m_mutex );
+    return m_connected;
+  }
+
+  bool reconnect()
+  {
+    Locker locker( m_mutex );
+    SQLDisconnect( m_connection );
+    SQLFreeHandle( SQL_HANDLE_DBC, m_connection );
+    m_connection = 0;
+    connect();
+    return true;
+  }
+
+  bool execute( OdbcQuery& pQuery )
+  {
+    Locker locker( m_mutex );
+    if( !pQuery.execute( m_connection ) )
+    {
+      reconnect();
+      return pQuery.execute( m_connection );
+    }
+    return true;
+  }
+
+private:
+  void connect()
+  {
+    m_connected = false;
+
+    RETCODE result;
+    if(!m_environment)
+    {
+      result = SQLAllocHandle( SQL_HANDLE_ENV, SQL_NULL_HANDLE, &m_environment );
+      if( !odbcSuccess(result) )
+      throw ConfigError( "Unable to allocate ODBC environment" );
+
+      result = SQLSetEnvAttr(m_environment, SQL_ATTR_ODBC_VERSION, (void*)SQL_OV_ODBC3, 0);
+      if( !odbcSuccess(result) )
+        throw ConfigError( "Unable to find ODBC version 3.0" );
+    }
+
+    result = SQLAllocHandle( SQL_HANDLE_DBC, m_environment, &m_connection );
+    if( !odbcSuccess(result) )
+      throw ConfigError( "Unable to allocate ODBC connection" );
+
+    std::stringstream connectionStream;
+    std::string connectionString = m_connectionID.getHost();
+    if( m_connectionID.getHost().find("UID=") == std::string::npos )
+      connectionStream << "UID=" << m_connectionID.getUser() << ";";
+    if( m_connectionID.getHost().find("PWD=") == std::string::npos )
+      connectionStream << "PWD=" << m_connectionID.getPassword() << ";";
+    connectionStream << m_connectionID.getHost();
+    connectionString = connectionStream.str();
+
+    SQLCHAR connectionStringOut[255];
+
+    result = SQLDriverConnect(
+      m_connection, NULL,
+      (SQLCHAR*)connectionString.c_str(), SQL_NTS,
+      connectionStringOut, 255,
+      0, SQL_DRIVER_NOPROMPT );
+
+    if( !odbcSuccess(result) )
+    {
+      std::string error = odbcError( SQL_HANDLE_DBC, m_connection );
+      throw ConfigError( error );
+    }
+
+    m_connected = true;
+  }
+
+  HENV m_environment;
+  HDBC m_connection;
+  bool m_connected;
+  DatabaseConnectionID m_connectionID;
+  Mutex m_mutex;
+};
+}
+
+#endif
+#endif

data/ext/quickfix/OdbcLog.cpp

@@ -0,0 +1,252 @@
+/****************************************************************************
+** 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
+
+#include "OdbcLog.h"
+#include "SessionID.h"
+#include "SessionSettings.h"
+#include "Utility.h"
+#include "strptime.h"
+#include <fstream>
+
+namespace FIX
+{
+
+const std::string OdbcLogFactory::DEFAULT_USER = "sa";
+const std::string OdbcLogFactory::DEFAULT_PASSWORD = "";
+const std::string OdbcLogFactory::DEFAULT_CONNECTION_STRING
+  = "DATABASE=quickfix;DRIVER={SQL Server};SERVER=(local);";
+
+OdbcLog::OdbcLog
+( const SessionID& s, const std::string& user, const std::string& password, 
+  const std::string& connectionString )
+{
+  init();
+  m_pSessionID = new SessionID( s );
+  m_pConnection = new OdbcConnection( user, password, connectionString );
+}
+
+OdbcLog::OdbcLog
+( const std::string& user, const std::string& password, 
+  const std::string& connectionString )
+: m_pSessionID( 0 )
+{
+  init();
+  m_pConnection = new OdbcConnection( user, password, connectionString );
+}
+
+void OdbcLog::init()
+{
+  setIncomingTable( "messages_log" );
+  setOutgoingTable( "messages_log" );
+  setEventTable( "event_log" );
+}
+
+OdbcLog::~OdbcLog()
+{
+  delete m_pSessionID;
+  delete m_pConnection;
+}
+
+OdbcLogFactory::OdbcLogFactory( const std::string& user, const std::string& password, 
+                                const std::string& connectionString )
+: m_user( user ), m_password( password ), m_connectionString( connectionString ),
+  m_useSettings( false )
+{
+}
+
+OdbcLogFactory::OdbcLogFactory()
+: m_user( DEFAULT_USER ), m_password( DEFAULT_PASSWORD ),
+  m_connectionString( DEFAULT_CONNECTION_STRING ), m_useSettings( false )
+{
+}
+
+OdbcLogFactory::~OdbcLogFactory()
+{
+}
+
+Log* OdbcLogFactory::create()
+{
+  std::string database;
+  std::string user;
+  std::string connectionString;
+
+  init( m_settings.get(), database, user, connectionString );
+  OdbcLog* result = new OdbcLog( database, user, connectionString );
+  initLog( m_settings.get(), *result );
+  return result;
+}
+
+Log* OdbcLogFactory::create( const SessionID& s )
+{
+  std::string database;
+  std::string user;
+  std::string connectionString;
+
+  Dictionary settings;
+  if( m_settings.has(s) ) 
+    settings = m_settings.get( s );
+
+  init( settings, database, user, connectionString );
+  OdbcLog* result = new OdbcLog( s, database, user, connectionString );
+  initLog( settings, *result );
+  return result;
+}
+
+void OdbcLogFactory::init( const Dictionary& settings, 
+                           std::string& user,
+                           std::string& password, 
+                           std::string& connectionString )
+{
+  user = DEFAULT_USER;
+  password = DEFAULT_PASSWORD;
+  connectionString = DEFAULT_CONNECTION_STRING;
+
+  if( m_useSettings )
+  {
+    try { user = settings.getString( ODBC_LOG_USER ); }
+    catch( ConfigError& ) {}
+
+    try { password = settings.getString( ODBC_LOG_PASSWORD ); }
+    catch( ConfigError& ) {}
+
+    try { connectionString = settings.getString( ODBC_LOG_CONNECTION_STRING ); }
+    catch( ConfigError& ) {}
+  }
+  else
+  {
+    user = m_user;
+    password = m_password;
+    connectionString = m_connectionString;
+  }
+}
+
+void OdbcLogFactory::initLog( const Dictionary& settings, OdbcLog& log )
+{
+  try { log.setIncomingTable( settings.getString( ODBC_LOG_INCOMING_TABLE ) ); }
+  catch( ConfigError& ) {}
+
+  try { log.setOutgoingTable( settings.getString( ODBC_LOG_OUTGOING_TABLE ) ); }
+  catch( ConfigError& ) {}
+
+  try { log.setEventTable( settings.getString( ODBC_LOG_EVENT_TABLE ) ); }
+  catch( ConfigError& ) {}
+}
+
+void OdbcLogFactory::destroy( Log* pLog )
+{
+  delete pLog;
+}
+
+void OdbcLog::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();
+
+  OdbcQuery incoming( incomingQuery.str() );
+  OdbcQuery outgoing( outgoingQuery.str() );
+  OdbcQuery event( eventQuery.str() );
+  m_pConnection->execute( incoming );
+  m_pConnection->execute( outgoing );
+  m_pConnection->execute( event );
+}
+
+void OdbcLog::backup()
+{
+}
+
+void OdbcLog::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[ 24 ];
+  STRING_SPRINTF( sqlTime, "%d-%02d-%02d %02d:%02d:%02d.%003d",
+                  year, month, day, hour, minute, second, millis );
+
+  std::string valueCopy = value;
+  string_replace( "'", "''", valueCopy );
+
+  std::stringstream queryString;
+  queryString << "INSERT INTO " << table << " "
+  << "(time, beginstring, sendercompid, targetcompid, session_qualifier, text) "
+  << "VALUES ("
+  << "{ts '" << sqlTime << "'},";
+
+  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 << "')";
+
+  OdbcQuery query( queryString.str() );
+  m_pConnection->execute( query );
+}
+
+}
+
+#endif

data/ext/quickfix/OdbcLog.h

@@ -0,0 +1,117 @@
+/* -*- 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 OdbcLog.h included, but HAVE_ODBC not defined
+#endif
+
+#ifdef HAVE_ODBC
+#ifndef FIX_ODBCLOG_H
+#define FIX_ODBCLOG_H
+
+#ifdef _MSC_VER
+#pragma warning( disable : 4503 4355 4786 4290 )
+#endif
+
+#include "OdbcConnection.h"
+#include "Log.h"
+#include "SessionSettings.h"
+#include <fstream>
+#include <string>
+
+namespace FIX
+{
+/// ODBC based implementation of Log.
+class OdbcLog : public Log
+{
+public:
+  OdbcLog( const SessionID& s, const std::string& user, const std::string& password, 
+           const std::string& connectionString );
+  OdbcLog( const std::string& user, const std::string& password, 
+           const std::string& connectionString );
+
+  ~OdbcLog();
+
+  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;
+  OdbcConnection* m_pConnection;
+  SessionID* m_pSessionID;
+};
+
+/// Creates a ODBC based implementation of Log.
+class OdbcLogFactory : public LogFactory
+{
+public:
+  static const std::string DEFAULT_USER;
+  static const std::string DEFAULT_PASSWORD;
+  static const std::string DEFAULT_CONNECTION_STRING;
+
+  OdbcLogFactory( const SessionSettings& settings )
+  : m_settings( settings ), m_useSettings( true ) {}
+
+  OdbcLogFactory( const std::string& user, const std::string& password, 
+                  const std::string& connectionString );
+
+  OdbcLogFactory();
+
+  ~OdbcLogFactory();
+
+  Log* create();
+  Log* create( const SessionID& );
+  void destroy( Log* );
+private:
+  void init( const Dictionary& settings, 
+             std::string& user, std::string& password, 
+             std::string& connectionString );
+
+  void initLog( const Dictionary& settings, OdbcLog& log );
+
+  SessionSettings m_settings;
+  std::string m_user;
+  std::string m_password;
+  std::string m_connectionString;
+  bool m_useSettings;
+};
+}
+
+#endif
+#endif