ConnectionPool.h

Go to the documentation of this file.

#ifndef LINTEL_CONNECTIONPOOL_H
#define LINTEL_CONNECTIONPOOL_H
 
#include <chrono>
#include <condition_variable>
#include <cstddef>
#include <functional>
#include <map>
#include <memory>
#include <mutex>
#include <source_location>
#include <string>
#include <thread>
#include <vector>
 
#include "lintel/core/configuration/DatabaseConnectionEntry.h"
#include "lintel/core/persistence/Connection.h"
 
namespace lintel {
namespace db {
  struct PoolSettings
  {
    std::size_t maxConnections = 0;
    std::chrono::milliseconds acquireTimeout{ 5000 };
  };
 
  class ConnectionPool
  {
  public:
    using Connector = std::function<std::unique_ptr<Connection>()>;
    using HealthCheck = std::function<bool(const Connection &)>;
 
    class Lease
    {
    public:
      Lease() = default;
      Lease(const Lease &) = delete;
      Lease &operator=(const Lease &) = delete;
      Lease(Lease &&other) noexcept;
      Lease &operator=(Lease &&other) noexcept;
      ~Lease();
 
      [[nodiscard]] Connection &connection() const;
 
      [[nodiscard]] bool valid() const { return m_connection != nullptr; }
 
    private:
      friend class ConnectionPool;
 
      Lease(ConnectionPool *pool, std::unique_ptr<Connection> connection, std::thread::id owner);
 
      void reset();
 
      ConnectionPool *m_pool = nullptr;
      std::unique_ptr<Connection> m_connection;
      std::thread::id m_owner;
    };
 
    explicit ConnectionPool(std::shared_ptr<DatabaseConnectionEntry> connectionEntry,
      PoolSettings settings,
      HealthCheck healthCheck = {},
      Connector connector = {});
 
    ConnectionPool(const ConnectionPool &) = delete;
    ConnectionPool &operator=(const ConnectionPool &) = delete;
 
    Lease acquire(std::source_location location = std::source_location::current());
 
    [[nodiscard]] const std::string &name() const;
 
    [[nodiscard]] std::size_t maxConnections() const { return m_settings.maxConnections; }
 
    [[nodiscard]] std::size_t outstanding() const;
 
    [[nodiscard]] std::size_t available() const;
 
  private:
    friend class Lease;
 
    void release(std::unique_ptr<Connection> connection, std::thread::id owner);
 
    [[nodiscard]] bool isHealthy(const Connection &connection) const;
 
    [[nodiscard]] std::string describeOutstanding(std::thread::id waiting) const;
 
    [[nodiscard]] static std::string describeLocation(const std::source_location &location);
 
    struct OutstandingLease
    {
      std::thread::id m_owner;
      std::source_location m_location;
      std::chrono::steady_clock::time_point m_acquired;
    };
 
    std::shared_ptr<DatabaseConnectionEntry> m_connectionEntry;
    PoolSettings m_settings;
    HealthCheck m_healthCheck;
    Connector m_connector;
    mutable std::mutex m_mutex;
    std::condition_variable m_condition;
    std::vector<std::unique_ptr<Connection>> m_idle;
    std::map<std::thread::id, OutstandingLease> m_outstanding;
    std::size_t m_created = 0;
  };
}// namespace db
 
}// namespace lintel
#endif// LINTEL_CONNECTIONPOOL_H