Database interaction is done

Author: Add-JDHero

sprint4/problems/leave_game/solution/CMakeLists.txt

@@ -7,6 +7,20 @@ set(CXX_STANDARD_REQUIRED ON)
 include(${CMAKE_BINARY_DIR}/conanbuildinfo_multi.cmake)
 conan_basic_setup(TARGETS)
 
+# Указываем путь к заголовкам
+# include_directories(/usr/include/pqxx)
+
+# # Ищем библиотеку
+# find_library(PQXX_LIB pqxx REQUIRED HINTS /usr/lib/aarch64-linux-gnu)
+
+find_package(PkgConfig REQUIRED)
+pkg_check_modules(PQXX REQUIRED libpqxx)
+
+# Добавляем найденные пути к заголовкам
+include_directories(${PQXX_INCLUDE_DIRS})
+link_directories(${PQXX_LIBRARY_DIRS})
+
+# Добавляем библиотеку к линковке
 # get_property(importTargets DIRECTORY "${CMAKE_SOURCE_DIR}" PROPERTY IMPORTED_TARGETS)
 # message(STATUS "${importTargets}") 
 
@@ -52,6 +66,12 @@ add_executable(game_server
   src/collision_detector.cpp
   src/model_serialization.h
   src/model_serialization.cpp
+  src/database_manager.h
+  src/database_manager.cpp
 )
 
-target_link_libraries(game_server CONAN_PKG::boost) 
+target_link_libraries(game_server 
+  CONAN_PKG::boost
+  # ${PQXX_LIB}
+  ${PQXX_LIBRARIES}
+) 

sprint4/problems/leave_game/solution/server_state.txt

@@ -1,12 +1,20 @@
 #include "application.h"
+#include "database_manager.h"
 #include "handlers.h"
 #include "json_loader.h"
 #include "model.h"
 #include "model_serialization.h"
 #include "player.h"
 #include "type_declarations.h"
+#include "log.h"
+
+#include <boost/log/trivial.hpp>
+#include <boost/exception/all.hpp>
+
 #include <boost/json/object.hpp>
 #include <iomanip>
+#include <exception>
+#include <unordered_set>
 
 namespace app {
     char to_uppercase(unsigned char c) {
@@ -195,8 +203,9 @@ namespace app {
         }
     }
 
-Application::Application(model::Game& game) 
-        : game_(game) {
+Application::Application(model::Game& game, db::ConnectionPool& pool) 
+        : game_(game)
+        , connection_pool_(pool) {
     }
 
     const std::vector<std::string> 
@@ -225,6 +234,8 @@ Application::Application(model::Game& game)
             players_.GetPlayerByToken(token);
         if (!player) return boost::json::serialize(players_json);
 
+        // for (const auto& )
+
         for (const auto& [dog_name, dog_id] : players_.GetPlayerNamesToId()) {
             players_json[std::to_string(dog_id)] = boost::json::object{
                 {"name", dog_name}
@@ -277,7 +288,8 @@ Application::Application(model::Game& game)
     }
 
     void Application::Tick(milliseconds delta_time) const {
-        game_.GetEngine().Tick(delta_time);
+        std::unordered_set<std::shared_ptr<model::Dog>> 
+            afk_players = game_.GetEngine().Tick(delta_time);
 
         if (listener_) {
             listener_->OnTick(delta_time);
@@ -324,9 +336,9 @@ namespace serialization {
             }
 
             std::filesystem::rename(temp_file, state_file_);
-            std::cout << "Game state saved to " << state_file_ << std::endl;
+            std::cout << "Game state saved to file: " << state_file_ << std::endl;
         } catch (const std::exception& e) {
-            std::cerr << "Error saving game state: " << e.what() << std::endl;
+            throw std::runtime_error(e.what());
         }
     }
 
@@ -354,7 +366,7 @@ namespace serialization {
 
             LoadGameDataFromFile(std::move(g_s));
 
-            std::cout << "Game state restored from " << state_file_ << std::endl;
+            std::cout << "Game state restored from file: "s << state_file_ << std::endl;
         } catch (const std::exception& e) {
             std::cerr << "Error loading game state: " << e.what() << std::endl;
             exit(EXIT_FAILURE);

sprint4/problems/leave_game/solution/src/application.cpp

@@ -6,6 +6,7 @@
 #include "infrastructure.h"
 #include "player.h"
 #include "model.h"
+#include "database_manager.h"
 
 #include <chrono>
 #include <cstdint>
@@ -142,13 +143,18 @@ namespace app {
             model::Dog::Id id;
         };
 
-        explicit Application(model::Game& game);
+        explicit Application(model::Game& game, 
+                             db::ConnectionPool& pool);
 
         void SetApplicationListener(ApplicationListener& listener);
 
         const std::string GetSerializedPlayersList(const Token& token) const;
         const std::string GetSerializedGameState(const Token& token) const;
 
+        std::string GetGameRecords() const {
+            return game_.GetGameRecords();
+        }
+
         model::MapService& GetGameMapService() {
             return game_.GetMapService();
         }
@@ -206,6 +212,8 @@ namespace app {
 
         Token FindTokenByPlayer(std::shared_ptr<player::Player> player);
 
+        db::ConnectionPool& connection_pool_;
+
 		model::Game& game_;
 		Players players_;
         ApplicationListener* listener_ = nullptr;
@@ -322,7 +330,6 @@ namespace app_serialization {
 
         template <typename Archive>
         void serialize(Archive& ar, [[maybe_unused]] const unsigned version) {
-            std::cout << "Serializing players, count: " << players_.size() << std::endl;
             ar & players_;
             ar & dog_ids_;
         }

sprint4/problems/leave_game/solution/src/application.h

@@ -0,0 +1,73 @@
+#include "database_manager.h"
+
+namespace db {
+    db::ConnectionPool CreateConnectionPool(unsigned num_threads, const std::string& db_url) {
+        return db::ConnectionPool{
+            num_threads, [db_url] {
+                return std::make_shared<pqxx::connection>(db_url);
+            }
+        };
+    }
+
+    void InitDatabase(db::ConnectionPool& conn_pool) {
+        auto connection = conn_pool.GetConnection();
+        
+        pqxx::work work{ *connection };
+
+        work.exec(R"(
+            CREATE TABLE IF NOT EXISTS retired_players (
+                id UUID DEFAULT gen_random_uuid() PRIMARY KEY, 
+                name VARCHAR(100) NOT NULL, 
+                score INTEGER, 
+                play_time_ms INTEGER
+            );
+        )");
+
+        work.exec(R"(
+            CREATE INDEX IF NOT EXISTS retired_players_idx 
+            ON retired_players USING btree (score DESC, play_time_ms, name);
+        )");
+
+        work.commit();
+    }
+
+    void RegisterPrepQueries(ConnectionPool::ConnectionWrapper conn_wrap) {
+        conn_wrap->prepare(
+            "insert_retire", 
+            "INSERT INTO retired_players (name, score, play_time_ms) VALUES ($1, $2, $3)"
+        );
+    }
+
+    template <typename ConnectionFactory>
+    ConnectionPool::ConnectionPool(size_t capacity, 
+                                   ConnectionFactory&& connection_factory) {
+        pool_.reserve(capacity);
+        for (size_t i = 0; i < capacity; ++i) {
+            pool_.emplace_back(connection_factory());
+            RegisterPrepQueries(GetConnection());
+        }
+    }
+
+    ConnectionPool::ConnectionWrapper ConnectionPool::GetConnection() {
+        std::unique_lock lock{mutex_};
+        // Блокируем текущий поток и ждём, пока cond_var_ не получит 
+        // уведомление и не освободится хотя бы одно соединение
+        cond_var_.wait(lock, [this] {
+            return used_connections_ < pool_.size();
+        });
+        // После выхода из цикла ожидания мьютекс остаётся захваченным
+
+        return {std::move(pool_[used_connections_++]), *this};
+    }
+
+    void ConnectionPool::ReturnConnection(ConnectionPtr&& conn) {
+        // Возвращаем соединение обратно в пул
+        {
+            std::lock_guard lock{mutex_};
+            assert(used_connections_ != 0);
+            pool_[--used_connections_] = std::move(conn);
+        }
+        // Уведомляем один из ожидающих потоков об изменении состояния пула
+        cond_var_.notify_one();
+    }
+}

sprint4/problems/leave_game/solution/src/database_manager.cpp

@@ -0,0 +1,74 @@
+#pragma once
+#include <memory>
+
+#include <cassert>
+#include <condition_variable>
+#include <mutex>
+
+#include <pqxx/pqxx>
+
+namespace db {
+    // using pqxx::operator"" _zv;
+
+    class ConnectionPool;
+    class ConnectionWrapper;
+
+    ConnectionPool CreateConnectionPool(unsigned num_threads, const std::string& db_url);
+
+    void InitDatabase(db::ConnectionPool& conn_pool);
+
+    void RegisterPrepQueries(ConnectionWrapper connection);
+
+    class ConnectionPool {
+        using PoolType = ConnectionPool;
+        using ConnectionPtr = std::shared_ptr<pqxx::connection>;
+
+    public:
+        class ConnectionWrapper {
+        public:
+            ConnectionWrapper(std::shared_ptr<pqxx::connection>&& conn, PoolType& pool) noexcept
+                : conn_{std::move(conn)}
+                , pool_{&pool} {
+            }
+
+            ConnectionWrapper(const ConnectionWrapper&) = delete;
+            ConnectionWrapper& operator=(const ConnectionWrapper&) = delete;
+
+            ConnectionWrapper(ConnectionWrapper&&) = default;
+            ConnectionWrapper& operator=(ConnectionWrapper&&) = default;
+
+            pqxx::connection& operator*() const& noexcept {
+                return *conn_;
+            }
+            pqxx::connection& operator*() const&& = delete;
+
+            pqxx::connection* operator->() const& noexcept {
+                return conn_.get();
+            }
+
+            ~ConnectionWrapper() {
+                if (conn_) {
+                    pool_->ReturnConnection(std::move(conn_));
+                }
+            }
+
+        private:
+            std::shared_ptr<pqxx::connection> conn_;
+            PoolType* pool_;
+        };
+
+        // ConnectionFactory is a functional object returning std::shared_ptr<pqxx::connection>
+        template <typename ConnectionFactory>
+        ConnectionPool(size_t capacity, ConnectionFactory&& connection_factory);
+
+        ConnectionWrapper GetConnection() ;
+
+    private:
+        void ReturnConnection(ConnectionPtr&& conn) ;
+
+        std::mutex mutex_;
+        std::condition_variable cond_var_;
+        std::vector<ConnectionPtr> pool_;
+        size_t used_connections_ = 0;
+    };
+} //namespace db

sprint4/problems/leave_game/solution/src/database_manager.h

@@ -55,6 +55,7 @@ namespace http_server {
         if (ec) {
             return ReportError(ec, "read"sv);
         }
+        
         HandleRequest(std::move(request_));
     }
 

sprint4/problems/leave_game/solution/src/http_server.cpp

@@ -9,6 +9,8 @@
 #include <string_view>
 #include <boost/log/utility/manipulators/add_value.hpp>
 #include <boost/json.hpp>
+#include <boost/exception/all.hpp>
+
 
 namespace logging = boost::log;
 

sprint4/problems/leave_game/solution/src/log.h

@@ -9,6 +9,7 @@
 #include "request_handler.h"
 #include "ticker.h"
 #include "extra_data.h"
+#include "database_manager.h"
 
 #include <boost/asio/io_context.hpp>
 #include <chrono>
@@ -37,7 +38,6 @@ void RunWorkers(unsigned n, const Fn& fn) {
     }
     fn();
 }
-
 }  // namespace
 
 int main(int argc, const char* argv[]) {
@@ -64,11 +64,18 @@ int main(int argc, const char* argv[]) {
 
         std::chrono::milliseconds tick_time = std::chrono::milliseconds(static_cast<int>(arg.period));
 
+        std::string db_url = std::getenv("DATABASE_URL");
+        const unsigned num_threads = std::thread::hardware_concurrency();
+
+        auto conn_pool = db::CreateConnectionPool(num_threads, db_url.data());
+        db::InitDatabase(conn_pool);
+
         // 1. Загружаем карту из файла и строим модель игры
         model::Game game = json_loader::LoadGame(arg.config);
         game.SetDefaultTickTime(static_cast<double>(tick_time.count()));
+        game.SetDBConnPool(&conn_pool);
 
-        app::Application app(game);
+        app::Application app(game, conn_pool);
 
         serialization::SerializingListener serializer(app, arg.state_file, std::chrono::milliseconds{3500});
         if (!arg.state_file.empty()) {
@@ -79,7 +86,6 @@ int main(int argc, const char* argv[]) {
         }
 
         // 2. Инициализируем io_context
-        const unsigned num_threads = std::thread::hardware_concurrency();
         net::io_context ioc(num_threads);
         net::strand strand = net::make_strand(ioc);