Networking primatives (Twon#187)

* Asio IP address program options test

* Ip6 test cases

* Pre-commit formatting

* Formatting

* Todo extend namedendpoint to convert to address

* Work in progress URL support

* Clean up

* Remove header

libraries/application/src/morpheus/application/po/adapters/boost/asio.hpp

@@ -0,0 +1,34 @@
+#pragma once
+
+#include <morpheus/core/base/prerequisites.hpp>
+
+#include <boost/algorithm/string.hpp>
+#include <boost/any.hpp>
+#include <boost/asio/ip/tcp.hpp>
+#include <boost/system/error_code.hpp>
+#include <boost/program_options.hpp>
+
+#include <string>
+#include <vector>
+
+namespace boost::asio::ip
+{
+
+template <class CharType>
+void validate(boost::any& v, std::vector<std::basic_string<CharType>> const& values, address* p, int)
+{
+    namespace po = boost::program_options;
+    po::validators::check_first_occurrence(v);
+    auto const& s = po::validators::get_single_string(values);
+
+    boost::system::error_code ec = make_error_code(boost::system::errc::success);
+    auto const address = boost::asio::ip::make_address(s, ec);
+    if (ec == boost::asio::error::invalid_argument)
+    {
+        throw po::validation_error(po::validation_error::invalid_option_value);
+    }
+
+    v = address;
+}
+
+} // namespace boost::asio::ip

libraries/application/tests/po/adapters/boost/CMakeLists.txt

@@ -1,4 +1,5 @@
 target_sources(MorpheusApplicationTests
     PRIVATE
+        asio.tests.cpp
         log.tests.cpp
 )

libraries/application/tests/po/adapters/boost/asio.tests.cpp

@@ -0,0 +1,63 @@
+#include "morpheus/application/po/adapters/boost/asio.hpp"
+#include "morpheus/application/po/options.hpp"
+#include "morpheus/core/conformance/ranges.hpp"
+#include "morpheus/logging.hpp"
+#include "morpheus/redirect_stream.hpp"
+
+#include <catch2/catch_test_macros.hpp>
+#include <iostream>
+
+namespace morpheus::application::po
+{
+
+struct BoostLogFixture
+{
+    LoggingFixture disableLogging;
+    RedirectStream captureCout = RedirectStream(std::cout);
+    RedirectStream captureCerr = RedirectStream(std::cerr);
+};
+
+struct Address
+{
+    boost::asio::ip::address ipAddress;
+
+    void addOptions(boost::program_options::options_description& options)
+    {
+        namespace po = boost::program_options;
+        // clang-format off
+        options.add_options()
+            ("address", po::value(&ipAddress)->required(), "The ip address.");
+        // clang-format on
+    }
+};
+
+TEST_CASE_METHOD(BoostLogFixture, "Test parsing of boost asio address as program options", "[morpheus.application.po.adapters.boost.asio.address]")
+{
+
+    SECTION("Ensure valid value parse correctly")
+    {
+        auto getAddress = [](std::string_view param)
+        {
+            Address address{};
+            std::array cliOptions = {"dummyProgram.exe", "--address", param.data()};
+            auto const result = parseProgramOptions(cliOptions.size(), cliOptions.data(), HelpDocumentation{}, address);
+            REQUIRE(!result);
+            return address.ipAddress;
+        };
+
+        REQUIRE(getAddress("127.0.0.1") == boost::asio::ip::address_v4::loopback());
+        REQUIRE(getAddress("192.168.1.218") == boost::asio::ip::address_v4({192, 168, 1, 218}));
+        REQUIRE(getAddress("0:0:0:0:0:0:0:1") == boost::asio::ip::address_v6::loopback());
+        REQUIRE(getAddress("fd00::f06b:9ee5:8bfa:666c") ==
+                boost::asio::ip::address_v6({0xfd, 0, 0, 0, 0, 0, 0, 0, 0xf0, 0x6b, 0x9e, 0xe5, 0x8b, 0xfa, 0x66, 0x6c}));
+    }
+    SECTION("Ensure invalid value parse correctly")
+    {
+        std::array cliOptions = {"dummyProgram.exe", "--address", "invalid"};
+        Address address;
+        auto const result = parseProgramOptions(cliOptions.size(), cliOptions.data(), HelpDocumentation{}, address);
+        REQUIRE(result);
+    }
+}
+
+} // namespace morpheus::application::po

libraries/application/tests/po/config.tests.cpp

@@ -1,6 +1,8 @@
 #include "morpheus/application/po/config.hpp"
 #include "morpheus/application/po/options.hpp"
 
+#include <boost/log/trivial.hpp>
+
 #include <catch2/catch_test_macros.hpp>
 
 #include <array>
@@ -12,20 +14,20 @@ TEST_CASE("Ensure options parsing of standard application config", "[morpheus.ap
 {
     GIVEN("A type supporting addOptions")
     {
-        Config confg;
+        Config config;
 
         WHEN("Parsing valid parameters")
         {
             std::array const cliOptions = { "dummyProgram.exe", "--logging-enabled", "true", "--log-append", "false", "--log-level", "debug", "--logfile-path", "." };
-            auto const result = parseProgramOptions(static_cast<int>(cliOptions.size()), cliOptions.data(), HelpDocumentation{}, confg);
+            auto const result = parseProgramOptions(static_cast<int>(cliOptions.size()), cliOptions.data(), HelpDocumentation{}, config);
 
             THEN("Expect no error results and valid values extracted")
             {
                 REQUIRE(!result);
-                REQUIRE(confg.loggingEnabled == true);
-                REQUIRE(confg.logAppend == false);
-                REQUIRE(confg.logLevel == boost::log::trivial::debug);
-                REQUIRE(confg.logFilePath == ".");
+                REQUIRE(config.loggingEnabled == true);
+                REQUIRE(config.logAppend == false);
+                REQUIRE(config.logLevel == boost::log::trivial::debug);
+                REQUIRE(config.logFilePath == ".");
             }
         }
     }

libraries/core/src/CMakeLists.txt

@@ -22,11 +22,12 @@ target_link_libraries(MorpheusCore
 
 add_subdirectory(morpheus/core)
 
-#target_compile_definitions(MorpheusCore
-#    PUBLIC
+target_compile_definitions(MorpheusCore
+    PUBLIC
 #         MORPHEUS_SHARED_BUILD=1
 #         MORPHEUS_DLL_EXPORTS=1
-#)
+        BOOST_USE_WINAPI_VERSION=0x600
+)
 
 target_compile_options(MorpheusCore
     PRIVATE

libraries/core/src/morpheus/core/CMakeLists.txt

@@ -17,4 +17,5 @@ add_subdirectory(concurrency)
 add_subdirectory(functional)
 add_subdirectory(memory)
 add_subdirectory(meta)
+add_subdirectory(network)
 add_subdirectory(serialisation)

libraries/core/src/morpheus/core/network/CMakeLists.txt

@@ -0,0 +1,4 @@
+target_sources(MorpheusCore
+    PUBLIC
+        named_endpoint.hpp
+)

libraries/core/src/morpheus/core/network/named_endpoint.hpp

@@ -0,0 +1,48 @@
+#pragma once
+
+#include <boost/container_hash/hash.hpp>
+
+#include <compare>
+#include <cstdint>
+#include <string_view>
+
+namespace morpheus::network
+{
+
+/// \class NamedEndpoint
+///     Allows for hostname to endpont resolution via DNS lookup.a
+/// \todo
+///     https://stackoverflow.com/questions/31314433/how-do-i-convert-a-host-name-in-to-a-boost-address-or-endpoint
+class NamedEndpoint
+{
+public:
+    NamedEndpoint(std::string_view const name, std::uint16_t const port)
+    : mName(name)
+    , mPort(port)
+    {}
+
+    [[nodisard]] auto name() const noexcept { return mName; }
+
+    [[nodisard]] auto port() const noexcept { return mPort; }
+
+    [[nodisard]] auto operator<=>(NamedEndpoint const& rhs) const noexcept = default;
+
+private:
+    std::string mName;
+    std::uint16_t mPort;
+};
+
+} // namespace morpheus::network
+
+/// std::hash specialisation for named enpoint
+template <>
+struct std::hash<morpheus::network::NamedEndpoint>
+{
+    std::size_t operator()(morpheus::network::NamedEndpoint const& n) const
+    {
+        std::size_t seed = 0;
+        boost::hash_combine(seed, n.name());
+        boost::hash_combine(seed, n.port());
+        return seed;
+    }
+};

libraries/core/tests/CMakeLists.txt

@@ -27,4 +27,5 @@ add_subdirectory(conversion)
 add_subdirectory(functional)
 add_subdirectory(memory)
 add_subdirectory(meta)
+add_subdirectory(network)
 add_subdirectory(serialisation)

libraries/core/tests/network/CMakeLists.txt

@@ -0,0 +1,4 @@
+target_sources(MorpheusCoreTests
+    PRIVATE
+        named_endpoint.tests.cpp
+)

libraries/core/tests/network/named_endpoint.tests.cpp

@@ -0,0 +1,13 @@
+#include "morpheus/core/network/named_endpoint.hpp"
+
+#include <catch2/catch_all.hpp>
+#include <gmock/gmock.h>
+
+namespace morpheus::network
+{
+
+using namespace ::testing;
+
+TEST_CASE("Verify construction of named endpoints", "[morpheus.network.named_endpoint.construction]") {}
+
+} // namespace morpheus::network