fix: make subscription webhook delivery synchronous to prevent connection exhaustion

RPCSub::sendThread() was passing the application's main io_service to
RPCCall::fromNetwork(), which posts async HTTP operations and returns
immediately. This caused sendThread() to fire unbounded concurrent
connections, exhausting file descriptors when endpoints return errors.

Use a local io_service with .run() (same pattern as rpcClient()) so each
delivery blocks until completion or timeout. Also catch all exceptions
to prevent mSending flag from getting stuck, and log errors at warn level.

Ref: XRPLF/rippled#6341

.github/actions/xahau-ga-dependencies/action.yml

@@ -134,10 +134,17 @@ runs:
     - name: Export custom recipes
       shell: bash
       run: |
-        conan export external/snappy --version 1.1.10 --user xahaud --channel stable
-        conan export external/soci --version 4.0.3 --user xahaud --channel stable
-        conan export external/wasmedge --version 0.11.2 --user xahaud --channel stable
-
+        # Export snappy if not already exported
+        conan list snappy/1.1.10@xahaud/stable 2>/dev/null | (grep -q "not found" && exit 1 || exit 0) || \
+          conan export external/snappy --version 1.1.10 --user xahaud --channel stable
+        
+        # Export soci if not already exported
+        conan list soci/4.0.3@xahaud/stable 2>/dev/null | (grep -q "not found" && exit 1 || exit 0) || \
+          conan export external/soci --version 4.0.3 --user xahaud --channel stable
+        
+        # Export wasmedge if not already exported
+        conan list wasmedge/0.11.2@xahaud/stable 2>/dev/null | (grep -q "not found" && exit 1 || exit 0) || \
+          conan export external/wasmedge --version 0.11.2 --user xahaud --channel stable
     - name: Install dependencies
       shell: bash
       env:

.github/workflows/xahau-ga-macos.yml

@@ -43,14 +43,22 @@ jobs:
       # To isolate environments for each Runner, instead of installing globally with brew, 
       # use mise to isolate environments for each Runner directory.
       - name: Setup toolchain (mise)
-        uses: jdx/mise-action@v2
+        uses: jdx/mise-action@v3.6.1
         with:
+          cache: false
           install: true
+          mise_toml: |
+            [tools]
+            cmake = "3.23.1"
+            python = "3.12"
+            pipx = "latest"
+            conan = "2"
+            ninja = "latest"
+            ccache = "latest"
 
       - name: Install tools via mise
         run: |
           mise install
-          mise use cmake@3.23.1 python@3.12 pipx@latest conan@2 ninja@latest ccache@latest
           mise reshim
           echo "$HOME/.local/share/mise/shims" >> "$GITHUB_PATH"
 

src/ripple/net/impl/RPCCall.cpp

@@ -1805,6 +1805,7 @@ rpcClient(
             }
 
             {
+                //@@start blocking-request
                 boost::asio::io_service isService;
                 RPCCall::fromNetwork(
                     isService,
@@ -1828,6 +1829,7 @@ rpcClient(
                     headers);
                 isService.run();  // This blocks until there are no more
                                   // outstanding async calls.
+                //@@end blocking-request
             }
             if (jvOutput.isMember("result"))
             {
@@ -1946,6 +1948,7 @@ fromNetwork(
     // HTTP call?
     auto constexpr RPC_NOTIFY = 30s;
 
+    //@@start async-request
     HTTPClient::request(
         bSSL,
         io_service,
@@ -1970,6 +1973,7 @@ fromNetwork(
             std::placeholders::_3,
             j),
         j);
+    //@@end async-request
 }
 
 }  // namespace RPCCall

src/ripple/net/impl/RPCSub.cpp

@@ -156,13 +156,19 @@ private:
             // Send outside of the lock.
             if (bSend)
             {
-                // XXX Might not need this in a try.
                 try
                 {
                     JLOG(j_.info()) << "RPCCall::fromNetwork: " << mIp;
 
+                    // Use a local io_service so the HTTP call blocks
+                    // until completion (or timeout). Without this,
+                    // fromNetwork() posts async ops to the app's
+                    // io_service and returns immediately, causing
+                    // unbounded concurrent connections that exhaust
+                    // file descriptors when endpoints are failing.
+                    boost::asio::io_service io_service;
                     RPCCall::fromNetwork(
-                        m_io_service,
+                        io_service,
                         mIp,
                         mPort,
                         mUsername,
@@ -173,12 +179,17 @@ private:
                         mSSL,
                         true,
                         logs_);
+                    io_service.run();
                 }
                 catch (const std::exception& e)
                 {
-                    JLOG(j_.info())
+                    JLOG(j_.warn())
                         << "RPCCall::fromNetwork exception: " << e.what();
                 }
+                catch (...)
+                {
+                    JLOG(j_.warn()) << "RPCCall::fromNetwork unknown exception";
+                }
             }
         } while (bSend);
     }

src/ripple/overlay/impl/OverlayImpl.cpp

@@ -484,44 +484,61 @@ OverlayImpl::start()
     m_peerFinder->setConfig(config);
     m_peerFinder->start();
 
-    auto addIps = [&](std::vector<std::string> bootstrapIps) -> void {
+    auto addIps = [this](std::vector<std::string> ips, bool fixed) {
         beast::Journal const& j = app_.journal("Overlay");
-        for (auto& ip : bootstrapIps)
+        for (auto& ip : ips)
         {
             std::size_t pos = ip.find('#');
             if (pos != std::string::npos)
                 ip.erase(pos);
 
-            JLOG(j.trace()) << "Found boostrap IP: " << ip;
+            JLOG(j.trace())
+                << "Found " << (fixed ? "fixed" : "bootstrap") << " IP: " << ip;
         }
 
         m_resolver.resolve(
-            bootstrapIps,
-            [&](std::string const& name,
+            ips,
+            [this, fixed](
+                std::string const& name,
                 std::vector<beast::IP::Endpoint> const& addresses) {
-                std::vector<std::string> ips;
-                ips.reserve(addresses.size());
                 beast::Journal const& j = app_.journal("Overlay");
+                std::string const base("config: ");
+
+                std::vector<beast::IP::Endpoint> eps;
+                eps.reserve(addresses.size());
                 for (auto const& addr : addresses)
                 {
-                    std::string addrStr = addr.port() == 0
-                        ? to_string(addr.at_port(DEFAULT_PEER_PORT))
-                        : to_string(addr);
-                    JLOG(j.trace()) << "Parsed boostrap IP: " << addrStr;
-                    ips.push_back(addrStr);
+                    auto ep = addr.port() == 0 ? addr.at_port(DEFAULT_PEER_PORT)
+                                               : addr;
+                    JLOG(j.trace())
+                        << "Parsed " << (fixed ? "fixed" : "bootstrap")
+                        << " IP: " << ep;
+                    eps.push_back(ep);
                 }
 
-                std::string const base("config: ");
-                if (!ips.empty())
-                    m_peerFinder->addFallbackStrings(base + name, ips);
+                if (eps.empty())
+                    return;
+
+                if (fixed)
+                {
+                    m_peerFinder->addFixedPeer(base + name, eps);
+                }
+                else
+                {
+                    std::vector<std::string> strs;
+                    strs.reserve(eps.size());
+                    for (auto const& ep : eps)
+                        strs.push_back(to_string(ep));
+                    m_peerFinder->addFallbackStrings(base + name, strs);
+                }
             });
     };
 
     if (!app_.config().IPS.empty())
-        addIps(app_.config().IPS);
+        addIps(app_.config().IPS, false);
 
     if (!app_.config().IPS_FIXED.empty())
-        addIps(app_.config().IPS_FIXED);
+        addIps(app_.config().IPS_FIXED, true);
 
     auto const timer = std::make_shared<Timer>(*this);
     std::lock_guard lock(mutex_);