Application.hpp

Go to the documentation of this file.

#pragma once
 
#include "srs/devices/Configuration.hpp"
#include "srs/utils/CommonAlias.hpp"
#include "srs/utils/CommonDefinitions.hpp"
#include <boost/asio/executor_work_guard.hpp>
#include <boost/asio/ip/udp.hpp>
#include <boost/asio/signal_set.hpp>
#include <boost/asio/strand.hpp>
#include <boost/asio/thread_pool.hpp>
#include <boost/system/detail/error_code.hpp>
#include <csignal>
#include <cstddef>
#include <cstdint>
#include <expected>
#include <future>
#include <memory>
#include <string>
#include <string_view>
#include <thread>
#include <utility>
#include <vector>
 
// #include <srs/devices/Fec.hpp>
namespace srs
{
    namespace workflow
    {
        class Handler;
    } // namespace workflow
 
    namespace connection
    {
        class DataReader;
        class DataSocket;
    } // namespace connection
 
    class App;
 
    namespace internal
    {
        class AppExitHelper
        {
          public:
            explicit AppExitHelper(App* app)
                : app_{ app }
            {
            }
 
            AppExitHelper(const AppExitHelper&) = default;
            AppExitHelper(AppExitHelper&&) = delete;
            AppExitHelper& operator=(const AppExitHelper&) = default;
            AppExitHelper& operator=(AppExitHelper&&) = delete;
            ~AppExitHelper() noexcept;
 
          private:
            App* app_;
        };
 
    } // namespace internal

 
    class App
    {
      public:
        App();
 
        App(const App&) = delete;
        App(App&&) = delete;
        App& operator=(const App&) = delete;
        App& operator=(App&&) = delete;

        ~App() noexcept;

        void init();
 
        void configure_fec() {}

        void switch_on();

        void switch_off();

        void read_data(bool is_non_stop = true);

        void start_workflow();

        void wait_for_finish();
 
        void wait_for_workflow() { workflow_thread_.join(); }
 
        // setters:
        void set_fec_data_receiv_port(int port_num) { config_.fec_data_receive_port = port_num; }

        void set_print_mode(common::DataPrintMode mode);

        void set_output_filenames(const std::vector<std::string>& filenames, std::size_t n_lines = 1);

        void set_options(Config options) { config_ = std::move(options); }
 
        void exit_and_switch_off();
 
        // internal usage
        // TODO: Refactor the code to not expose those methods for the internal usage
 
        // getters:
        [[nodiscard]] auto get_channel_address() const -> uint16_t { return channel_address_; }
        [[nodiscard]] auto get_io_context() -> auto& { return io_context_; }
        [[nodiscard]] auto get_fec_strand() -> auto& { return fec_strand_; }
        [[nodiscard]] auto get_workflow_handler() const -> const auto& { return *workflow_handler_; };
        [[nodiscard]] auto get_config() const -> const auto& { return config_; }
        [[nodiscard]] auto get_config_ref() -> auto& { return config_; }
 
        // called by ExitHelper
        void action_after_destructor();
 
      private:
        using udp = asio::ip::udp;
        using SwitchFutureType = std::expected<std::future<void>, boost::system::error_code>;
        using SwitchFutureStatusType = std::expected<std::future_status, boost::system::error_code>;
 
        uint16_t channel_address_ = common::DEFAULT_CHANNEL_ADDRE;
        Config config_;
 
        // Destructors are called in the inverse order

        io_context_type io_context_{ 4 };

        asio::executor_work_guard<io_context_type::executor_type> io_work_guard_;

        std::vector<udp::endpoint> remote_fec_endpoints_;

        asio::signal_set signal_set_{ io_context_, SIGINT, SIGTERM };

        asio::strand<io_context_type::executor_type> fec_strand_;

        std::jthread working_thread_;

        std::jthread workflow_thread_;
 
        SwitchFutureType switch_on_future_;
 
        SwitchFutureType switch_off_future_;

        internal::AppExitHelper exit_helper_{ this };

        std::unique_ptr<workflow::Handler> workflow_handler_;

        // std::shared_ptr<connection::DataReader> data_reader_;
 
        std::shared_ptr<connection::DataSocket> data_socket_;
 
        void wait_for_reading_finish();
        void set_remote_fec_endpoints();
        void add_remote_fec_endpoint(std::string_view remote_ip, int port_number);
        static auto wait_for_switch_action(const SwitchFutureType& switch_future) -> SwitchFutureStatusType;
 
        template <typename T>
        auto switch_FECs(std::string_view connection_name) -> SwitchFutureType;
    };
 
} // namespace srs