Upgrade use of Boost.Process

Boost 1.88 has effectively deprecated Boost.Process.v1, which was
replaced by Boost.Process.v2. This breaking change was repaired by
creating a `Process` class that hides the intricacies of using either
Boost.Process.v1/.v2 depending on the Boost version used to configure
ecFlow build:
 - version < 1.66, not supported
 - 1.66 <= version < 1.86, Process.v1 is used
 - 1.86 <= version, Process.v2 is used

The CMake build was also repaired, since Process.v2 is no longer a
header only library and required linking with Boost::process.

Author: marcosbento

CMakeLists.txt

@@ -37,7 +37,7 @@ project( ecflow LANGUAGES CXX VERSION 5.13.8 )
 #   The CMake project version is used, as generated CMake variables, to filter .../ecflow/core/ecflow_version.h.in
 #
 
-set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${CMAKE_SOURCE_DIR}/cmake)
+list(APPEND CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${CMAKE_SOURCE_DIR}/cmake)
 
 include( ecbuild_system NO_POLICY_SCOPE )
 ecbuild_requires_macro_version( 1.6 )

cmake/Dependencies.cmake

@@ -166,6 +166,10 @@ if (ENABLE_PYTHON)
   endif()
   set(ECFLOW_BOOST_PYTHON_COMPONENT "python${_python_base_version}")
 
+  if ( Boost_MINOR_VERSION GREATER_EQUAL 86 )
+    list(APPEND _boost_needed_libs process)
+  endif()
+
   list(APPEND _boost_needed_libs ${ECFLOW_BOOST_PYTHON_COMPONENT})
 endif()
 
@@ -175,11 +179,14 @@ endif()
 
 find_package( Boost ${ECFLOW_BOOST_VERSION} QUIET REQUIRED COMPONENTS ${_boost_needed_libs})
 
+set(SELECTED_BOOST_VERSION "${Boost_MAJOR_VERSION}.${Boost_MINOR_VERSION}.${Boost_SUBMINOR_VERSION}")
+
 ecbuild_info( " * Boost_FOUND                : ${Boost_FOUND}" )
 ecbuild_info( " * Boost_NO_BOOST_CMAKE       : ${Boost_NO_BOOST_CMAKE}" )
 ecbuild_info( " * Boost_USE_MULTITHREADED    : ${Boost_USE_MULTITHREADED}" )
 ecbuild_info( " * Boost_NO_SYSTEM_PATHS      : ${Boost_NO_SYSTEM_PATHS}" )
 ecbuild_info( " * Boost_DETAILED_FAILURE_MSG : ${Boost_DETAILED_FAILURE_MSG}" )
+ecbuild_info( " * Boost_VERSION              : ${Boost_VERSION}" )
 ecbuild_info( " * Boost_MAJOR_VERSION        : ${Boost_MAJOR_VERSION}" )
 ecbuild_info( " * Boost_MINOR_VERSION        : ${Boost_MINOR_VERSION}" )
 ecbuild_info( " * Boost_SUBMINOR_VERSION     : ${Boost_SUBMINOR_VERSION}" )

libs/udp/CMakeLists.txt

@@ -67,12 +67,18 @@ set(TEST_TARGET s_udp)
 
 list(APPEND ${TEST_TARGET}_srcs
   # HEADERS
+  test/Process.hpp
   test/TestSupport.hpp
   # SOURCES
+  test/Process.cpp
   test/TestUDP_main.cpp
   test/TestUDPServer.cpp
 )
 
+if(${SELECTED_BOOST_VERSION} VERSION_GREATER_EQUAL 1.86.0)
+  set(ADDITIONAL_BOOST_COMPONENTS Boost::process)
+endif()
+
 ecbuild_add_test(
   TARGET
     ${TEST_TARGET}
@@ -86,6 +92,7 @@ ecbuild_add_test(
     test_scaffold
     Boost::boost
     Boost::unit_test_framework
+    ${ADDITIONAL_BOOST_COMPONENTS}
     $<$<BOOL:${OPENSSL_FOUND}>:OpenSSL::SSL>
   DEPENDS
     ecflow_server # the server is launched to support tests

libs/udp/test/Process.cpp

@@ -0,0 +1,111 @@
+/*
+ * Copyright 2009- ECMWF.
+ *
+ * This software is licensed under the terms of the Apache Licence version 2.0
+ * which can be obtained at http://www.apache.org/licenses/LICENSE-2.0.
+ * In applying this licence, ECMWF does not waive the privileges and immunities
+ * granted to it by virtue of its status as an intergovernmental organisation
+ * nor does it submit to any jurisdiction.
+ */
+
+#include "Process.hpp"
+
+#include <boost/version.hpp>
+#if BOOST_VERSION < 106600
+
+    #error "Boost version >= 1.66.0 is required"
+
+#elif BOOST_VERSION >= 106600 && BOOST_VERSION < 108600
+
+    #define BOOST_PROCESS_VERSION 1
+    #include <boost/process.hpp>
+
+namespace bp = boost::process;
+
+#else // BOOST_VERSION >= 108600
+
+    #define BOOST_PROCESS_VERSION 2
+    #include <boost/asio.hpp>
+    #include <boost/process.hpp>
+
+namespace ba = boost::asio;
+    #if BOOST_VERSION < 108800
+namespace bp = boost::process::v2;
+    #else
+namespace bp = boost::process;
+    #endif
+
+#endif
+
+namespace ecf::test {
+
+#if BOOST_PROCESS_VERSION == 1
+struct Process::Impl
+{
+    Impl(std::string_view executable, std::vector<std::string_view> args) : handle_{} {
+        // Determine the invocation command
+        auto invoke_command = std::string(executable);
+        for (const auto& arg : args) {
+            invoke_command += " " + std::string(arg);
+        }
+
+        // Start the process
+        handle_ = bp::child{invoke_command};
+    }
+    ~Impl() = default;
+
+    bp::child handle_;
+};
+#elif BOOST_PROCESS_VERSION == 2
+struct Process::Impl
+{
+    static std::vector<boost::string_view> to_boost_string_view(std::vector<std::string_view> args) {
+        std::vector<boost::string_view> result;
+        result.reserve(args.size());
+        for (const auto& arg : args) {
+            result.emplace_back(arg.data(), arg.size());
+        }
+        return result;
+    }
+
+    Impl(std::string_view executable, std::vector<std::string_view> args)
+        : ctx_{},
+          handle_{ctx_, executable, to_boost_string_view(args)} {
+        // The process is started in the constructor
+    }
+    ~Impl() = default;
+
+    ba::io_context ctx_;
+    bp::process handle_;
+};
+
+#else
+    #error "Unsupported boost::process version"
+#endif
+
+Process::Process() : impl_{nullptr} {
+}
+
+Process::Process(Process&& rhs) : impl_{std::move(rhs.impl_)} {
+    rhs.impl_ = nullptr;
+}
+
+Process::Process(std::string_view executable, std::vector<std::string_view> args)
+    : impl_{std::make_unique<Impl>(executable, args)} {
+}
+
+Process& Process::operator=(Process&& rhs) {
+    if (this != &rhs) {
+        impl_     = std::move(rhs.impl_);
+        rhs.impl_ = nullptr;
+    }
+    return *this;
+}
+
+Process::~Process() = default;
+
+void Process::terminate() {
+    impl_ = nullptr;
+}
+
+} // namespace ecf::test

libs/udp/test/Process.hpp

@@ -0,0 +1,42 @@
+/*
+ * Copyright 2009- ECMWF.
+ *
+ * This software is licensed under the terms of the Apache Licence version 2.0
+ * which can be obtained at http://www.apache.org/licenses/LICENSE-2.0.
+ * In applying this licence, ECMWF does not waive the privileges and immunities
+ * granted to it by virtue of its status as an intergovernmental organisation
+ * nor does it submit to any jurisdiction.
+ */
+
+#ifndef ecflow_udp_test_Process_HPP
+#define ecflow_udp_test_Process_HPP
+
+#include <memory>
+#include <string_view>
+#include <vector>
+
+namespace ecf::test {
+
+class Process {
+public:
+    Process();
+    Process(const Process& rhs) = delete;
+    Process(Process&& rhs);
+
+    Process(std::string_view executable, std::vector<std::string_view> args);
+
+    Process& operator=(const Process& rhs) = delete;
+    Process& operator=(Process&& rhs);
+
+    void terminate();
+
+    ~Process();
+
+private:
+    struct Impl;
+    std::unique_ptr<Impl> impl_;
+};
+
+} // namespace ecf::test
+
+#endif /* ecflow_udp_test_Process_HPP */

libs/udp/test/TestSupport.hpp

@@ -14,23 +14,21 @@
 #include <memory>
 #include <thread>
 
-#include <boost/asio.hpp>
-#include <boost/process.hpp>
 #include <boost/test/unit_test.hpp>
 
+#include "Process.hpp"
 #include "ecflow/attribute/NodeAttr.hpp"
 #include "ecflow/client/ClientInvoker.hpp"
 #include "ecflow/core/EcfPortLock.hpp"
 #include "ecflow/core/File.hpp"
+#include "ecflow/core/Filesystem.hpp"
 #include "ecflow/core/Host.hpp"
 #include "ecflow/core/Str.hpp"
 #include "ecflow/node/Defs.hpp"
 #include "ecflow/node/Node.hpp"
 #include "ecflow/test/scaffold/Naming.hpp"
 #include "ecflow/udp/UDPClient.hpp"
 
-namespace bp = boost::process;
-
 namespace ecf::test {
 
 template <typename SERVER>
@@ -46,7 +44,7 @@ class BaseMockServer {
         BOOST_REQUIRE_MESSAGE(!host_.empty(), "determiner host name");
         BOOST_REQUIRE_MESSAGE(port_ > 0, "port is be larger than 0");
 
-        server_ = SERVER::launch(host_, port_, std::forward<Args>(args)...);
+        server_ = std::move(SERVER::launch(host_, port_, std::forward<Args>(args)...));
         ECF_TEST_DBG(<< "   MOCK: " << SERVER::designation << " has been started!");
     }
     BaseMockServer(const BaseMockServer&) = delete;
@@ -65,7 +63,7 @@ class BaseMockServer {
     hostname_t host_;
     uint16_t port_;
 
-    bp::child server_;
+    Process server_;
 };
 
 /**
@@ -78,7 +76,7 @@ class MockServer : public BaseMockServer<MockServer> {
     void load_definition(const std::string& defs) const {
         ClientInvoker client(ecf::Str::LOCALHOST(), port());
         try {
-            BOOST_REQUIRE_MESSAGE(fs::exists(defs), "definitions file exists at: " + defs);
+            BOOST_REQUIRE_MESSAGE(fs::exists(defs), "definitions file doesn't exist at: " + defs);
             auto error = client.loadDefs(defs);
             BOOST_REQUIRE_MESSAGE(!error, "load definitions, without error ");
         }
@@ -132,7 +130,7 @@ class MockServer : public BaseMockServer<MockServer> {
 public:
     static constexpr const char* designation = "ecFlow server";
 
-    static bp::child launch(const hostname_t& host, port_t port) {
+    static Process launch(const hostname_t& host, port_t port) {
         // Just for precaution, in case a previous run didn't clean up...
         cleanup(host, port);
 
@@ -141,20 +139,16 @@ class MockServer : public BaseMockServer<MockServer> {
         BOOST_REQUIRE_MESSAGE(!invoke_command.empty(), "The server program could not be found");
         BOOST_REQUIRE_MESSAGE(fs::exists(invoke_command), "Server exe does not exist at:" << invoke_command);
 
-        invoke_command += " --port ";
-        invoke_command += std::to_string(port);
-        invoke_command += " -d &";
-
         ECF_TEST_DBG(<< "Launching ecflow_server @" << host << ":" << port << ", with: " << invoke_command);
 
-        bp::child child(invoke_command);
+        auto server = Process(invoke_command, {"--port", std::to_string(port), "-d"});
 
         ClientInvoker client(ecf::Str::LOCALHOST(), port);
         if (!client.wait_for_server_reply(5)) {
             BOOST_REQUIRE_MESSAGE(false, "could not launch ecflow server");
         }
 
-        return child;
+        return server;
     }
 
     static void cleanup(const hostname_t& host, port_t port) {
@@ -233,21 +227,18 @@ class MockUDPServer : public BaseMockServer<MockUDPServer> {
 public:
     static constexpr const char* designation = "ecFlow UDP";
 
-    static bp::child launch(const hostname_t& host, port_t port, port_t ecflow_port) {
+    static Process launch(const hostname_t& host, port_t port, port_t ecflow_port) {
 
         std::string invoke_command = ecf::File::root_build_dir() + "/bin/ecflow_udp";
-        invoke_command += " --port ";
-        invoke_command += std::to_string(port);
-        invoke_command += " --ecflow_port ";
-        invoke_command += std::to_string(ecflow_port);
-        invoke_command += " --verbose";
 
         ECF_TEST_DBG(<< "   Launching ecflow_udp @" << host << ":" << port << ", with: " << invoke_command);
 
-        bp::child server(invoke_command);
+        auto server =
+            Process(invoke_command,
+                    {"--port", std::to_string(port), "--ecflow_port", std::to_string(ecflow_port), "--verbose"});
 
         // Wait for server to start...
-        std::this_thread::sleep_for(std::chrono::milliseconds(2000));
+        std::this_thread::sleep_for(std::chrono::milliseconds(2500));
 
         return server;
     }
@@ -286,7 +277,7 @@ struct EnableServersFixture
         : ecflow_server(ecflow_server_port),
           ecflow_udp(ecflow_udp_port, ecflow_server_port) {
         // Load 'reference' suite for tests...
-        ecflow_server.load_definition("data/reference.def");
+        ecflow_server.load_definition(fs::absolute("data/reference.def").string());
     }
 };