Refactoring connection_pool.cpp

Author: jahnvi480

mssql_python/pybind/connection/connection_pool.cpp

@@ -1,16 +1,20 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT license.
 
-// INFO|TODO - Note that is file is Windows specific right now. Making it arch agnostic will be
-//             taken up in future.
+// INFO|TODO - Note that is file is Windows specific right now. Making it
+//             arch agnostic will be taken up in future.
 
-#include "connection_pool.h"
+#include "connection/connection_pool.h"
 #include <exception>
+#include <memory>
+#include <vector>
 
 ConnectionPool::ConnectionPool(size_t max_size, int idle_timeout_secs)
-    : _max_size(max_size),  _idle_timeout_secs(idle_timeout_secs), _current_size(0) {}
+    : _max_size(max_size), _idle_timeout_secs(idle_timeout_secs),
+      _current_size(0) {}
 
-std::shared_ptr<Connection> ConnectionPool::acquire(const std::wstring& connStr, const py::dict& attrs_before) {
+std::shared_ptr<Connection> ConnectionPool::acquire(
+    const std::wstring& connStr, const py::dict& attrs_before) {
     std::vector<std::shared_ptr<Connection>> to_disconnect;
     std::shared_ptr<Connection> valid_conn = nullptr;
     {
@@ -21,7 +25,8 @@ std::shared_ptr<Connection> ConnectionPool::acquire(const std::wstring& connStr,
         // Phase 1: Remove stale connections, collect for later disconnect
         _pool.erase(std::remove_if(_pool.begin(), _pool.end(),
             [&](const std::shared_ptr<Connection>& conn) {
-                auto idle_time = std::chrono::duration_cast<std::chrono::seconds>(now - conn->lastUsed()).count();
+                auto idle_time = std::chrono::duration_cast<
+                    std::chrono::seconds>(now - conn->lastUsed()).count();
                 if (idle_time > _idle_timeout_secs) {
                     to_disconnect.push_back(conn);
                     return true;
@@ -30,7 +35,8 @@ std::shared_ptr<Connection> ConnectionPool::acquire(const std::wstring& connStr,
             }), _pool.end());
 
         size_t pruned = before - _pool.size();
-        _current_size = (_current_size >= pruned) ? (_current_size - pruned) : 0;
+        _current_size = (_current_size >= pruned) ?
+                        (_current_size - pruned) : 0;
 
         // Phase 2: Attempt to reuse healthy connections
         while (!_pool.empty()) {
@@ -56,7 +62,8 @@ std::shared_ptr<Connection> ConnectionPool::acquire(const std::wstring& connStr,
             valid_conn->connect(attrs_before);
             ++_current_size;
         } else if (!valid_conn) {
-            throw std::runtime_error("ConnectionPool::acquire: pool size limit reached");
+            throw std::runtime_error(
+                "ConnectionPool::acquire: pool size limit reached");
         }
     }
 
@@ -76,8 +83,7 @@ void ConnectionPool::release(std::shared_ptr<Connection> conn) {
     if (_pool.size() < _max_size) {
         conn->updateLastUsed();
         _pool.push_back(conn);
-    }
-    else {
+    } else {
         conn->disconnect();
         if (_current_size > 0) --_current_size;
     }
@@ -97,7 +103,8 @@ void ConnectionPool::close() {
         try {
             conn->disconnect();
         } catch (const std::exception& ex) {
-            LOG("ConnectionPool::close: disconnect failed: {}", ex.what());
+            LOG("ConnectionPool::close: disconnect failed: {}",
+                ex.what());
         }
     }
 }
@@ -107,18 +114,21 @@ ConnectionPoolManager& ConnectionPoolManager::getInstance() {
     return manager;
 }
 
-std::shared_ptr<Connection> ConnectionPoolManager::acquireConnection(const std::wstring& connStr, const py::dict& attrs_before) {
+std::shared_ptr<Connection> ConnectionPoolManager::acquireConnection(
+    const std::wstring& connStr, const py::dict& attrs_before) {
     std::lock_guard<std::mutex> lock(_manager_mutex);
 
     auto& pool = _pools[connStr];
     if (!pool) {
         LOG("Creating new connection pool");
-        pool = std::make_shared<ConnectionPool>(_default_max_size, _default_idle_secs);
+        pool = std::make_shared<ConnectionPool>(_default_max_size,
+                                                _default_idle_secs);
     }
     return pool->acquire(connStr, attrs_before);
 }
 
-void ConnectionPoolManager::returnConnection(const std::wstring& conn_str, const std::shared_ptr<Connection> conn) {
+void ConnectionPoolManager::returnConnection(
+    const std::wstring& conn_str, const std::shared_ptr<Connection> conn) {
     std::lock_guard<std::mutex> lock(_manager_mutex);
     if (_pools.find(conn_str) != _pools.end()) {
         _pools[conn_str]->release((conn));