Add SQLite for Persistent Storage (#64)

* Add SQLite wrapper
* Add SQLite tests

Signed-off-by: Igor Egorov <[email protected]>

Author: Igor Egorov

cmake/Hunter/config.cmake

@@ -34,3 +34,9 @@ hunter_config(
     # disable building examples and tests, disable testing
     CMAKE_ARGS BOOST_DI_OPT_BUILD_TESTS=OFF BOOST_DI_OPT_BUILD_EXAMPLES=OFF
 )
+
+hunter_config(
+    SQLiteModernCpp
+    URL https://github.com/soramitsu/libp2p-sqlite-modern-cpp/archive/fc3b700064cb57ab6b598c9bc7a12b2842f78da2.zip
+    SHA1 d913f2a0360892a30bc7cd8820a0475800b47d76
+)

cmake/dependencies.cmake

@@ -29,3 +29,7 @@ find_package(tsl_hat_trie CONFIG REQUIRED)
 # https://github.com/masterjedy/di
 hunter_add_package(Boost.DI)
 find_package(Boost.DI CONFIG REQUIRED)
+
+# https://github.com/soramitsu/libp2p-sqlite-modern-cpp/tree/hunter
+hunter_add_package(SQLiteModernCpp)
+find_package(SQLiteModernCpp CONFIG REQUIRED)

include/libp2p/storage/sqlite.hpp

@@ -0,0 +1,133 @@
+/**
+ * Copyright Soramitsu Co., Ltd. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#ifndef LIBP2P_SQLITE_HPP
+#define LIBP2P_SQLITE_HPP
+
+#include <vector>
+
+#include <sqlite_modern_cpp.h>
+#include <libp2p/common/logger.hpp>
+
+namespace libp2p::storage {
+
+  /// C++ handy interface for SQLite based on SQLiteModernCpp
+  class SQLite {
+   public:
+    using StatementHandle = size_t;
+    using database_binder = ::sqlite::database_binder;
+    static auto constexpr kLoggerTag = "sqlite";
+
+    explicit SQLite(const std::string &db_file);
+    SQLite(const std::string &db_file, const std::string &logger_tag);
+    ~SQLite();
+
+    template <typename T>
+    auto operator<<(const T &t) {
+      return (db_ << t);
+    }
+
+    template <typename T>
+    SQLite &operator>>(T &t) {
+      db_ >> t;
+      return *this;
+    }
+
+    /// Reads extended sqlite3 error code
+    int getErrorCode();
+
+    /// Returns human-readable representation of an error
+    std::string getErrorMessage();
+
+    /**
+     * Store prepared statement
+     * @param sql - prepared statement body
+     * @return - handle to the statement for
+     */
+    StatementHandle createStatement(const std::string &sql);
+
+    /**
+     * Retrieves SQLiteModernCpp prepared statement
+     * @param handle - statement identifier
+     * @return - statement bound to the db
+     */
+    database_binder &getStatement(StatementHandle handle);
+
+    /**
+     * Executes a command from a prepared statement
+     * @tparam Args - command arguments' types
+     * @param st_handle - statement identifier
+     * @param args - command arguments
+     * @return number of rows affected, -1 in case of error
+     */
+    template <typename... Args>
+    inline int execCommand(StatementHandle st_handle,
+                           const Args &... args) noexcept {
+      try {
+        auto &st = getStatement(st_handle);
+        bindArgs(st, args...);
+        st.execute();
+        return countChanges();
+      } catch (const std::runtime_error &e) {
+        // getStatement can receive invalid handle
+        log_->error(e.what());
+      } catch (...) {
+        log_->error(getErrorMessage());
+      }
+      return -1;
+    }
+
+    /**
+     * Executes a query from a prepared statement
+     * @tparam Sink - query response consumer type
+     * @tparam Args - query arguments' types
+     * @param st_handle - statement identifier
+     * @param sink - query response consumer
+     * @param args - query arguments
+     * @return true when query was successfully executed, otherwise - false
+     */
+    template <typename Sink, typename... Args>
+    inline bool execQuery(StatementHandle st_handle, Sink &&sink,
+                          const Args &... args) noexcept {
+      try {
+        auto &st = getStatement(st_handle);
+        bindArgs(st, args...);
+        st >> sink;
+        return true;
+      } catch (const std::runtime_error &e) {
+        // getStatement can receive invalid handle
+        log_->error(e.what());
+      } catch (...) {
+        log_->error(getErrorMessage());
+      }
+      return false;
+    }
+
+   private:
+    static inline database_binder &bindArgs(database_binder &statement) {
+      return statement;
+    }
+
+    template <typename Arg, typename... Args>
+    static inline database_binder &bindArgs(database_binder &statement,
+                                            const Arg &arg,
+                                            const Args &... args) {
+      statement << arg;
+      return bindArgs(statement, args...);
+    }
+
+    /// Returns the number of rows modified
+    int countChanges();
+
+    ::sqlite::database db_;
+    std::string db_file_;
+    common::Logger log_;
+
+    std::vector<database_binder> statements_;
+  };
+
+}  // namespace libp2p::storage
+
+#endif  // LIBP2P_SQLITE_HPP

src/CMakeLists.txt

@@ -14,6 +14,7 @@ add_subdirectory(peer)
 add_subdirectory(protocol)
 add_subdirectory(protocol_muxer)
 add_subdirectory(security)
+add_subdirectory(storage)
 add_subdirectory(transport)
 
 add_library(p2p

src/storage/CMakeLists.txt

@@ -0,0 +1,10 @@
+#
+# Copyright Soramitsu Co., Ltd. All Rights Reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+
+libp2p_add_library(libp2p_sqlite sqlite.cpp)
+target_link_libraries(libp2p_sqlite
+    SQLiteModernCpp::SQLiteModernCpp
+    p2p_logger
+    )

src/storage/sqlite.cpp

@@ -0,0 +1,56 @@
+/**
+ * Copyright Soramitsu Co., Ltd. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include <libp2p/storage/sqlite.hpp>
+
+namespace libp2p::storage {
+
+  SQLite::SQLite(const std::string &db_file)
+      : db_(db_file),
+        db_file_(db_file),
+        log_(common::createLogger(kLoggerTag)) {}
+
+  SQLite::SQLite(const std::string &db_file, const std::string &logger_tag)
+      : db_(db_file),
+        db_file_(db_file),
+        log_(common::createLogger(logger_tag)) {}
+
+  SQLite::~SQLite() {
+    // without the following, all the prepared statements
+    // might be executed when db_'s destructor is called
+    for (auto &st : statements_) {
+      st.used(true);
+    }
+  }
+
+  int SQLite::getErrorCode() {
+    return sqlite3_extended_errcode(db_.connection().get());
+  }
+
+  std::string SQLite::getErrorMessage() {
+    int ec{getErrorCode()};
+    return (0 == ec) ? std::string()
+                     : std::string(sqlite3_errstr(ec)) + ": "
+            + sqlite3_errmsg(db_.connection().get());
+  }
+
+  SQLite::StatementHandle SQLite::createStatement(const std::string &sql) {
+    auto handle{statements_.size()};
+    statements_.emplace_back(db_ << sql);
+    return handle;
+  }
+
+  SQLite::database_binder &SQLite::getStatement(
+      SQLite::StatementHandle handle) {
+    if (handle >= statements_.size()) {
+      throw std::runtime_error("SQLite: statement does not exist");
+    }
+    return statements_[handle];
+  }
+
+  int SQLite::countChanges() {
+    return sqlite3_changes(db_.connection().get());
+  }
+}  // namespace libp2p::storage

test/libp2p/CMakeLists.txt

@@ -16,4 +16,5 @@ add_subdirectory(peer)
 add_subdirectory(protocol)
 add_subdirectory(protocol_muxer)
 add_subdirectory(security)
+add_subdirectory(storage)
 add_subdirectory(transport)

test/libp2p/storage/CMakeLists.txt

@@ -0,0 +1,12 @@
+#
+# Copyright Soramitsu Co., Ltd. All Rights Reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+
+addtest(libp2p_sqlite_test
+    sqlite_test.cpp
+    )
+target_link_libraries(libp2p_sqlite_test
+    Boost::filesystem
+    libp2p_sqlite
+    )

test/libp2p/storage/sqlite_test.cpp

@@ -0,0 +1,96 @@
+/**
+ * Copyright Soramitsu Co., Ltd. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include <libp2p/storage/sqlite.hpp>
+
+#include <vector>
+
+#include <gtest/gtest.h>
+#include <boost/filesystem.hpp>
+
+/// Fixture for in-memory SQLite tests
+struct SQLite : public ::testing::Test {
+  SQLite() : sql(":memory:") {}
+  libp2p::storage::SQLite sql;
+};
+
+/// Operators << and >> provide raw access to SQLite
+TEST_F(SQLite, RawOperators) {
+  int result = 0;
+  sql << "SELECT 1+1" >> result;
+  ASSERT_EQ(result, 2);
+}
+
+/**
+ * Preapared statement can be used more than once
+ * @given a database with a table
+ * @when the table is filled in with multiple calls of a prepared statement
+ * @then table contents can be queries with another prepared statement more than
+ * once
+ */
+TEST_F(SQLite, MultipleUseOfPreparedStatement) {
+  sql << "create table countable(num integer, char text);";
+  auto handle =
+      sql.createStatement("insert into countable(num, char) values(?, ?)");
+  const char chars[] = {"abcdef"};
+  for (size_t i = 0; i < sizeof(chars); ++i) {
+    sql.execCommand(handle, i, chars[i]);
+  }
+
+  auto query = sql.createStatement("select sum(num) from countable");
+  auto checker = [](int sum) {
+    ASSERT_EQ(sum, 21);  // 21 is sum of numbers from 1 to 6
+  };
+  sql.execQuery(query, checker);
+  sql.execQuery(query, checker);
+}
+
+/// Fixture for tests which require a file being saved on disk
+struct Persistence : public ::testing::Test {
+  Persistence() : kTestDbFile("test_db.sqlite") {}
+
+  ~Persistence() {
+    // this code will be executed even if test has thrown an exception
+    if (boost::filesystem::exists(kTestDbFile)) {
+      boost::filesystem::remove(kTestDbFile);
+    }
+  }
+
+  std::string char2string(const char c) {
+    return std::string(1, c);
+  }
+
+  const std::string kTestDbFile;
+};
+
+/**
+ * Database saved on disk preserves stored state
+ * @given an SQLite wrapper which saves the db to kTestDbFile
+ * @when the db is filled with the data and gets closed
+ * @then the db file can be opened and the data is still available
+ */
+TEST_F(Persistence, StatePreserved) {
+  const char chars[] = "abcdef";
+  {
+    libp2p::storage::SQLite sql1(kTestDbFile);
+    sql1 << "create table countable(num integer, char text);";
+    auto handle =
+        sql1.createStatement("insert into countable(num, char) values(?, ?)");
+
+    // loop up to sizeof -1 because of null terminator of C-string
+    for (size_t i = 0; i < sizeof(chars) - 1; ++i) {
+      sql1.execCommand(handle, i, char2string(chars[i]));
+    }
+  }
+  {
+    libp2p::storage::SQLite sql2(kTestDbFile);
+    auto checker = [this, chars](int number, std::string c) {
+      ASSERT_GE(number, 0);
+      ASSERT_LT(number, sizeof(chars));
+      ASSERT_EQ(c, char2string(chars[number]));
+    };
+    sql2 << "select num, char from countable" >> checker;
+  }
+}