add error callback to network.tcp_connect

src/network/Network.cpp

@@ -16,7 +16,10 @@ namespace network {
     std::unique_ptr<Requests> create_curl_requests();
 
     std::shared_ptr<TcpConnection> connect_tcp(
-        const std::string& address, int port, runnable callback
+        const std::string& address,
+        int port,
+        runnable callback,
+        stringconsumer errorCallback
     );
 
     std::shared_ptr<TcpServer> open_tcp_server(
@@ -87,12 +90,19 @@ Server* Network::getServer(u64id_t id, bool includePrivate) const {
     return found->second.get();
 }
 
-u64id_t Network::connectTcp(const std::string& address, int port, consumer<u64id_t> callback) {
+u64id_t Network::connectTcp(
+    const std::string& address,
+    int port,
+    consumer<u64id_t> callback,
+    ConnectErrorCallback errorCallback
+) {
     std::lock_guard lock(connectionsMutex);
     
     u64id_t id = nextConnection++;
     auto socket = connect_tcp(address, port, [id, callback]() {
         callback(id);
+    }, [id, errorCallback](auto errorMessage) {
+        errorCallback(id, errorMessage);
     });
     connections[id] = std::move(socket);
     return id;

src/network/Network.hpp

@@ -7,7 +7,7 @@ namespace network {
     public:
         ~TcpConnection() override = default;
 
-        virtual void connect(runnable callback) = 0;
+        virtual void connect(runnable callback, stringconsumer errorCallback) = 0;
 
         virtual void setNoDelay(bool noDelay) = 0;
         [[nodiscard]] virtual bool isNoDelay() const = 0;
@@ -88,8 +88,18 @@ namespace network {
         [[nodiscard]] Connection* getConnection(u64id_t id, bool includePrivate);
         [[nodiscard]] Server* getServer(u64id_t id, bool includePrivate) const;
 
-        u64id_t connectTcp(const std::string& address, int port, consumer<u64id_t> callback);
-        u64id_t connectUdp(const std::string& address, int port, const consumer<u64id_t>& callback, ClientDatagramCallback handler);
+        u64id_t connectTcp(
+            const std::string& address,
+            int port,
+            consumer<u64id_t> callback,
+            ConnectErrorCallback errorCallback
+        );
+        u64id_t connectUdp(
+            const std::string& address,
+            int port,
+            const consumer<u64id_t>& callback,
+            ClientDatagramCallback handler
+        );
 
         u64id_t openTcpServer(int port, ConnectCallback handler);
         u64id_t openUdpServer(int port, const ServerDatagramCallback& handler);

src/network/Sockets.cpp

@@ -106,6 +106,7 @@ class SocketTcpConnection : public TcpConnection {
     std::vector<char> readBatch;
     util::Buffer<char> buffer;
     std::mutex mutex;
+    std::string errorMessage;
 
     void connectSocket() {
         state = ConnectionState::CONNECTING;
@@ -115,7 +116,8 @@ class SocketTcpConnection : public TcpConnection {
             auto error = handle_socket_error("Connect failed");
             closesocket(descriptor);
             state = ConnectionState::CLOSED;
-            logger.error() << error.what();
+            errorMessage = error.what();
+            logger.error() << errorMessage;
             return;
         }
         logger.info() << "connected to " << to_string(addr);
@@ -182,13 +184,15 @@ public:
         thread = std::make_unique<std::thread>([this]() { startListen();});
     }
 
-    void connect(runnable callback) override {
-        thread = std::make_unique<std::thread>([this, callback]() {
+    void connect(runnable callback, stringconsumer errorCallback) override {
+        thread = std::make_unique<std::thread>([this, callback, errorCallback]() {
             connectSocket();
             if (state == ConnectionState::CONNECTED) {
                 callback();
+                startListen();
+            } else {
+                errorCallback(errorMessage);
             }
-            startListen();
         });
     }
 
@@ -263,7 +267,10 @@ public:
     }
 
     static std::shared_ptr<SocketTcpConnection> connect(
-        const std::string& address, int port, runnable callback
+        const std::string& address,
+        int port,
+        runnable callback,
+        stringconsumer errorCallback
     ) {
         addrinfo hints {};
 
@@ -274,7 +281,11 @@ public:
         if (int res = getaddrinfo(
             address.c_str(), nullptr, &hints, &addrinfo
         )) {
-            throw std::runtime_error(gai_strerror(res));
+            std::string errorMessage = gai_strerror(res);
+            if (errorCallback) {
+                errorCallback(errorMessage);
+            }
+            throw std::runtime_error(errorMessage);
         }
 
         sockaddr_in serverAddress;
@@ -284,10 +295,14 @@ public:
 
         SOCKET descriptor = socket(AF_INET, SOCK_STREAM, 0);
         if (descriptor == -1) {
-            throw std::runtime_error("Could not create socket");
+            std::string errorMessage = "could not create socket";
+            if (errorCallback) {
+                errorCallback(errorMessage);
+            }
+            throw std::runtime_error(errorMessage);
         }
         auto socket = std::make_shared<SocketTcpConnection>(descriptor, std::move(serverAddress));
-        socket->connect(std::move(callback));
+        socket->connect(std::move(callback), std::move(errorCallback));
         return socket;
     }
 
@@ -670,9 +685,14 @@ public:
 
 namespace network {
     std::shared_ptr<TcpConnection> connect_tcp(
-        const std::string& address, int port, runnable callback
+        const std::string& address,
+        int port,
+        runnable callback,
+        stringconsumer errorCallback
     ) {
-        return SocketTcpConnection::connect(address, port, std::move(callback));
+        return SocketTcpConnection::connect(
+            address, port, std::move(callback), std::move(errorCallback)
+        );
     }
 
     std::shared_ptr<TcpServer> open_tcp_server(

src/network/commons.hpp

@@ -13,6 +13,7 @@ namespace network {
     using OnResponse = std::function<void(std::vector<char>)>;
     using OnReject = std::function<void(int, std::vector<char>)>;
     using ConnectCallback = std::function<void(u64id_t, u64id_t)>;
+    using ConnectErrorCallback = std::function<void(u64id_t, std::string)>;
     using ServerDatagramCallback = std::function<void(u64id_t sid, const std::string& addr, int port, const char* buffer, size_t length)>;
     using ClientDatagramCallback = std::function<void(u64id_t cid, const char* buffer, size_t length)>;