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>
        {
            SMessageResponseData();
            SMessageResponseData(const boost::property_tree::ptree& _pt);

            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>
        {
            SProgressResponseData();
            SProgressResponseData(const boost::property_tree::ptree& _pt);
            SProgressResponseData(
                uint16_t _srcCmd, uint32_t _completed, uint32_t _total, uint32_t _errors, uint32_t _time = 0);

            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; 

          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>
        {
            SSubmitRequestData();
            SSubmitRequestData(const boost::property_tree::ptree& _pt);

            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 : SBaseRequestData<STopologyRequestData>
        {
            STopologyRequestData();
            STopologyRequestData(const boost::property_tree::ptree& _pt);

            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);
        };

        struct STopologyResponseData : SBaseResponseData<STopologyResponseData>
        {
            STopologyResponseData();
            STopologyResponseData(const boost::property_tree::ptree& _pt);

            bool m_activated{ true };     
            uint64_t m_agentID{ 0 };      
            uint64_t m_slotID{ 0 };       
            uint64_t m_taskID{ 0 };       
            uint64_t m_collectionID{ 0 }; 
            std::string m_path;           
            std::string m_host;           
            std::string m_wrkDir;         

          private:
            friend SBaseData<STopologyResponseData>;
            friend SBaseResponseData<STopologyResponseData>;
            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 STopologyResponseData& _val) const;
            friend std::ostream& operator<<(std::ostream& _os, const STopologyResponseData& _data);
        };

        using STopologyRequest = SBaseRequestImpl<STopologyRequestData, STopologyResponseData>;

        DDS_TOOLS_DECLARE_DATA_CLASS(SBaseRequestData, SGetLogRequestData, "getlog")

        
        using SGetLogRequest = SBaseRequestImpl<SGetLogRequestData, SEmptyResponseData>;

        struct SCommanderInfoResponseData : SBaseResponseData<SCommanderInfoResponseData>
        {
            SCommanderInfoResponseData();
            SCommanderInfoResponseData(const boost::property_tree::ptree& _pt);

            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>
        {
            SAgentInfoResponseData();
            SAgentInfoResponseData(const boost::property_tree::ptree& _pt);

            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 };                                                  
            uint32_t m_nIdleSlots{ 0 };                                              
            uint32_t m_nExecutingSlots{ 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 SSlotInfoResponseData : SBaseResponseData<SSlotInfoResponseData>
        {
            SSlotInfoResponseData();
            SSlotInfoResponseData(const boost::property_tree::ptree& _pt);

            uint32_t m_index{ 0 };   
            uint64_t m_agentID{ 0 }; 
            uint64_t m_slotID{ 0 };  
            uint64_t m_taskID{ 0 };  
            uint32_t m_state{ 0 };   
            std::string m_host;      
            std::string m_wrkDir;    

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

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

        DDS_TOOLS_DECLARE_DATA_CLASS(SBaseRequestData, SSlotInfoRequestData, "slotInfo")

        
        using SSlotInfoRequest = SBaseRequestImpl<SSlotInfoRequestData, SSlotInfoResponseData>;

        struct SAgentCountResponseData : SBaseResponseData<SAgentCountResponseData>
        {
            SAgentCountResponseData();
            SAgentCountResponseData(const boost::property_tree::ptree& _pt);

            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>;

        struct SOnTaskDoneResponseData : SBaseResponseData<SOnTaskDoneResponseData>
        {
            SOnTaskDoneResponseData();
            SOnTaskDoneResponseData(const boost::property_tree::ptree& _pt);

            uint64_t m_taskID{ 0 };   
            uint32_t m_exitCode{ 0 }; 
            uint32_t m_signal{ 0 };   
            std::string m_host;       
            std::string m_wrkDir;     
            std::string m_taskPath;   

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

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

        DDS_TOOLS_DECLARE_DATA_CLASS(SBaseRequestData, SOnTaskDoneRequestData, "onTaskDone")

        
        using SOnTaskDoneRequest = SBaseRequestImpl<SOnTaskDoneRequestData, SOnTaskDoneResponseData>;

        struct SAgentCommandRequestData : SBaseRequestData<SAgentCommandRequestData>
        {

            SAgentCommandRequestData();
            SAgentCommandRequestData(const boost::property_tree::ptree& _pt);

            enum class EAgentCommandType : uint8_t
            {
                shutDownByID = 0, 
                shutDownBySlotID, 
                // stopTaskByTaskID,
                // stopTaskByAgentID,
                // restartTaskByTaskID,
                // restartTaskByAgentID
            };

            EAgentCommandType m_commandType = EAgentCommandType::shutDownByID;
            uint64_t m_arg1{ 0 }; 
            std::string m_arg2;   

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

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

        using SAgentCommandRequest = SBaseRequestImpl<SAgentCommandRequestData, SEmptyResponseData>;
    } // namespace tools_api
} // namespace dds

#endif /* DDS_TOOLSPROTOCOL_H */