ToolsProtocol.h

Go to the documentation of this file.

// Copyright 2019 GSI, Inc. All rights reserved.
//
//
//

#ifndef DDS_TOOLSPROTOCOL_H
#define DDS_TOOLSPROTOCOL_H

// STD
#include <chrono>
#include <ostream>
#include <string>
#include <boost/property_tree/ptree.hpp>
// DDS
#include "Intercom.h"
#include "ToolsProtocolCore.h"

namespace dds
{
    namespace tools_api
    {
        DDS_TOOLS_DECLARE_DATA_CLASS(SBaseResponseData, SDoneResponseData, "done")

        
        struct SMessageResponseData : SBaseResponseData<SMessageResponseData>
        {
            std::string m_msg;                                                                  
            dds::intercom_api::EMsgSeverity m_severity = dds::intercom_api::EMsgSeverity::info; 

          private:
            friend SBaseData<SMessageResponseData>;
            friend SBaseResponseData<SMessageResponseData>;
            void _fromPT(const boost::property_tree::ptree& _pt);
            void _toPT(boost::property_tree::ptree& _pt) const;
            static constexpr const char* _protocolTag = "message";

          public:
            bool operator==(const SMessageResponseData& _val) const;
            friend std::ostream& operator<<(std::ostream& _os, const SMessageResponseData& _data);
        };

        struct SProgressResponseData : SBaseResponseData<SProgressResponseData>
        {
            uint32_t m_completed = 0;
            uint32_t m_total = 0;
            uint32_t m_errors = 0;
            uint32_t m_time = 0;
            uint16_t m_srcCommand = 0; 

            SProgressResponseData();
            SProgressResponseData(
                uint16_t _srcCmd, uint32_t _completed, uint32_t _total, uint32_t _errors, uint32_t _time = 0);

          private:
            friend SBaseData<SProgressResponseData>;
            friend SBaseResponseData<SProgressResponseData>;
            void _fromPT(const boost::property_tree::ptree& _pt);
            void _toPT(boost::property_tree::ptree& _pt) const;
            static constexpr const char* _protocolTag = "progress";

          public:
            bool operator==(const SProgressResponseData& _val) const;
            friend std::ostream& operator<<(std::ostream& _os, const SProgressResponseData& _data);
        };

        struct SSubmitRequestData : SBaseRequestData<SSubmitRequestData>
        {
            std::string m_rms;        
            uint32_t m_instances = 0; 
            uint32_t m_slots = 0;     
            std::string m_config;     
            std::string m_pluginPath; 

          private:
            friend SBaseData<SSubmitRequestData>;
            void _fromPT(const boost::property_tree::ptree& _pt);
            void _toPT(boost::property_tree::ptree& _pt) const;
            static constexpr const char* _protocolTag = "submit";

          public:
            bool operator==(const SSubmitRequestData& _val) const;
            friend std::ostream& operator<<(std::ostream& _os, const SSubmitRequestData& _data);
        };

        using SSubmitRequest = SBaseRequestImpl<SSubmitRequestData, SEmptyResponseData>;

        struct STopologyRequestData : SBaseResponseData<STopologyRequestData>
        {
            enum class EUpdateType : uint8_t
            {
                UPDATE = 0,
                ACTIVATE,
                STOP
            };
            EUpdateType m_updateType = EUpdateType::UPDATE; 
            std::string m_topologyFile;                     
            bool m_disableValidation = false; 

          private:
            friend SBaseData<STopologyRequestData>;
            void _fromPT(const boost::property_tree::ptree& _pt);
            void _toPT(boost::property_tree::ptree& _pt) const;
            static constexpr const char* _protocolTag = "topology";

          public:
            bool operator==(const STopologyRequestData& _val) const;
            friend std::ostream& operator<<(std::ostream& _os, const STopologyRequestData& _data);
        };

        using STopologyRequest = SBaseRequestImpl<STopologyRequestData, SEmptyResponseData>;

        DDS_TOOLS_DECLARE_DATA_CLASS(SBaseRequestData, SGetLogRequestData, "getlog")

        
        using SGetLogRequest = SBaseRequestImpl<SGetLogRequestData, SEmptyResponseData>;

        struct SCommanderInfoResponseData : SBaseResponseData<SCommanderInfoResponseData>
        {
            pid_t m_pid = 0;                  
            std::string m_activeTopologyName; 
            std::string m_activeTopologyPath; 

          private:
            friend SBaseData<SCommanderInfoResponseData>;
            friend SBaseResponseData<SCommanderInfoResponseData>;
            void _fromPT(const boost::property_tree::ptree& _pt);
            void _toPT(boost::property_tree::ptree& _pt) const;
            static constexpr const char* _protocolTag = "commanderInfo";

          public:
            bool operator==(const SCommanderInfoResponseData& _val) const;
            friend std::ostream& operator<<(std::ostream& _os, const SCommanderInfoResponseData& _data);
        };

        DDS_TOOLS_DECLARE_DATA_CLASS(SBaseRequestData, SCommanderInfoRequestData, "commanderInfo")

        
        using SCommanderInfoRequest = SBaseRequestImpl<SCommanderInfoRequestData, SCommanderInfoResponseData>;

        struct SAgentInfoResponseData : SBaseResponseData<SAgentInfoResponseData>
        {
            uint32_t m_index{ 0 };                                                   
            uint64_t m_agentID{ 0 };                                                 
            std::chrono::milliseconds m_startUpTime{ std::chrono::milliseconds(0) }; 
            std::string m_username;                                                  
            std::string m_host;                                                      
            std::string m_DDSPath;                                                   
            uint32_t m_agentPid{ 0 };                                                
            uint32_t m_nSlots{ 0 };                                                  

          private:
            friend SBaseData<SAgentInfoResponseData>;
            friend SBaseResponseData<SAgentInfoResponseData>;
            void _fromPT(const boost::property_tree::ptree& _pt);
            void _toPT(boost::property_tree::ptree& _pt) const;
            static constexpr const char* _protocolTag = "agentInfo";

          public:
            bool operator==(const SAgentInfoResponseData& _val) const;
            friend std::ostream& operator<<(std::ostream& _os, const SAgentInfoResponseData& _data);
        };

        DDS_TOOLS_DECLARE_DATA_CLASS(SBaseRequestData, SAgentInfoRequestData, "agentInfo")

        
        using SAgentInfoRequest = SBaseRequestImpl<SAgentInfoRequestData, SAgentInfoResponseData>;

        struct SAgentCountResponseData : SBaseResponseData<SAgentCountResponseData>
        {
            uint32_t m_activeSlotsCount = 0;    
            uint32_t m_idleSlotsCount = 0;      
            uint32_t m_executingSlotsCount = 0; 

          private:
            friend SBaseData<SAgentCountResponseData>;
            friend SBaseResponseData<SAgentCountResponseData>;
            void _fromPT(const boost::property_tree::ptree& _pt);
            void _toPT(boost::property_tree::ptree& _pt) const;
            static constexpr const char* _protocolTag = "agentCount";

          public:
            bool operator==(const SAgentCountResponseData& _val) const;
            friend std::ostream& operator<<(std::ostream& _os, const SAgentCountResponseData& _data);
        };

        DDS_TOOLS_DECLARE_DATA_CLASS(SBaseRequestData, SAgentCountRequestData, "agentCount")

        
        using SAgentCountRequest = SBaseRequestImpl<SAgentCountRequestData, SAgentCountResponseData>;

    } // namespace tools_api
} // namespace dds

#endif /* DDS_TOOLSPROTOCOL_H */