increase timeout and make connecting in parallel

Author: krypdkat

QubicServer.cpp

@@ -270,7 +270,7 @@ namespace {
 
                 // Set accept timeout for periodic cleanup
                 struct timeval tv;
-                tv.tv_sec = 1;
+                tv.tv_sec = 10;
                 tv.tv_usec = 0;
                 ::setsockopt(listen_fd_, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv));
 

connection/connection.cpp

@@ -3,11 +3,11 @@
 #include <stdexcept>
 #include <algorithm> // For std::min
 #include <thread>
-
 #include <sys/socket.h>
 #include <netinet/in.h>
 #include <arpa/inet.h>
 #include <unistd.h>
+#include <atomic>
 #include <cstring>
 #include <cerrno>  // for errno
 #include <fcntl.h>
@@ -35,7 +35,7 @@ static int do_connect(const char* nodeIp, int nodePort)
 
     // Configure timeouts (best-effort)
     struct timeval tv;
-    tv.tv_sec = 2;
+    tv.tv_sec = 10;
     tv.tv_usec = 0;
     if (setsockopt(serverSocket, SOL_SOCKET, SO_RCVTIMEO, (const void*)&tv, sizeof tv) < 0) {
         Logger::get()->warn("setsockopt(SO_RCVTIMEO) failed: {} ({})", errno, strerror(errno));
@@ -360,7 +360,7 @@ QubicConnection::QubicConnection(int existingSocket)
     if (mSocket >= 0) {
         // Configure timeouts (best-effort)
         struct timeval tv;
-        tv.tv_sec = 2;
+        tv.tv_sec = 10;
         tv.tv_usec = 0;
         if (setsockopt(mSocket, SOL_SOCKET, SO_RCVTIMEO, (const void*)&tv, sizeof tv) < 0) {
             Logger::get()->warn("setsockopt(SO_RCVTIMEO) failed: {} ({})", errno, strerror(errno));
@@ -380,7 +380,18 @@ QubicConnection::QubicConnection(int existingSocket)
 void parseConnection(ConnectionPool& connPoolAll,
                      std::vector<std::string>& endpoints)
 {
-    // Try endpoints in order, connect to the first that works
+    struct ParsedEndpoint
+    {
+        std::string endpoint;
+        std::string nodeType;
+        std::string ip;
+        int port = 0;
+        bool has_passcode = false;
+        uint64_t passcode_arr[4] = {0, 0, 0, 0};
+    };
+
+    std::vector<ParsedEndpoint> parsedEndpoints;
+    parsedEndpoints.reserve(endpoints.size());
 
     for (const auto& endpoint : endpoints) {
         // Expected format: nodeType:ip:port[:pass0-pass1-pass2-pass3]
@@ -430,47 +441,92 @@ void parseConnection(ConnectionPool& connPoolAll,
             continue;
         }
 
+        ParsedEndpoint parsed;
+        parsed.endpoint = endpoint;
+        parsed.nodeType = nodeType;
+        parsed.ip = ip;
+        parsed.port = port;
+
         // Optional passcode parsing
-        bool has_passcode = false;
-        uint64_t passcode_arr[4] = {0,0,0,0};
         if (!passcode_str.empty()) {
-            // Split by '-'
-            uint64_t parsed[4];
+            uint64_t parsedPasscode[4] = {0,0,0,0};
             size_t start = 0;
             int idx = 0;
             while (idx < 4 && start <= passcode_str.size()) {
                 size_t dash = passcode_str.find('-', start);
                 auto token = passcode_str.substr(start, (dash == std::string::npos) ? std::string::npos : (dash - start));
                 if (token.empty()) break;
                 try {
-                    parsed[idx] = static_cast<uint64_t>(std::stoull(token, nullptr, 10));
+                    parsedPasscode[idx] = static_cast<uint64_t>(std::stoull(token, nullptr, 10));
                 } catch (...) {
-                    idx = -1; // mark error
+                    idx = -1;
                     break;
                 }
                 idx++;
                 if (dash == std::string::npos) break;
                 start = dash + 1;
             }
             if (idx == 4) {
-                memcpy(passcode_arr, parsed, sizeof(parsed));
-                has_passcode = true;
+                memcpy(parsed.passcode_arr, parsedPasscode, sizeof(parsedPasscode));
+                parsed.has_passcode = true;
             } else {
                 Logger::get()->warn("Skipping endpoint '{}': invalid passcode format, expected 4 uint64 separated by '-'", endpoint);
                 continue;
             }
         }
 
-        QCPtr conn = make_qc(ip.c_str(), port);
-        conn->setNodeType(nodeType);
-        if (has_passcode) {
-            conn->updatePasscode(passcode_arr);
+        parsedEndpoints.push_back(std::move(parsed));
+    }
+
+    if (parsedEndpoints.empty()) {
+        return;
+    }
+
+    std::vector<QCPtr> createdConnections(parsedEndpoints.size());
+    std::atomic<size_t> nextIndex{0};
+
+    unsigned int workerCount = parsedEndpoints.size();
+
+    std::vector<std::thread> workers;
+    workers.reserve(workerCount);
+
+    for (unsigned int worker = 0; worker < workerCount; ++worker) {
+        workers.emplace_back([&]() {
+            while (true) {
+                size_t index = nextIndex.fetch_add(1);
+                if (index >= parsedEndpoints.size()) {
+                    break;
+                }
+
+                const auto& ep = parsedEndpoints[index];
+                QCPtr conn = make_qc(ep.ip.c_str(), ep.port);
+                conn->setNodeType(ep.nodeType);
+                if (ep.has_passcode) {
+                    conn->updatePasscode(const_cast<uint64_t*>(ep.passcode_arr));
+                }
+                createdConnections[index] = conn;
+            }
+        });
+    }
+
+    for (auto& worker : workers) {
+        if (worker.joinable()) {
+            worker.join();
+        }
+    }
+
+    for (size_t i = 0; i < parsedEndpoints.size(); ++i) {
+        const auto& ep = parsedEndpoints[i];
+        QCPtr& conn = createdConnections[i];
+        if (!conn) {
+            Logger::get()->warn("Failed to create connection object for node {}", ep.endpoint);
+            continue;
         }
         if (!conn->isSocketValid()) {
-            Logger::get()->warn("Failed to connect to node {}. Will try to reconnect later", endpoint);
+            Logger::get()->warn("Failed to connect to node {}. Will try to reconnect later", ep.endpoint);
         }
         connPoolAll.add(conn);
-        Logger::get()->info("Added {} node {}:{}{}", nodeType, ip, port, has_passcode ? " (trusted)" : "");
+        Logger::get()->info("Added {} node {}:{}{}", ep.nodeType, ep.ip, ep.port, ep.has_passcode ? " (trusted)" : "");
     }
 }