quickfix_ruby_ud 2.0.7-x86_64-linux

data/ext/quickfix/MySQLConnection.h

@@ -0,0 +1,187 @@
+/* -*- 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_MYSQLCONNECTION_H
+#define FIX_MYSQLCONNECTION_H
+
+#ifndef HAVE_MYSQL
+#error MySQLConnection.h included, but HAVE_MYSQL not defined
+#endif
+
+#ifdef HAVE_MYSQL
+
+#ifdef _MSC_VER
+#pragma warning(disable : 4503 4355 4786 4290)
+#pragma comment(lib, "libMySQL")
+#endif
+
+#include "DatabaseConnectionID.h"
+#include "DatabaseConnectionPool.h"
+#include "Mutex.h"
+#include <errmsg.h>
+#include <mysql.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() EXCEPT(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 mysql database: ") + "'" + m_connectionID.getDatabase()
+            + "': " + m_connectionID.getUser() + '@' + m_connectionID.getHost() + ":" + std::to_string(port) + " ["
+            + mysql_error(m_pConnection) + "]");
+      }
+    }
+
+#if (MYSQL_VERSION_ID > 80000)
+    bool reconnect = true;
+    mysql_options(m_pConnection, MYSQL_OPT_RECONNECT, &reconnect);
+#else
+    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::unique_ptr<MySQLConnectionPool> MySQLConnectionPoolPtr;
+} // namespace FIX
+
+#endif // FIX_MYSQLCONNECTION_H
+#endif // HAVE_MYSQL

data/ext/quickfix/MySQLLog.cpp

@@ -0,0 +1,262 @@
+/****************************************************************************
+** 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 &sessionID, const DatabaseConnectionID &connectionID, MySQLConnectionPool *pool)
+    : m_pConnectionPool(pool) {
+  init();
+  m_pSessionID = new SessionID(sessionID);
+  m_pConnection = m_pConnectionPool->create(connectionID);
+}
+
+MySQLLog::MySQLLog(const DatabaseConnectionID &connectionID, MySQLConnectionPool *pool)
+    : m_pConnectionPool(pool),
+      m_pSessionID(0) {
+  init();
+  m_pConnection = m_pConnectionPool->create(connectionID);
+}
+
+MySQLLog::MySQLLog(
+    const SessionID &sessionID,
+    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(sessionID);
+  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 = 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", 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,158 @@
+/* -*- 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_MYSQLLOG_H
+#define FIX_MYSQLLOG_H
+
+#ifndef HAVE_MYSQL
+#error MySQLLog.h included, but HAVE_MYSQL not defined
+#endif
+
+#ifdef HAVE_MYSQL
+
+#ifdef _MSC_VER
+#pragma warning(disable : 4503 4355 4786 4290)
+#pragma comment(lib, "libMySQL")
+#endif
+
+#include "Log.h"
+#include "MySQLConnection.h"
+#include "SessionSettings.h"
+#include <fstream>
+#include <string>
+
+namespace FIX {
+/// MySQL based implementation of Log.
+class MySQLLog : public Log {
+public:
+  MySQLLog(const SessionID &sessionID, const DatabaseConnectionID &connectionID, MySQLConnectionPool *pool);
+  MySQLLog(const DatabaseConnectionID &connectionID, MySQLConnectionPool *pool);
+  MySQLLog(
+      const SessionID &sessionID,
+      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;
+};
+} // namespace FIX
+
+#endif // FIX_MYSQLLOG_H
+#endif // HAVE_MYSQL