quickfix_ruby 1.14.3

data/ext/quickfix/Parser.cpp

@@ -0,0 +1,103 @@
+/****************************************************************************
+** 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 "Parser.h"
+#include "Utility.h"
+#include "FieldConvertors.h"
+#include <algorithm>
+
+namespace FIX
+{
+bool Parser::extractLength( int& length, std::string::size_type& pos,
+                            const std::string& buffer )
+throw( MessageParseError )
+{
+  if( !buffer.size() ) return false;
+
+  std::string::size_type startPos = buffer.find( "\0019=", 0 );
+  if( startPos == std::string::npos ) return false;
+  startPos += 3;
+  std::string::size_type endPos = buffer.find( "\001", startPos );
+  if( endPos == std::string::npos ) return false;
+
+  std::string strLength( buffer, startPos, endPos - startPos );
+
+  try
+  {
+    length = IntConvertor::convert( strLength );
+    if( length < 0 ) throw MessageParseError();
+  }
+  catch( FieldConvertError& )
+  { throw MessageParseError(); }
+
+  pos = endPos + 1;
+  return true;
+}
+
+bool Parser::readFixMessage( std::string& str )
+throw( MessageParseError )
+{
+  std::string::size_type pos = 0;
+
+  if( m_buffer.length() < 2 ) return false;
+  pos = m_buffer.find( "8=" );
+  if( pos == std::string::npos ) return false;
+  m_buffer.erase( 0, pos );
+
+  int length = 0;
+
+  try
+  {
+    if( extractLength(length, pos, m_buffer) )
+    {
+      pos += length;
+      if( m_buffer.size() < pos )
+        return false;
+
+      pos = m_buffer.find( "\00110=", pos-1 );
+      if( pos == std::string::npos ) return false;
+      pos += 4;
+      pos = m_buffer.find( "\001", pos );
+      if( pos == std::string::npos ) return false;
+      pos += 1;
+
+      str.assign( m_buffer, 0, pos );
+      m_buffer.erase( 0, pos );
+      return true;
+    }
+  }
+  catch( MessageParseError& e )
+  {
+    if( length > 0 )
+      m_buffer.erase( 0, pos + length );
+    else
+      m_buffer.erase();
+
+    throw e;
+  }
+
+  return false;
+}
+}

data/ext/quickfix/Parser.h

@@ -0,0 +1,57 @@
+/* -*- 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_PARSER_H
+#define FIX_PARSER_H
+
+#ifdef _MSC_VER
+#pragma warning( disable : 4503 4355 4786 4290 )
+#endif
+
+#include "Exceptions.h"
+#include <iostream>
+#include <string>
+
+namespace FIX
+{
+/// Parses %FIX messages off an input stream.
+class Parser
+{
+public:
+  Parser() {}
+  ~Parser() {}
+
+  bool extractLength( int& length, std::string::size_type& pos,
+                      const std::string& buffer )
+  throw ( MessageParseError );
+  bool readFixMessage( std::string& str )
+  throw ( MessageParseError );
+
+  void addToStream( const char* str, size_t len )
+  { m_buffer.append( str, len ); }
+  void addToStream( const std::string& str )
+  { m_buffer.append( str ); }
+
+private:
+  std::string m_buffer;
+};
+}
+#endif //FIX_PARSER_H

data/ext/quickfix/PostgreSQLConnection.h

@@ -0,0 +1,176 @@
+/* -*- 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_POSTGRESQL
+#error PostgreSQLConnection.h included, but HAVE_POSTGRESQL not defined
+#endif
+
+#ifdef HAVE_POSTGRESQL
+#ifndef FIX_POSTGRESQLCONNECTION_H
+#define FIX_POSTGRESQLCONNECTION_H
+
+#ifdef _MSC_VER
+#pragma warning( disable : 4503 4355 4786 4290 )
+#pragma comment( lib, "libpq" )
+#endif
+
+#include <libpq-fe.h>
+#include "DatabaseConnectionID.h"
+#include "DatabaseConnectionPool.h"
+#include "Mutex.h"
+
+namespace FIX
+{
+class PostgreSQLQuery
+{
+public:
+  PostgreSQLQuery( const std::string& query ) 
+  : m_result( 0 ), m_query( query ) 
+  {}
+
+  ~PostgreSQLQuery()
+  {
+    if( m_result )
+      PQclear( m_result );
+  }
+
+  bool execute( PGconn* pConnection )
+  {
+    int retry = 0;
+    
+    do
+    {
+      if( m_result ) PQclear( m_result );
+      m_result = PQexec( pConnection, m_query.c_str() );
+      m_status = PQresultStatus( m_result );
+      if( success() ) return true;
+      PQreset( pConnection );
+      retry++;
+    } while( retry <= 1 );
+    return success();
+  }
+
+  bool success()
+  {
+    return m_status == PGRES_TUPLES_OK
+      || m_status == PGRES_COMMAND_OK;
+  }
+
+  int rows()
+  {
+    return PQntuples( m_result );
+  }
+
+  char* reason()
+  {
+    return PQresultErrorMessage( m_result );
+  }
+
+  char* getValue( int row, int column )
+  {
+    return PQgetvalue( m_result, row, column );
+  }
+
+  void throwException() throw( IOException )
+  {
+    if( !success() )
+      throw IOException( "Query failed [" + m_query + "] " );
+  }
+
+private:
+  PGresult* m_result;
+  ExecStatusType m_status;
+  std::string m_query; 
+};
+
+class PostgreSQLConnection
+{
+public:
+  PostgreSQLConnection
+  ( const DatabaseConnectionID& id )
+  : m_connectionID( id )
+  {
+    connect();
+  }
+
+  PostgreSQLConnection
+  ( 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();
+  }
+
+  ~PostgreSQLConnection()
+  {
+    if( m_pConnection )
+      PQfinish( m_pConnection );
+  }
+
+  const DatabaseConnectionID& connectionID()
+  {
+    return m_connectionID;
+  }
+
+  bool connected()
+  {
+    Locker locker( m_mutex );
+    return PQstatus( m_pConnection ) == CONNECTION_OK;
+  }
+
+  bool reconnect()
+  {
+    Locker locker( m_mutex );
+    PQreset( m_pConnection );
+    return connected();
+  }
+
+  bool execute( PostgreSQLQuery& pQuery )
+  {
+    Locker locker( m_mutex );
+    return pQuery.execute( m_pConnection );
+  }
+
+private:
+  void connect()
+  {
+    short port = m_connectionID.getPort();
+    m_pConnection = PQsetdbLogin
+      ( m_connectionID.getHost().c_str(), port == 0 ? "" : IntConvertor::convert( port ).c_str(),
+        "", "", m_connectionID.getDatabase().c_str(), m_connectionID.getUser().c_str(), m_connectionID.getPassword().c_str() );
+
+    if( !connected() )
+      throw ConfigError( "Unable to connect to database" );
+  }
+
+  PGconn* m_pConnection;
+  DatabaseConnectionID m_connectionID;
+  Mutex m_mutex;
+};
+
+typedef DatabaseConnectionPool<PostgreSQLConnection>
+  PostgreSQLConnectionPool;
+typedef std::auto_ptr< PostgreSQLConnectionPool >
+  PostgreSQLConnectionPoolPtr;
+}
+
+#endif //FIX_POSTGRESQLCONNECTION_H
+#endif //HAVE_POSTGRESQL

data/ext/quickfix/PostgreSQLLog.cpp

@@ -0,0 +1,276 @@
+/****************************************************************************
+** 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_POSTGRESQL
+
+#include "PostgreSQLLog.h"
+#include "SessionID.h"
+#include "SessionSettings.h"
+#include "Utility.h"
+#include "strptime.h"
+#include <fstream>
+
+namespace FIX
+{
+
+const std::string PostgreSQLLogFactory::DEFAULT_DATABASE = "quickfix";
+const std::string PostgreSQLLogFactory::DEFAULT_USER = "postgres";
+const std::string PostgreSQLLogFactory::DEFAULT_PASSWORD = "";
+const std::string PostgreSQLLogFactory::DEFAULT_HOST = "localhost";
+const short PostgreSQLLogFactory::DEFAULT_PORT = 0;
+
+PostgreSQLLog::PostgreSQLLog
+( const SessionID& s, const DatabaseConnectionID& d, PostgreSQLConnectionPool* p )
+: m_pConnectionPool( p )
+{
+  init();
+  m_pSessionID = new SessionID( s );
+  m_pConnection = m_pConnectionPool->create( d );
+}
+
+PostgreSQLLog::PostgreSQLLog
+( const DatabaseConnectionID& d, PostgreSQLConnectionPool* p )
+: m_pConnectionPool( p ), m_pSessionID( 0 )
+{
+  init();
+  m_pConnection = m_pConnectionPool->create( d );
+}
+
+PostgreSQLLog::PostgreSQLLog
+( 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 PostgreSQLConnection( database, user, password, host, port );
+}
+
+PostgreSQLLog::PostgreSQLLog
+( const std::string& database, const std::string& user,
+  const std::string& password, const std::string& host, short port )
+  : m_pConnectionPool( 0 ), m_pSessionID( 0 )
+{
+  init();
+  m_pConnection = new PostgreSQLConnection( database, user, password, host, port );
+}
+
+void PostgreSQLLog::init()
+{
+  setIncomingTable( "messages_log" );
+  setOutgoingTable( "messages_log" );
+  setEventTable( "event_log" );
+}
+
+PostgreSQLLog::~PostgreSQLLog()
+{
+  if( m_pConnectionPool )
+    m_pConnectionPool->destroy( m_pConnection );
+  else
+    delete m_pConnection;
+  delete m_pSessionID;
+}
+
+Log* PostgreSQLLogFactory::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 );
+  PostgreSQLLog* result = new PostgreSQLLog( id, m_connectionPoolPtr.get() );
+  initLog( m_settings.get(), *result );
+  return result;
+}
+
+Log* PostgreSQLLogFactory::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 );
+  PostgreSQLLog* result = new PostgreSQLLog( s, id, m_connectionPoolPtr.get() );
+  initLog( settings, *result );
+  return result;
+}
+
+void PostgreSQLLogFactory::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( POSTGRESQL_LOG_DATABASE ); }
+    catch( ConfigError& ) {}
+
+    try { user = settings.getString( POSTGRESQL_LOG_USER ); }
+    catch( ConfigError& ) {}
+
+    try { password = settings.getString( POSTGRESQL_LOG_PASSWORD ); }
+    catch( ConfigError& ) {}
+
+    try { host = settings.getString( POSTGRESQL_LOG_HOST ); }
+    catch( ConfigError& ) {}
+
+    try { port = ( short ) settings.getInt( POSTGRESQL_LOG_PORT ); }
+    catch( ConfigError& ) {}
+  }
+  else
+  {
+    database = m_database;
+    user = m_user;
+    password = m_password;
+    host = m_host;
+    port = m_port;
+  }
+}
+
+void PostgreSQLLogFactory::initLog( const Dictionary& settings, PostgreSQLLog& log )
+{
+  try { log.setIncomingTable( settings.getString( POSTGRESQL_LOG_INCOMING_TABLE ) ); }
+  catch( ConfigError& ) {}
+
+  try { log.setOutgoingTable( settings.getString( POSTGRESQL_LOG_OUTGOING_TABLE ) ); }
+  catch( ConfigError& ) {}
+
+  try { log.setEventTable( settings.getString( POSTGRESQL_LOG_EVENT_TABLE ) ); }
+  catch( ConfigError& ) {}
+}
+
+void PostgreSQLLogFactory::destroy( Log* pLog )
+{
+  delete pLog;
+}
+
+void PostgreSQLLog::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();
+
+  PostgreSQLQuery incoming( incomingQuery.str() );
+  PostgreSQLQuery outgoing( outgoingQuery.str() );
+  PostgreSQLQuery event( eventQuery.str() );
+  m_pConnection->execute( incoming );
+  m_pConnection->execute( outgoing );
+  m_pConnection->execute( event );
+}
+
+void PostgreSQLLog::backup()
+{
+}
+
+void PostgreSQLLog::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 );
+  
+  char* valueCopy = new char[ (value.size() * 2) + 1 ];
+  PQescapeString( valueCopy, value.c_str(), value.size() );
+
+  std::stringstream queryString;
+  queryString << "INSERT INTO " << table << " "
+  << "(time, beginstring, sendercompid, targetcompid, session_qualifier, text) "
+  << "VALUES ("
+  << "'" << 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 << "')";
+  delete [] valueCopy;
+
+  PostgreSQLQuery query( queryString.str() );
+  m_pConnection->execute( query );
+}
+
+} // namespace FIX
+
+#endif //HAVE_POSTGRESQL