quickfix_ruby_ud 2.0.7

data/ext/quickfix/Parser.cpp

@@ -0,0 +1,111 @@
+/****************************************************************************
+** 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 "FieldConvertors.h"
+#include "Parser.h"
+#include "Utility.h"
+#include <algorithm>
+
+namespace FIX {
+bool Parser::extractLength(int &length, std::string::size_type &pos, const std::string &buffer)
+    EXCEPT(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) EXCEPT(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;
+}
+} // namespace FIX

data/ext/quickfix/Parser.h

@@ -0,0 +1,50 @@
+/* -*- 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) EXCEPT(MessageParseError);
+  bool readFixMessage(std::string &str) EXCEPT(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;
+};
+} // namespace FIX
+#endif // FIX_PARSER_H

data/ext/quickfix/PostgreSQLConnection.h

@@ -0,0 +1,163 @@
+/* -*- 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_POSTGRESQLCONNECTION_H
+#define FIX_POSTGRESQLCONNECTION_H
+
+#ifndef HAVE_POSTGRESQL
+#error PostgreSQLConnection.h included, but HAVE_POSTGRESQL not defined
+#endif
+
+#ifdef HAVE_POSTGRESQL
+
+#ifdef _MSC_VER
+#pragma warning(disable : 4503 4355 4786 4290)
+#pragma comment(lib, "libpq")
+#endif
+
+#include "DatabaseConnectionID.h"
+#include "DatabaseConnectionPool.h"
+#include "Mutex.h"
+#include <libpq-fe.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() EXCEPT(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 postgres database '" + m_connectionID.getDatabase() + "': " + m_connectionID.getUser()
+          + '@' + m_connectionID.getHost() + ":" + std::to_string(port));
+    }
+  }
+
+  PGconn *m_pConnection;
+  DatabaseConnectionID m_connectionID;
+  Mutex m_mutex;
+};
+
+typedef DatabaseConnectionPool<PostgreSQLConnection> PostgreSQLConnectionPool;
+typedef std::unique_ptr<PostgreSQLConnectionPool> PostgreSQLConnectionPoolPtr;
+} // namespace FIX
+
+#endif // FIX_POSTGRESQLCONNECTION_H
+#endif // HAVE_POSTGRESQL

data/ext/quickfix/PostgreSQLLog.cpp

@@ -0,0 +1,263 @@
+/****************************************************************************
+** 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 = UtcTimeStamp::now();
+  int year, month, day, hour, minute, second, millis;
+  time.getYMD(year, month, day);
+  time.getHMS(hour, minute, second, millis);
+
+  char sqlTime[100];
+  STRING_SPRINTF(sqlTime, "%d-%02d-%02d %02d:%02d:%02d.%03d", 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