CloudComputeService.h

 
#ifndef WRENCH_CLOUDSERVICE_H
#define WRENCH_CLOUDSERVICE_H
 
#include <map>
#include <simgrid/s4u/VirtualMachine.hpp>
 
#include "wrench/simulation/Simulation.h"
#include "wrench/services/compute/ComputeServiceMessage.h"
#include "wrench/services/compute/cloud/CloudComputeServiceProperty.h"
#include "wrench/services/compute/cloud/CloudComputeServiceMessagePayload.h"
#include "wrench/simgrid_S4U_util/S4U_VirtualMachine.h"
#include "wrench/job/PilotJob.h"
 
 
namespace wrench {
 
    class Simulation;
 
    class BareMetalComputeService;
 
    class CloudComputeService : public ComputeService {
    private:
        WRENCH_PROPERTY_COLLECTION_TYPE default_property_values = {
                {CloudComputeServiceProperty::VM_BOOT_OVERHEAD_IN_SECONDS,      "0.0"},
                {CloudComputeServiceProperty::VM_RESOURCE_ALLOCATION_ALGORITHM, "best-fit-ram-first"}
        };
 
WRENCH_MESSAGE_PAYLOADCOLLECTION_TYPE  default_messagepayload_values = {
                {CloudComputeServiceMessagePayload::STOP_DAEMON_MESSAGE_PAYLOAD,                  1024},
                {CloudComputeServiceMessagePayload::DAEMON_STOPPED_MESSAGE_PAYLOAD,               1024},
                {CloudComputeServiceMessagePayload::RESOURCE_DESCRIPTION_REQUEST_MESSAGE_PAYLOAD, 1024},
                {CloudComputeServiceMessagePayload::RESOURCE_DESCRIPTION_ANSWER_MESSAGE_PAYLOAD,  1024},
                {CloudComputeServiceMessagePayload::GET_EXECUTION_HOSTS_REQUEST_MESSAGE_PAYLOAD,  1024},
                {CloudComputeServiceMessagePayload::GET_EXECUTION_HOSTS_ANSWER_MESSAGE_PAYLOAD,   1024},
                {CloudComputeServiceMessagePayload::CREATE_VM_REQUEST_MESSAGE_PAYLOAD,            1024},
                {CloudComputeServiceMessagePayload::CREATE_VM_ANSWER_MESSAGE_PAYLOAD,             1024},
                {CloudComputeServiceMessagePayload::SHUTDOWN_VM_REQUEST_MESSAGE_PAYLOAD,          1024},
                {CloudComputeServiceMessagePayload::SHUTDOWN_VM_ANSWER_MESSAGE_PAYLOAD,           1024},
                {CloudComputeServiceMessagePayload::START_VM_REQUEST_MESSAGE_PAYLOAD,             1024},
                {CloudComputeServiceMessagePayload::START_VM_ANSWER_MESSAGE_PAYLOAD,              1024},
                {CloudComputeServiceMessagePayload::SUSPEND_VM_REQUEST_MESSAGE_PAYLOAD,           1024},
                {CloudComputeServiceMessagePayload::SUSPEND_VM_ANSWER_MESSAGE_PAYLOAD,            1024},
                {CloudComputeServiceMessagePayload::RESUME_VM_REQUEST_MESSAGE_PAYLOAD,            1024},
                {CloudComputeServiceMessagePayload::RESUME_VM_ANSWER_MESSAGE_PAYLOAD,             1024},
                {CloudComputeServiceMessagePayload::DESTROY_VM_REQUEST_MESSAGE_PAYLOAD,           1024},
                {CloudComputeServiceMessagePayload::DESTROY_VM_ANSWER_MESSAGE_PAYLOAD,            1024},
                {CloudComputeServiceMessagePayload::SUBMIT_STANDARD_JOB_REQUEST_MESSAGE_PAYLOAD,  1024},
                {CloudComputeServiceMessagePayload::SUBMIT_STANDARD_JOB_ANSWER_MESSAGE_PAYLOAD,   1024},
                {CloudComputeServiceMessagePayload::SUBMIT_PILOT_JOB_REQUEST_MESSAGE_PAYLOAD,     1024},
                {CloudComputeServiceMessagePayload::SUBMIT_PILOT_JOB_ANSWER_MESSAGE_PAYLOAD,      1024},
                {CloudComputeServiceMessagePayload::IS_THERE_AT_LEAST_ONE_HOST_WITH_AVAILABLE_RESOURCES_REQUEST_MESSAGE_PAYLOAD, 1024},
                {CloudComputeServiceMessagePayload::IS_THERE_AT_LEAST_ONE_HOST_WITH_AVAILABLE_RESOURCES_ANSWER_MESSAGE_PAYLOAD, 1024},
        };
 
    public:
        CloudComputeService(const std::string &hostname,
                            std::vector<std::string> execution_hosts,
                            std::string scratch_space_mount_point,
                            WRENCH_PROPERTY_COLLECTION_TYPE property_list = {},
                            WRENCH_MESSAGE_PAYLOADCOLLECTION_TYPE messagepayload_list = {});
 
        virtual bool supportsStandardJobs() override;
        virtual bool supportsCompoundJobs() override;
        virtual bool supportsPilotJobs() override;
 
        /***********************/
        /***********************/
 
        virtual std::string createVM(unsigned long num_cores,
                                     double ram_memory,
                                     WRENCH_PROPERTY_COLLECTION_TYPE property_list = {},
                                     WRENCH_MESSAGE_PAYLOADCOLLECTION_TYPE messagepayload_list = {});
 
        virtual std::string createVM(unsigned long num_cores,
                                     double ram_memory,
                                     std::string desired_vm_name,
                                     WRENCH_PROPERTY_COLLECTION_TYPE property_list = {},
                                     WRENCH_MESSAGE_PAYLOADCOLLECTION_TYPE messagepayload_list = {});
 
        virtual void shutdownVM(const std::string &vm_name);
 
        virtual void shutdownVM(const std::string &vm_name, bool send_failure_notifications, ComputeService::TerminationCause termination_cause);
 
        virtual std::shared_ptr<BareMetalComputeService> startVM(const std::string &vm_name);
 
        virtual std::shared_ptr<BareMetalComputeService> getVMComputeService(const std::string &vm_name);
 
        virtual std::string getVMPhysicalHostname(const std::string &vm_name);
 
        virtual void suspendVM(const std::string &vm_name);
 
        virtual void resumeVM(const std::string &vm_name);
 
        virtual void destroyVM(const std::string &vm_name);
 
        virtual bool isVMRunning(const std::string &vm_name);
 
        virtual bool isVMSuspended(const std::string &vm_name);
 
        virtual bool isVMDown(const std::string &vm_name);
 
 
        std::vector<std::string> getExecutionHosts();
 
        /***********************/
        /***********************/
 
        /***********************/
        /***********************/
 
        void submitCompoundJob(std::shared_ptr<CompoundJob> job,
                               const std::map<std::string, std::string> &service_specific_args) override {};
 
        void terminateCompoundJob(std::shared_ptr<CompoundJob> job) override {};
 
        void validateProperties();
 
        ~CloudComputeService();
 
        /***********************/
        /***********************/
 
    protected:
        /***********************/
        /***********************/
 
        friend class Simulation;
 
        int main() override;
 
        std::shared_ptr<SimulationMessage> sendRequest(simgrid::s4u::Mailbox *answer_mailbox, ComputeServiceMessage *message);
 
        virtual bool processNextMessage();
 
        virtual void processGetResourceInformation(simgrid::s4u::Mailbox *answer_mailbox,
                                                   const std::string &key);
 
        virtual void processGetExecutionHosts(simgrid::s4u::Mailbox *answer_mailbox);
 
        virtual void processCreateVM(simgrid::s4u::Mailbox *answer_mailbox,
                                     unsigned long requested_num_cores,
                                     double requested_ram,
                                     std::string desired_vm_name,
                                     WRENCH_PROPERTY_COLLECTION_TYPE property_list,
                                     WRENCH_MESSAGE_PAYLOADCOLLECTION_TYPE messagepayload_list
        );
 
        virtual void
        processStartVM(simgrid::s4u::Mailbox *answer_mailbox, const std::string &vm_name, const std::string &pm_name);
 
        virtual void processShutdownVM(simgrid::s4u::Mailbox *answer_mailbox,
                                       const std::string &vm_name,
                                       bool send_failure_notifications,
                                       ComputeService::TerminationCause termination_cause);
 
        virtual void processSuspendVM(simgrid::s4u::Mailbox *answer_mailbox, const std::string &vm_name);
 
        virtual void processResumeVM(simgrid::s4u::Mailbox *answer_mailbox, const std::string &vm_name);
 
        virtual void processDestroyVM(simgrid::s4u::Mailbox *answer_mailbox, const std::string &vm_name);
 
//        virtual void processSubmitStandardJob(const std::string &answer_mailbox, std::shared_ptr<StandardJob> job,
//                                              std::map<std::string, std::string> &service_specific_args);
//
//        virtual void processSubmitPilotJob(const std::string &answer_mailbox, std::shared_ptr<PilotJob> job,
//                                           std::map<std::string, std::string> &service_specific_args);
 
        virtual void
        processBareMetalComputeServiceTermination(std::shared_ptr<BareMetalComputeService> cs, int exit_code);
 
        virtual void processIsThereAtLeastOneHostWithAvailableResources(
                simgrid::s4u::Mailbox *answer_mailbox, unsigned long num_cores, double ram);
 
 
        void stopAllVMs(bool send_failure_notifications, ComputeService::TerminationCause termination_cause);
 
        static unsigned long VM_ID;
        std::vector<std::string> execution_hosts;
 
        std::map<std::string, double> used_ram_per_execution_host;
 
        std::map<std::string, unsigned long> used_cores_per_execution_host;
 
        std::map<std::string, std::pair<std::shared_ptr<S4U_VirtualMachine>, std::shared_ptr<BareMetalComputeService>>> vm_list;
 
        /***********************/
        /***********************/
 
    private:
        std::string findHost(unsigned long desired_num_cores, double desired_ram, std::string desired_host);
 
    };
}
 
#endif //WRENCH_CLOUDSERVICE_H