recordingUnit.hpp

Go to the documentation of this file.

 
#ifndef RTCTK_COMPONENTFRAMEWORK_RECORDINGUNIT_HPP
#define RTCTK_COMPONENTFRAMEWORK_RECORDINGUNIT_HPP
 
#include <rtctk/componentFramework/componentMetricsIf.hpp>
#include <rtctk/componentFramework/exceptions.hpp>
#include <rtctk/componentFramework/oldbIf.hpp>
#include <rtctk/componentFramework/runtimeRepoIf.hpp>
#include <rtctk/componentFramework/serviceContainer.hpp>
 
#include <atomic>
#include <boost/signals2.hpp>
#include <boost/signals2/connection.hpp>
#include <filesystem>
#include <optional>
#include <shared_mutex>
#include <vector>
 
namespace rtctk::componentFramework {
 
class RecordingUnit;
class ServiceContainer;
 
using RecUnitListType = std::list<std::unique_ptr<RecordingUnit>>;
using RecUnitFactoryType = std::function<RecUnitListType(const std::string&, ServiceContainer&)>;
 
template <class T, class... Args>
void AddRecUnit(RecUnitListType& units, Args&&... args) {
    units.emplace_back(std::make_unique<T>(std::forward<Args>(args)...));
}
 
class RecordingUnit {
public:
    enum class State : uint8_t { STOPPED, PREPARING, IDLE, WAITING, RUNNING, FINISHED, FAILED };
 
    const std::map<State, std::string> m_state_text = {
        {State::STOPPED, "Stopped"},
        {State::PREPARING, "Preparing"},
        {State::IDLE, "Idle"},
        {State::WAITING, "Waiting"},
        {State::RUNNING, "Running"},
        {State::FINISHED, "Finished"},
        {State::FAILED, "Failed"},
    };  //< States names
 
    RecordingUnit(const std::string& comp_id,
                  const std::string& unit_id,
                  const std::string& unit_type,
                  ServiceContainer& services);
 
    RecordingUnit() = delete;
 
    virtual ~RecordingUnit() = default;
 
    void ConnectWithLeaders(RecUnitListType& units);
 
    std::string GetId();
 
    State GetState();
 
    virtual void CheckErrors();
    virtual void Prepare(const std::filesystem::path& file_path) = 0;
    virtual void Start() = 0;
    virtual std::vector<std::filesystem::path> Stop() = 0;
    virtual void Update();
 
    boost::signals2::connection
    Connect(const std::function<void(const std::string&, const State&)>& function);
 
protected:
    bool SetState(State state, State precondition);
 
    void SetState(State state, State precondition, const std::string& error_message);
 
    void SetFailed(const std::exception_ptr& exception);
    void SetStopped();
    bool HasLeaders();
    bool HasFirstLeaderStarted();
    bool HasLastLeaderFinished();
    void ResetLeaderStates();
 
    std::string m_comp_id;
    std::string m_unit_id;
    RuntimeRepoIf& m_rtr;
    OldbIf& m_oldb;
    ComponentMetricsIf& m_metrics;
    std::optional<std::filesystem::path> m_file_path;
    boost::signals2::signal<void(const std::string&, const State&)> m_signal;
 
private:
    std::mutex m_leader_mutex;
    std::atomic<State> m_state;
    std::exception_ptr m_exception = nullptr;
    std::shared_mutex m_exception_mutex;
    std::vector<std::string> m_leaders;
    std::map<std::string, State> m_leader_states;
    std::vector<boost::signals2::scoped_connection> m_leader_connections;
    bool m_first_leader_started = false;
    bool m_last_leader_finished = false;
    inline static constexpr std::string_view RTR_PATH_LEADER_LIST =
        "/{}/static/rec_units/{}/leader_list";
    inline static constexpr std::string_view OLDB_PATH_UNIT_STATE = "/{}/rec_units/{}/state";
    inline static constexpr std::string_view OLDB_PATH_UNIT_TYPE = "/{}/rec_units/{}/type";
};
 
}  // namespace rtctk::componentFramework
 
#endif  // RTCTK_COMPONENTFRAMEWORK_RECORDINGUNIT_HPP