ComputeServiceMessage.h

#ifndef WRENCH_COMPUTESERVICEMESSAGE_H
#define WRENCH_COMPUTESERVICEMESSAGE_H

#include <memory>
#include <vector>
#include "wrench/workflow/execution_events/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, StandardJob *,
                                                      std::map<std::string, std::string> &service_specific_args,
                                                      double payload);

        std::string answer_mailbox;
        StandardJob *job;
        std::map<std::string, std::string> service_specific_args;
    };

    class ComputeServiceSubmitStandardJobAnswerMessage : public ComputeServiceMessage {
    public:
        ComputeServiceSubmitStandardJobAnswerMessage(StandardJob *, std::shared_ptr<ComputeService>, bool success,
                                                     std::shared_ptr<FailureCause> failure_cause, double payload);

        StandardJob *job;
        std::shared_ptr<ComputeService> compute_service;
        bool success;
        std::shared_ptr<FailureCause> failure_cause;
    };

    class ComputeServiceStandardJobDoneMessage : public ComputeServiceMessage {
    public:
        ComputeServiceStandardJobDoneMessage(StandardJob *, std::shared_ptr<ComputeService>, double payload);

        StandardJob *job;
        std::shared_ptr<ComputeService> compute_service;
    };

    class ComputeServiceStandardJobFailedMessage : public ComputeServiceMessage {
    public:
        ComputeServiceStandardJobFailedMessage(StandardJob *, std::shared_ptr<ComputeService>,
                                               std::shared_ptr<FailureCause> cause,
                                               double payload);

        StandardJob *job;
        std::shared_ptr<ComputeService> compute_service;
        std::shared_ptr<FailureCause> cause;
    };

    class ComputeServiceTerminateStandardJobRequestMessage : public ComputeServiceMessage {
    public:
        ComputeServiceTerminateStandardJobRequestMessage(std::string answer_mailbox, StandardJob *, double payload);

        std::string answer_mailbox;
        StandardJob *job;
    };

    class ComputeServiceTerminateStandardJobAnswerMessage : public ComputeServiceMessage {
    public:
        ComputeServiceTerminateStandardJobAnswerMessage(StandardJob *, std::shared_ptr<ComputeService>, bool success,
                                                        std::shared_ptr<FailureCause> failure_cause, double payload);

        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, PilotJob *,
                                                   std::map<std::string, std::string> &service_specific_args,
                                                   double payload);

        std::string answer_mailbox;
        PilotJob *job;
        std::map<std::string, std::string> service_specific_args;
    };

    class ComputeServiceSubmitPilotJobAnswerMessage : public ComputeServiceMessage {
    public:
        ComputeServiceSubmitPilotJobAnswerMessage(PilotJob *, std::shared_ptr<ComputeService>, bool success,
                                                  std::shared_ptr<FailureCause> cause,
                                                  double payload);

        PilotJob *job;
        std::shared_ptr<ComputeService> compute_service;
        bool success;
        std::shared_ptr<FailureCause> failure_cause;
    };


    class ComputeServicePilotJobStartedMessage : public ComputeServiceMessage {
    public:
        ComputeServicePilotJobStartedMessage(PilotJob *, std::shared_ptr<ComputeService>, double payload);

        PilotJob *job;
        std::shared_ptr<ComputeService> compute_service;
    };

    class ComputeServicePilotJobExpiredMessage : public ComputeServiceMessage {
    public:
        ComputeServicePilotJobExpiredMessage(PilotJob *, std::shared_ptr<ComputeService>, double payload);

        PilotJob *job;
        std::shared_ptr<ComputeService> compute_service;
    };

    class ComputeServicePilotJobFailedMessage : public ComputeServiceMessage {
    public:
        ComputeServicePilotJobFailedMessage(PilotJob *, std::shared_ptr<ComputeService>, double payload);

        PilotJob *job;
        std::shared_ptr<ComputeService> compute_service;
    };

    class ComputeServiceTerminatePilotJobRequestMessage : public ComputeServiceMessage {
    public:
        ComputeServiceTerminatePilotJobRequestMessage(std::string answer_mailbox, PilotJob *, double payload);

        std::string answer_mailbox;
        PilotJob *job;
    };

    class ComputeServiceTerminatePilotJobAnswerMessage : public ComputeServiceMessage {
    public:
        ComputeServiceTerminatePilotJobAnswerMessage(PilotJob *, std::shared_ptr<ComputeService> compute_service,
                                                     bool success,
                                                     std::shared_ptr<FailureCause> failure_cause, double payload);

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

    /***********************/
    /***********************/

};

#endif //WRENCH_COMPUTESERVICEMESSAGE_H