Add shell: bash to each composite action step

.github/actions/extract-version/action.yml

@@ -0,0 +1,21 @@
+name: Extract version
+description: "Extract version from BuildInfo.cpp"
+
+outputs:
+  version:
+    description: "The version extracted from BuildInfo.cpp."
+    value: ${{ steps.version.outputs.version }}
+
+runs:
+  using: composite
+  steps:
+    - name: Extract version
+      id: version
+      shell: bash
+      run: |
+        VERSION="$(cat src/libxrpl/protocol/BuildInfo.cpp | grep "versionString =" | awk -F '"' '{print $2}')"
+        if [[ -z "${VERSION}" ]]; then
+          echo 'Unable to extract version from BuildInfo.cpp.'
+          exit 1
+        fi
+        echo "version=${VERSION}" >> "${GITHUB_OUTPUT}"

.github/actions/upload-recipe/action.yml

@@ -0,0 +1,72 @@
+name: Upload Conan recipe
+description: "Upload recipe to a Conan remote."
+
+inputs:
+  conan_recipe_name:
+    description: "The name of the recipe to use."
+    required: false
+    default: xrpl
+  conan_recipe_version:
+    description: "The version of the recipe to use."
+    required: true
+  conan_recipe_channel:
+    description: "The optional Conan channel to use."
+    required: false
+  conan_recipe_user:
+    description: "The optional Conan user to use."
+    required: false
+  conan_remote_name:
+    description: "The name of the Conan remote to use."
+    required: true
+  conan_remote_url:
+    description: "The URL of the Conan endpoint to use."
+    required: true
+  conan_remote_username:
+    description: "The username for logging into the Conan remote."
+    required: true
+  conan_remote_password:
+    description: "The password for logging into the Conan remote."
+    required: true
+
+outputs:
+  conan_ref: ${{ steps.ref.outputs.ref }}
+
+runs:
+  using: composite
+
+  steps:
+    - name: Calculate Conan reference
+      id: ref
+      shell: bash
+      env:
+        CONAN_RECIPE_NAME: ${{ inputs.conan_recipe_name }}
+        CONAN_RECIPE_VERSION: ${{ inputs.conan_recipe_version }}
+        CONAN_RECIPE_CHANNEL: ${{ inputs.conan_recipe_channel }}
+        CONAN_RECIPE_USER: ${{ inputs.conan_recipe_user }}
+      run: |
+        if [[ -n "${CONAN_RECIPE_USER}" && -n "${CONAN_RECIPE_CHANNEL}" ]]; then
+          echo "ref=${CONAN_RECIPE_NAME}/${CONAN_RECIPE_VERSION}@${CONAN_RECIPE_USER}/${CONAN_RECIPE_CHANNEL}" >> "${GITHUB_OUTPUT}"
+        else
+          echo "ref=${CONAN_RECIPE_NAME}/${CONAN_RECIPE_VERSION}" >> "${GITHUB_OUTPUT}"
+        fi
+    - name: Set up Conan
+      uses: ./.github/actions/setup-conan
+      with:
+        conan_remote_name: ${{ inputs.conan_remote_name }}
+        conan_remote_url: ${{ inputs.conan_remote_url }}
+    - name: Log into Conan remote
+      shell: bash
+      env:
+        CONAN_REMOTE_NAME: ${{ inputs.conan_remote_name }}
+        CONAN_REMOTE_USERNAME: ${{ inputs.conan_remote_username }}
+        CONAN_REMOTE_PASSWORD: ${{ inputs.conan_remote_password }}
+      run: conan remote login "${CONAN_REMOTE_NAME}" "${CONAN_REMOTE_USERNAME}" --password "${CONAN_REMOTE_PASSWORD}"
+    - name: Upload package
+      shell: bash
+      env:
+        CONAN_RECIPE_CHANNEL: ${{ inputs.conan_recipe_channel }}
+        CONAN_RECIPE_USER: ${{ inputs.conan_recipe_user }}
+        CONAN_REMOTE_NAME: ${{ inputs.conan_remote_name }}
+      run: |
+        conan export --channel="${CONAN_RECIPE_CHANNEL}" --user="${CONAN_RECIPE_USER}" .
+        conan upload --confirm --check --remote="${CONAN_REMOTE_NAME}" ${{ steps.ref.outputs.ref }}

.github/workflows/reusable-notify-clio.yml

@@ -44,37 +44,29 @@ jobs:
     steps:
       - name: Checkout repository
         uses: actions/checkout@08eba0b27e820071cde6df949e0beb9ba4906955 # v4.3.0
+      - name: Extract version
+        id: version
+        uses: ./.github/actions/extract-version
       - name: Generate outputs
         id: generate
         env:
           PR_NUMBER: ${{ github.event.pull_request.number }}
         run: |
-          echo 'Generating user and channel.'
           echo "user=clio" >> "${GITHUB_OUTPUT}"
           echo "channel=pr_${PR_NUMBER}" >> "${GITHUB_OUTPUT}"
-          echo 'Extracting version.'
-          echo "version=$(cat src/libxrpl/protocol/BuildInfo.cpp | grep "versionString =" | awk -F '"' '{print $2}')" >> "${GITHUB_OUTPUT}"
-      - name: Calculate conan reference
-        id: conan_ref
-        run: |
-          echo "conan_ref=${{ steps.generate.outputs.version }}@${{ steps.generate.outputs.user }}/${{ steps.generate.outputs.channel }}" >> "${GITHUB_OUTPUT}"
-      - name: Set up Conan
-        uses: ./.github/actions/setup-conan
+      - name: Upload recipe
+        uses: ./.github/actions/upload-recipe
+        id: upload
         with:
+          conan_recipe_version: ${{ steps.version.outputs.version }}
+          conan_recipe_channel: ${{ steps.generate.outputs.channel }}
+          conan_recipe_user: ${{ steps.generate.outputs.user }}
           conan_remote_name: ${{ inputs.conan_remote_name }}
           conan_remote_url: ${{ inputs.conan_remote_url }}
-      - name: Log into Conan remote
-        env:
-          CONAN_REMOTE_NAME: ${{ inputs.conan_remote_name }}
-        run: conan remote login "${CONAN_REMOTE_NAME}" "${{ secrets.conan_remote_username }}" --password "${{ secrets.conan_remote_password }}"
-      - name: Upload package
-        env:
-          CONAN_REMOTE_NAME: ${{ inputs.conan_remote_name }}
-        run: |
-          conan export --user=${{ steps.generate.outputs.user }} --channel=${{ steps.generate.outputs.channel }} .
-          conan upload --confirm --check --remote="${CONAN_REMOTE_NAME}" xrpl/${{ steps.conan_ref.outputs.conan_ref }}
+          conan_remote_username: ${{ secrets.conan_remote_username }}
+          conan_remote_password: ${{ secrets.conan_remote_password }}
     outputs:
-      conan_ref: ${{ steps.conan_ref.outputs.conan_ref }}
+      conan_ref: ${{ steps.upload.outputs.conan_ref }}
 
   notify:
     needs: upload

src/tests/libxrpl/net/HTTPClient.cpp

@@ -10,7 +10,6 @@
 #include <gtest/gtest.h>
 
 #include <atomic>
-#include <iostream>
 #include <map>
 #include <thread>
 
@@ -18,40 +17,6 @@ using namespace xrpl;
 
 namespace {
 
-struct logger
-{
-    std::string name;
-    logger const* const parent = nullptr;
-    static std::size_t depth;
-    logger(std::string n) : name(n)
-    {
-        std::clog << indent() << name << " begin\n";
-        ++depth;
-    }
-
-    logger(logger const& p, std::string n) : parent(&p), name(n)
-    {
-        std::clog << indent() << parent->name << " : " << name << " begin\n";
-        ++depth;
-    }
-
-    ~logger()
-    {
-        --depth;
-        if (parent)
-            std::clog << indent() << parent->name << " : " << name << " end\n";
-        else
-            std::clog << indent() << name << " end\n";
-    }
-
-    std::string
-    indent()
-    {
-        return std::string(depth, ' ');
-    }
-};
-std::size_t logger::depth = 0;
-
 // Simple HTTP server using Beast for testing
 class TestHTTPServer
 {
@@ -70,7 +35,6 @@ private:
 public:
     TestHTTPServer() : acceptor_(ioc_), port_(0)
     {
-        logger l("TestHTTPServer()");
         // Bind to any available port
         endpoint_ = {boost::asio::ip::tcp::v4(), 0};
         acceptor_.open(endpoint_.protocol());
@@ -86,7 +50,6 @@ public:
 
     ~TestHTTPServer()
     {
-        logger l("~TestHTTPServer()");
         stop();
     }
 
@@ -124,7 +87,6 @@ private:
     void
     stop()
     {
-        logger l("TestHTTPServer::stop");
         running_ = false;
         acceptor_.close();
     }
@@ -132,7 +94,6 @@ private:
     void
     accept()
     {
-        logger l("TestHTTPServer::accept");
         if (!running_)
             return;
 
@@ -154,37 +115,31 @@ private:
     void
     handleConnection(boost::asio::ip::tcp::socket socket)
     {
-        logger l("TestHTTPServer::handleConnection");
         try
         {
-            std::optional<logger> r(std::in_place, l, "read the http request");
             // Read the HTTP request
             boost::beast::flat_buffer buffer;
             boost::beast::http::request<boost::beast::http::string_body> req;
             boost::beast::http::read(socket, buffer, req);
 
             // Create response
-            r.emplace(l, "create response");
             boost::beast::http::response<boost::beast::http::string_body> res;
             res.version(req.version());
             res.result(status_code_);
             res.set(boost::beast::http::field::server, "TestServer");
 
             // Add custom headers
-            r.emplace(l, "add custom headers");
             for (auto const& [name, value] : custom_headers_)
             {
                 res.set(name, value);
             }
 
             // Set body and prepare payload first
-            r.emplace(l, "set body and prepare payload");
             res.body() = response_body_;
             res.prepare_payload();
 
             // Override Content-Length with custom headers after prepare_payload
             // This allows us to test case-insensitive header parsing
-            r.emplace(l, "override content-length");
             for (auto const& [name, value] : custom_headers_)
             {
                 if (boost::iequals(name, "Content-Length"))
@@ -195,25 +150,19 @@ private:
             }
 
             // Send response
-            r.emplace(l, "send response");
             boost::beast::http::write(socket, res);
 
             // Shutdown socket gracefully
-            r.emplace(l, "shutdown socket");
             boost::system::error_code ec;
             socket.shutdown(boost::asio::ip::tcp::socket::shutdown_send, ec);
         }
         catch (std::exception const&)
         {
             // Connection handling errors are expected
-            logger c(l, "catch");
         }
 
         if (running_)
-        {
-            logger r(l, "accept");
             accept();
-        }
     }
 };
 
@@ -227,16 +176,12 @@ runHTTPTest(
     std::string& result_data,
     boost::system::error_code& result_error)
 {
-    logger l("runHTTPTest");
     // Create a null journal for testing
     beast::Journal j{beast::Journal::getNullSink()};
 
-    std::optional<logger> r(std::in_place, l, "initializeSSLContext");
-
     // Initialize HTTPClient SSL context
     HTTPClient::initializeSSLContext("", "", false, j);
 
-    r.emplace(l, "HTTPClient::get");
     HTTPClient::get(
         false,  // no SSL
         server.ioc(),
@@ -261,7 +206,6 @@ runHTTPTest(
     while (!completed &&
            std::chrono::steady_clock::now() - start < std::chrono::seconds(10))
     {
-        r.emplace(l, "ioc.run_one");
         if (server.ioc().run_one() == 0)
         {
             break;
@@ -275,8 +219,6 @@ runHTTPTest(
 
 TEST(HTTPClient, case_insensitive_content_length)
 {
-    logger l("HTTPClient case insensitive Content-Length");
-
     // Test different cases of Content-Length header
     std::vector<std::string> header_cases = {
         "Content-Length",  // Standard case
@@ -288,7 +230,6 @@ TEST(HTTPClient, case_insensitive_content_length)
 
     for (auto const& header_name : header_cases)
     {
-        logger h(l, header_name);
         TestHTTPServer server;
         std::string test_body = "Hello World!";
         server.setResponseBody(test_body);
@@ -317,7 +258,6 @@ TEST(HTTPClient, case_insensitive_content_length)
 
 TEST(HTTPClient, basic_http_request)
 {
-    logger l("HTTPClient basic HTTP request");
     TestHTTPServer server;
     std::string test_body = "Test response body";
     server.setResponseBody(test_body);
@@ -339,7 +279,6 @@ TEST(HTTPClient, basic_http_request)
 
 TEST(HTTPClient, empty_response)
 {
-    logger l("HTTPClient empty response");
     TestHTTPServer server;
     server.setResponseBody("");  // Empty body
     server.setHeader("Content-Length", "0");
@@ -360,7 +299,6 @@ TEST(HTTPClient, empty_response)
 
 TEST(HTTPClient, different_status_codes)
 {
-    logger l("HTTPClient different status codes");
     std::vector<unsigned int> status_codes = {200, 404, 500};
 
     for (auto status : status_codes)