subsys.hpp

Go to the documentation of this file.

 
#ifndef SUP_SYSSUP_COMMON_SUBSYS_HPP
#define SUP_SYSSUP_COMMON_SUBSYS_HPP
 
#include <boost/signals2.hpp>
#include <boost/bimap.hpp>
#include <boost/assign.hpp>
 
#include <ifw/sup/syssup/common/iSubsys.hpp>
#include <ifw/sup/syssup/common/subsysFactory.hpp>
#include <ifw/sup/syssup/common/states.hpp>
#include <utils/bat/logger.hpp>
 
 
#include <mal/utility/LoadMal.hpp>
#include <mal/rr/qos/ReplyTime.hpp>
 
 
namespace sup::syssup::common {
 
 
   constexpr auto KEY_STATUS_SUBSYS_CONNECTION  = "connection_status";
 
 
 
  struct SubsysData  {
  public:
 
    enum class ConnectionEnum : short { CONNECTED = 10,
                                        NOT_CONNECTED = 11
                                      };
 
    const std::map<ConnectionEnum, std::string> ConnectionMap {
          { ConnectionEnum::CONNECTED, "Connected" },
          { ConnectionEnum::NOT_CONNECTED, "ERROR - Not Connected" }
        };
 
    inline State::StateEnum GetState() const;
 
    inline void SetState(const std::string state);
 
    inline State::SubstateEnum GetSubstate() const;
 
    inline void SetSubstate(const std::string subtate);
 
    inline void SetConnection(const SubsysData::ConnectionEnum connection);
 
    inline ConnectionEnum GetConnection() const;
 
    inline std::string GetConnectionStr() const;
 
 
  private:
    ConnectionEnum m_connection{ConnectionEnum::NOT_CONNECTED};  
    State::StateEnum    m_state;                                 
    State::SubstateEnum    m_substate;                           
 
  };
 
  template <typename INTERFACE>
  class Dispatcher {
     public:
      Dispatcher(const elt::mal::Uri& uri,
                 const int timeout = 5000,
                const std::optional<elt::mal::Mal::Properties> mal_properties = {})
        : m_client(), m_uri(uri), m_timeout(timeout) {
            try {
                  m_client = elt::mal::CiiFactory::getInstance().getClient<INTERFACE>(
                     uri,
                     {std::make_shared<elt::mal::rr::qos::ReplyTime>(std::chrono::milliseconds(m_timeout))},
                      mal_properties ? *mal_properties : elt::mal::Mal::Properties());
              } catch (std::exception& e) {
                LOG4CPLUS_ERROR(utils::bat::GetAppLogger(), "Problems creating MAL client "
                          << " error: " << e.what());
                m_client = nullptr;
              }
 
           }
 
           void Update(const elt::mal::Uri& uri,
                       const int timeout = 5000,
                       const std::optional<elt::mal::Mal::Properties> mal_properties = {}) {
             try {
                   m_timeout = timeout;
                   m_client = elt::mal::CiiFactory::getInstance().getClient<INTERFACE>(
                      uri,
                      {std::make_shared<elt::mal::rr::qos::ReplyTime>(std::chrono::milliseconds(m_timeout))},
                       mal_properties ? *mal_properties : elt::mal::Mal::Properties());
               } catch (std::exception& e) {
                 LOG4CPLUS_ERROR(utils::bat::GetAppLogger(), "Problems creating MAL client "
                           << " error: " << e.what());
                 m_client = nullptr;
               }
 
           }
           std::shared_ptr<INTERFACE>& GetInterface() {
 
               return m_client;
           }
 
           Dispatcher(const Dispatcher&) = delete;
           Dispatcher& operator=(const Dispatcher&) = delete;
 
          private:
           std::shared_ptr<INTERFACE> m_client;  // Share pointer to MAL Client
           elt::mal::Uri m_uri;
       int m_timeout;
       };
 
 
    class Config;
    class DataContext;
    struct Subsys : Factory<Subsys, const std::string, Config&, DataContext&>,
                   public ISubsys {
    public:
 
      using UpdateHandler = boost::signals2::signal<void()>;
 
      Subsys(Key);
 
 
      virtual ~Subsys();
 
      virtual bool IsNotReady() const ;
      virtual bool IsReady() const ;
 
      virtual bool IsOperational() const ;
 
      virtual void CheckSubsysFailure() const ;
 
      virtual bool IsDisabling() const ;
 
 
 
      virtual void Ignore(rad::AnyEvent const& last_event) ;
 
      virtual void StopIgn(rad::AnyEvent const& last_event) ;
 
      virtual void SubsysReset(rad::AnyEvent const& last_event) ;
 
      virtual void SubsysInit(rad::AnyEvent const& last_event) ;
 
      virtual void SubsysEnable(rad::AnyEvent const& last_event) ;
 
      virtual void SubsysDisable(rad::AnyEvent const& last_event) ;
 
      void Subscribe(UpdateHandler::slot_type handler);
 
      void SetDataState(const std::string state);
 
      std::string GetDataStateStr() const;
 
      State::StateEnum GetDataState() const;
 
      void SetDataSubstate(const std::string subtate);
 
      std::string GetDataSubstateStr() const;
 
      State::SubstateEnum GetDataSubstate() const;
 
 
      void SetDataConnection(const SubsysData::ConnectionEnum connection);
 
      std::string GetDataConnectionStr() const;
 
      SubsysData::ConnectionEnum GetDataConnection() const;
 
 
    protected:
 
 
 
      void UpdateDb(std::vector<std::string> attr_vector);
 
      void SetIgnore(bool flag);
 
 
 
      void GetPrefix(const std::vector<std::string> prefix_list, std::string& prefix);
 
 
    protected:
      UpdateHandler      m_signal; 
 
    private:
 
      SubsysData         m_status;  
      log4cplus::Logger  m_logger;
 
    };
 
}
 
#include "subsys.ipp"
 
#endif //SUP_SYSSUP_COMMON_SUBSYS_HPP