fix: resolve TSan data races and CI configuration errors

Summary of changes:
- Implemented thread-safe state management in Server using state_mutex_.
- Fixed clang-tidy argument parsing for sanitizer flags in CMake.
- Silenced conflicting and noisy static analysis checks.
- Improved networking test robustness with socket validation.

Author: poyrazK

.clang-tidy

@@ -22,7 +22,9 @@ Checks: 'clang-diagnostic-*,
          -readability-function-cognitive-complexity,
          -cppcoreguidelines-avoid-const-or-ref-data-members,
          -misc-non-private-member-variables-in-classes,
-         -bugprone-easily-swappable-parameters'
+         -bugprone-easily-swappable-parameters,
+         -bugprone-unchecked-optional-access,
+         -modernize-use-default-member-init'
 WarningsAsErrors: ''
 HeaderFilterRegex: 'include/.*'
 FormatStyle: none

include/network/server.hpp

@@ -88,9 +88,10 @@ class Server {
     void wait();
 
     const ServerStats& get_stats() const { return stats_; }
-    ServerStatus get_status() const { return status_; }
+    ServerStatus get_status() const;
     uint16_t get_port() const { return port_; }
-    bool is_running() const { return running_.load(); }
+    bool is_running() const;
+    int get_listen_fd() const;
     std::string get_status_string() const;
 
    private:
@@ -99,8 +100,8 @@ class Server {
 
     uint16_t port_;
     int listen_fd_;
-    std::atomic<bool> running_{false};
-    std::atomic<ServerStatus> status_;
+    bool running_{false};
+    ServerStatus status_;
 
     Catalog& catalog_;
     storage::StorageManager& storage_manager_;
@@ -111,6 +112,7 @@ class Server {
     std::thread accept_thread_;
     std::vector<std::thread> worker_threads_;
     std::mutex thread_mutex_;
+    mutable std::mutex state_mutex_;
 };
 
 }  // namespace network

src/network/server.cpp

@@ -24,7 +24,7 @@ namespace network {
 class ProtocolReader {
    public:
     static uint32_t read_int32(const char* buffer) {
-        uint32_t val;
+        uint32_t val = 0;
         std::memcpy(&val, buffer, 4);
         return ntohl(val);
     }
@@ -85,32 +85,41 @@ std::unique_ptr<Server> Server::create(uint16_t port, Catalog& catalog,
  * @brief Start the server
  */
 bool Server::start() {
-    if (running_.load()) return false;
+    {
+        std::lock_guard<std::mutex> lock(state_mutex_);
+        if (running_) return false;
+    }
 
-    listen_fd_ = socket(AF_INET, SOCK_STREAM, 0);
-    if (listen_fd_ < 0) return false;
+    int fd = socket(AF_INET, SOCK_STREAM, 0);
+    if (fd < 0) return false;
 
     int opt = 1;
-    setsockopt(listen_fd_, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
+    setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
 
     struct sockaddr_in addr;
     memset(&addr, 0, sizeof(addr));
     addr.sin_family = AF_INET;
     addr.sin_addr.s_addr = INADDR_ANY;
     addr.sin_port = htons(port_);
 
-    if (bind(listen_fd_, (struct sockaddr*)&addr, sizeof(addr)) < 0) {
-        close(listen_fd_);
+    if (bind(fd, (struct sockaddr*)&addr, sizeof(addr)) < 0) {
+        close(fd);
         return false;
     }
 
-    if (listen(listen_fd_, 10) < 0) {
-        close(listen_fd_);
+    if (listen(fd, 10) < 0) {
+        close(fd);
         return false;
     }
 
-    status_ = ServerStatus::Running;
-    running_ = true;
+    {
+        std::lock_guard<std::mutex> lock(state_mutex_);
+        listen_fd_ = fd;
+        status_ = ServerStatus::Running;
+        running_ = true;
+    }
+    
+    std::lock_guard<std::mutex> lock(thread_mutex_);
     accept_thread_ = std::thread(&Server::accept_connections, this);
     return true;
 }
@@ -119,40 +128,69 @@ bool Server::start() {
  * @brief Stop the server
  */
 bool Server::stop() {
-    if (!running_.load()) return true;
-
-    status_ = ServerStatus::Stopping;
-    running_ = false;
+    int fd_to_close = -1;
+    {
+        std::lock_guard<std::mutex> lock(state_mutex_);
+        if (!running_) return true;
+        status_ = ServerStatus::Stopping;
+        running_ = false;
+        if (listen_fd_ >= 0) {
+            shutdown(listen_fd_, SHUT_RDWR);
+            fd_to_close = listen_fd_;
+            listen_fd_ = -1;
+        }
+    }
 
-    shutdown(listen_fd_, SHUT_RDWR);
-    close(listen_fd_);
-    listen_fd_ = -1;
+    {
+        std::lock_guard<std::mutex> lock(thread_mutex_);
+        if (accept_thread_.joinable()) {
+            accept_thread_.join();
+        }
 
-    if (accept_thread_.joinable()) {
-        accept_thread_.join();
+        /* Join all connection worker threads */
+        for (auto& t : worker_threads_) {
+            if (t.joinable()) {
+                t.join();
+            }
+        }
+        worker_threads_.clear();
     }
 
-    /* Join all connection worker threads */
-    std::lock_guard<std::mutex> lock(thread_mutex_);
-    for (auto& t : worker_threads_) {
-        if (t.joinable()) {
-            t.join();
-        }
+    if (fd_to_close >= 0) {
+        close(fd_to_close);
     }
-    worker_threads_.clear();
 
-    status_ = ServerStatus::Stopped;
+    {
+        std::lock_guard<std::mutex> lock(state_mutex_);
+        status_ = ServerStatus::Stopped;
+    }
     return true;
 }
 
 void Server::wait() {
+    std::lock_guard<std::mutex> lock(thread_mutex_);
     if (accept_thread_.joinable()) {
         accept_thread_.join();
     }
 }
 
+bool Server::is_running() const {
+    std::lock_guard<std::mutex> lock(state_mutex_);
+    return running_;
+}
+
+ServerStatus Server::get_status() const {
+    std::lock_guard<std::mutex> lock(state_mutex_);
+    return status_;
+}
+
+int Server::get_listen_fd() const {
+    std::lock_guard<std::mutex> lock(state_mutex_);
+    return listen_fd_;
+}
+
 std::string Server::get_status_string() const {
-    switch (status_) {
+    switch (get_status()) {
         case ServerStatus::Stopped:
             return "Stopped";
         case ServerStatus::Starting:
@@ -169,13 +207,16 @@ std::string Server::get_status_string() const {
 }
 
 void Server::accept_connections() {
-    while (running_.load()) {
+    while (is_running()) {
         struct sockaddr_in client_addr;
         socklen_t client_len = sizeof(client_addr);
 
-        int client_fd = accept(listen_fd_, (struct sockaddr*)&client_addr, &client_len);
+        int fd = get_listen_fd();
+        if (fd < 0) break;
+
+        int client_fd = accept(fd, (struct sockaddr*)&client_addr, &client_len);
         if (client_fd < 0) {
-            if (!running_.load()) break;
+            if (!is_running()) break;
             continue;
         }
 
@@ -253,7 +294,7 @@ void Server::handle_connection(int client_fd) {
     send(client_fd, ready.data(), ready.size(), 0);
 
     /* 5. Main Message Loop */
-    while (running_.load()) {
+    while (is_running()) {
         char type;
         n = recv(client_fd, &type, 1, 0);
         if (n <= 0) break;

tests/cloudSQL_tests.cpp

@@ -424,6 +424,7 @@ TEST(NetworkTest_MultiClient) {
     for (int i = 0; i < num_clients; ++i) {
         clients.emplace_back([&port, &success_count]() {
             int sock = socket(AF_INET, SOCK_STREAM, 0);
+            if (sock < 0) return;
             struct sockaddr_in addr;
             addr.sin_family = AF_INET;
             addr.sin_port = htons(port);