ComputeServiceMessage.h

 
#ifndef WRENCH_COMPUTESERVICEMESSAGE_H
#define WRENCH_COMPUTESERVICEMESSAGE_H
 
#include <memory>
#include <vector>
#include "wrench/workflow/failure_causes/FailureCause.h"
#include "wrench/services/ServiceMessage.h"
 
namespace wrench {
 
    class StandardJob;
 
    class PilotJob;
 
    /***********************/
    /***********************/
 
    class ComputeServiceMessage : public ServiceMessage {
    protected:
        ComputeServiceMessage(std::string name, double payload);
    };
 
    class ComputeServiceSubmitStandardJobRequestMessage : public ComputeServiceMessage {
    public:
        ComputeServiceSubmitStandardJobRequestMessage(const std::string answer_mailbox, std::shared_ptr<StandardJob> ,
                                                      const std::map<std::string, std::string> service_specific_args,
                                                      double payload);
 
        std::string answer_mailbox;
        std::shared_ptr<StandardJob> job;
        std::map<std::string, std::string> service_specific_args;
    };
 
    class ComputeServiceSubmitStandardJobAnswerMessage : public ComputeServiceMessage {
    public:
        ComputeServiceSubmitStandardJobAnswerMessage(std::shared_ptr<StandardJob> , std::shared_ptr<ComputeService>, bool success,
                                                     std::shared_ptr<FailureCause> failure_cause, double payload);
 
        std::shared_ptr<StandardJob> job;
        std::shared_ptr<ComputeService> compute_service;
        bool success;
        std::shared_ptr<FailureCause> failure_cause;
    };
 
    class ComputeServiceStandardJobDoneMessage : public ComputeServiceMessage {
    public:
        ComputeServiceStandardJobDoneMessage(std::shared_ptr<StandardJob> , std::shared_ptr<ComputeService>, double payload);
 
        std::shared_ptr<StandardJob> job;
        std::shared_ptr<ComputeService> compute_service;
    };
 
    class ComputeServiceStandardJobFailedMessage : public ComputeServiceMessage {
    public:
        ComputeServiceStandardJobFailedMessage(std::shared_ptr<StandardJob> , std::shared_ptr<ComputeService>,
                                               std::shared_ptr<FailureCause> cause,
                                               double payload);
 
        std::shared_ptr<StandardJob> job;
        std::shared_ptr<ComputeService> compute_service;
        std::shared_ptr<FailureCause> cause;
    };
 
    class ComputeServiceTerminateStandardJobRequestMessage : public ComputeServiceMessage {
    public:
        ComputeServiceTerminateStandardJobRequestMessage(std::string answer_mailbox, std::shared_ptr<StandardJob> , double payload);
 
        std::string answer_mailbox;
        std::shared_ptr<StandardJob> job;
    };
 
    class ComputeServiceTerminateStandardJobAnswerMessage : public ComputeServiceMessage {
    public:
        ComputeServiceTerminateStandardJobAnswerMessage(std::shared_ptr<StandardJob> , std::shared_ptr<ComputeService>, bool success,
                                                        std::shared_ptr<FailureCause> failure_cause, double payload);
 
        std::shared_ptr<StandardJob> job;
        std::shared_ptr<ComputeService> compute_service;
        bool success;
        std::shared_ptr<FailureCause> failure_cause;
    };
 
    class ComputeServiceSubmitPilotJobRequestMessage : public ComputeServiceMessage {
    public:
        ComputeServiceSubmitPilotJobRequestMessage(std::string answer_mailbox, std::shared_ptr<PilotJob> ,
                                                   const std::map<std::string, std::string> service_specific_args,
                                                   double payload);
 
        std::string answer_mailbox;
        std::shared_ptr<PilotJob> job;
        std::map<std::string, std::string> service_specific_args;
    };
 
    class ComputeServiceSubmitPilotJobAnswerMessage : public ComputeServiceMessage {
    public:
        ComputeServiceSubmitPilotJobAnswerMessage(std::shared_ptr<PilotJob> , std::shared_ptr<ComputeService>, bool success,
                                                  std::shared_ptr<FailureCause> cause,
                                                  double payload);
 
        std::shared_ptr<PilotJob> job;
        std::shared_ptr<ComputeService> compute_service;
        bool success;
        std::shared_ptr<FailureCause> failure_cause;
    };
 
 
    class ComputeServicePilotJobStartedMessage : public ComputeServiceMessage {
    public:
        ComputeServicePilotJobStartedMessage(std::shared_ptr<PilotJob> , std::shared_ptr<ComputeService>, double payload);
 
        std::shared_ptr<PilotJob> job;
        std::shared_ptr<ComputeService> compute_service;
    };
 
    class ComputeServicePilotJobExpiredMessage : public ComputeServiceMessage {
    public:
        ComputeServicePilotJobExpiredMessage(std::shared_ptr<PilotJob> , std::shared_ptr<ComputeService>, double payload);
 
        std::shared_ptr<PilotJob> job;
        std::shared_ptr<ComputeService> compute_service;
    };
 
    class ComputeServicePilotJobFailedMessage : public ComputeServiceMessage {
    public:
        ComputeServicePilotJobFailedMessage(std::shared_ptr<PilotJob> , std::shared_ptr<ComputeService>, double payload);
 
        std::shared_ptr<PilotJob> job;
        std::shared_ptr<ComputeService> compute_service;
    };
 
    class ComputeServiceTerminatePilotJobRequestMessage : public ComputeServiceMessage {
    public:
        ComputeServiceTerminatePilotJobRequestMessage(std::string answer_mailbox, std::shared_ptr<PilotJob> , double payload);
 
        std::string answer_mailbox;
        std::shared_ptr<PilotJob> job;
    };
 
    class ComputeServiceTerminatePilotJobAnswerMessage : public ComputeServiceMessage {
    public:
        ComputeServiceTerminatePilotJobAnswerMessage(std::shared_ptr<PilotJob> , std::shared_ptr<ComputeService> compute_service,
                                                     bool success,
                                                     std::shared_ptr<FailureCause> failure_cause, double payload);
 
        std::shared_ptr<PilotJob> job;
        std::shared_ptr<ComputeService> compute_service;
        bool success;
        std::shared_ptr<FailureCause> failure_cause;
    };
 
 
    class ComputeServiceResourceInformationRequestMessage : public ComputeServiceMessage {
    public:
        ComputeServiceResourceInformationRequestMessage(std::string answer_mailbox, double payload);
 
        std::string answer_mailbox;
    };
 
    class ComputeServiceResourceInformationAnswerMessage : public ComputeServiceMessage {
    public:
        ComputeServiceResourceInformationAnswerMessage(std::map<std::string, std::map<std::string, double>> info,
                                                       double payload);
 
        std::map<std::string, std::map<std::string, double>> info;
    };
 
    class ComputeServiceIsThereAtLeastOneHostWithAvailableResourcesRequestMessage : public ComputeServiceMessage {
    public:
        ComputeServiceIsThereAtLeastOneHostWithAvailableResourcesRequestMessage(const std::string &answer_mailbox,
                                                                                         unsigned long num_cores,
                                                                                         double ram, double payload);
 
        std::string answer_mailbox;
        unsigned long num_cores;
        double ram;
    };
 
    class ComputeServiceIsThereAtLeastOneHostWithAvailableResourcesAnswerMessage : public ComputeServiceMessage {
    public:
        ComputeServiceIsThereAtLeastOneHostWithAvailableResourcesAnswerMessage(bool answer, double payload);
 
        bool answer;
    };
 
    /***********************/
    /***********************/
 
};
 
#endif //WRENCH_COMPUTESERVICEMESSAGE_H