Completed Prototyping of Patterns. registry_client_main needs boost_program_options

Author: StevenAWhite

projects/libpfc_net/CMakeLists.txt

@@ -68,7 +68,7 @@ add_library(sustain::pfc_nw ALIAS ${PROJECT_NAME} )
 set_target_properties(${PROJECT_NAME}
   PROPERTIES
   DEFINE_SYMBOL "SUSTAIN_FRAMEWORK_EXPORTS"
-  FOLDER "Binaries"
+  FOLDER "Libraries"
   OUTPUT_NAME "${PROJECT_NAME}"
   COMPILE_PDB_NAME "${PROJECT_NAME}"
   PROJECT_LABEL "${PROJECT_NAME}"

projects/libpfc_net/cpp/net/Pattrn.cpp

@@ -1,4 +1,4 @@
-#include <sustain/framework/Service.h>
+#include <sustain/framework/net/Service.h>
 
 #include <sustain/framework/Protocol.h>
 #include <sustain/framework/net/Multicast_Receiver.h>

projects/libpfc_net/cpp/net/Service.cpp

@@ -0,0 +1,11 @@
+#include <sustain/framework/net/patterns/pub_sub/Publisher.h>
+
+namespace pfc {
+PubSub_Publisher::~PubSub_Publisher() {}
+
+void PubSub_Publisher::broadcast(std::function<void(void)>) {}
+void PubSub_Publisher::async_broadcast(std::function<void(void)>) {}
+
+void PubSub_Publisher::standup() {}
+void PubSub_Publisher::shutdown() {}
+}

projects/libpfc_net/cpp/net/patterns/pub_sub/Publisher.cpp

@@ -1,145 +1,13 @@
-#include <sustain/framework/pub_sub/Subscriber.h>
-
-#include <boost/asio.hpp>
-#include <boost/system/error_code.hpp>
+#include <sustain/framework/net/patterns/pub_sub/Subscriber.h>
 
 #include <sustain/framework/util/Error.h>
 
 namespace pfc {
-struct Subscriber::Implementation {
-  Implementation();
-  Implementation(const std::string& service_name, const std::string& multicast_address);
-  ~Implementation();
-  Implementation(const Implementation&) = delete;
-  Implementation(Implementation&&) = default;
-  Implementation& operator=(const Implementation&) = delete;
-  Implementation& operator=(Implementation&&) = delete;
-
-  pfc::Error multicast_setup(const std::string& multicast_address);
-  void multicast_announce();
-  void multicast_announce_timeout();
-
-  std::thread multicast_announce_thread;
-  std::thread multicast_listen_thread;
-
-  std::atomic<bool> thead_control_shutdown;
-  std::atomic<bool> thead_control_service_registered;
-
-  boost::asio::io_context io_context;
-  boost::asio::ip::udp::endpoint endpoint;
-  boost::asio::ip::udp::socket socket;
-  boost::asio::steady_timer timer;
-
-  static constexpr int max_message_count = 25;
-  int message_count;
-  std::string message;
-
-  //TODO: Determine Optimum Size
-  std::array<char, 4096> data;
-
-  pfc::Error server_status;
-};
-//-----------------------------------------------------------------------------
-Subscriber::Implementation::Implementation()
-  : io_context()
-  , socket(io_context)
-  , timer(io_context)
-{
-}
-//-----------------------------------------------------------------------------
-Subscriber::Implementation::Implementation(const std::string& service_name, const std::string& multicast_address)
-  : io_context()
-  , socket(io_context)
-  , endpoint()
-  , timer(io_context)
-  , thead_control_shutdown(false)
-  , thead_control_service_registered(false)
-  , message_count(0)
-  , message("Tutorial Message")
-  , server_status(Success())
-{
-  server_status |= multicast_setup(multicast_address);
-}
-//-----------------------------------------------------------------------------
-Subscriber::Implementation::~Implementation()
-{
-  thead_control_shutdown = true;
-  if (multicast_announce_thread.joinable()) {
-    multicast_announce_thread = std::thread([]() {});
-  }
-  if (multicast_listen_thread.joinable()) {
-    multicast_announce_thread = std::thread([]() {});
-  }
-}
-//-----------------------------------------------------------------------------
-pfc::Error Subscriber::Implementation::multicast_setup(const std::string& multicast_address)
-{
-  boost::system::error_code err;
-  pfc::Error pfc_error_code = Success();
-  auto broadcast_address = boost::asio::ip::make_address(multicast_address, err);
-  if (!err) {
-    endpoint = boost::asio::ip::udp::endpoint(broadcast_address, g_pfc_registry_announce_port);
-    socket = boost::asio::ip::udp::socket(io_context, endpoint.protocol());
-  } else {
-    pfc_error_code = pfc::Error(Error::Code::PFC_IP_PARSE_ERROR);
-  }
-  return pfc_error_code;
-}
-//-----------------------------------------------------------------------------
-void Subscriber::Implementation::multicast_announce()
-{
-  std::ostringstream os;
-  os << "Message " << message_count++;
-  message = os.str();
+PubSub_Subscriber::~PubSub_Subscriber() {}
 
-  socket.async_send_to(
-    boost::asio::buffer(message), endpoint,
-    [this](boost::system::error_code ec, std::size_t /*length*/) {
-      if (!ec && message_count < max_message_count)
-        multicast_announce_timeout();
-    });
-}
-//-----------------------------------------------------------------------------
-void Subscriber::Implementation::multicast_announce_timeout()
-{
-  timer.expires_after(std::chrono::seconds(1));
-  timer.async_wait(
-    [this](boost::system::error_code ec) {
-      if (!ec)
-        multicast_announce();
-    });
-}
-//-----------------------------------------------------------------------------
-Subscriber::Subscriber(std::string service_name, std::string multicast_address)
-  : _impl(std::make_unique<Implementation>(std::move(service_name), std::move(multicast_address)))
-{
-}
-//-----------------------------------------------------------------------------
-Subscriber::Subscriber(Subscriber&& obj)
-  : _impl(std::move(obj._impl))
-{
-  obj._impl = std::make_unique<Implementation>();
-}
-//-----------------------------------------------------------------------------
-Subscriber::~Subscriber()
-{
+void PubSub_Subscriber::listen(std::function<void(void)>) {}
+void PubSub_Subscriber::async_listen(std::function<void(void)>) {}
 
-}
-//-----------------------------------------------------------------------------
-bool Subscriber::Valid()
-{
-  return _impl->server_status.is_ok();
-}
-//-----------------------------------------------------------------------------
-Error Subscriber::Error()
-{
-  return _impl->server_status;
-}
-//-----------------------------------------------------------------------------
-Subscriber& Subscriber::operator=(Subscriber&& obj)
-{
-  _impl = std::move(obj._impl);
-  obj._impl = std::make_unique<Implementation>();
-  return *this;
-}
+void PubSub_Subscriber::standup() {}
+void PubSub_Subscriber::shutdown() {}
 }

projects/libpfc_net/cpp/net/patterns/pub_sub/Subscriber.cpp

@@ -0,0 +1,11 @@
+#include <sustain/framework/net/patterns/req_rep/Client.h>
+
+namespace pfc {
+ReqRep_Client::~ReqRep_Client() {}
+
+void ReqRep_Client::broadcast(std::function<void(void)>) {}
+void ReqRep_Client::async_broadcast(std::function<void(void)>) {}
+
+void ReqRep_Client::standup() {}
+void ReqRep_Client::shutdown() {}
+}

projects/libpfc_net/cpp/net/patterns/req_rep/Client.cpp

@@ -0,0 +1,11 @@
+#include <sustain/framework/net/patterns/req_rep/Server.h>
+
+namespace pfc {
+ReqRep_Server::~ReqRep_Server() {}
+
+void ReqRep_Server::listen(std::function<void(void)>) {}
+void ReqRep_Server::async_listen(std::function<void(void)>) {}
+
+void ReqRep_Server::standup() {}
+void ReqRep_Server::shutdown() {}
+}

projects/libpfc_net/cpp/net/patterns/req_rep/Server.cpp

@@ -0,0 +1,11 @@
+#include <sustain/framework/net/patterns/survey/Participant.h>
+
+namespace pfc {
+Survey_Participant::~Survey_Participant() {}
+
+void Survey_Participant::listen(std::function<void(void)>) {}
+void Survey_Participant::async_listen(std::function<void(void)>) {}
+
+void Survey_Participant::standup() {}
+void Survey_Participant::shutdown() {}
+}

projects/libpfc_net/cpp/net/patterns/survey/Participant.cpp

@@ -0,0 +1,11 @@
+#include <sustain/framework/net/patterns/survey/Surveyor.h>
+
+namespace pfc {
+Survey_Surveyor::~Survey_Surveyor() {}
+
+void Survey_Surveyor::broadcast(std::function<void(void)>) {}
+void Survey_Surveyor::async_broadcast(std::function<void(void)>) {}
+
+void Survey_Surveyor::standup() {}
+void Survey_Surveyor::shutdown() {}
+}