Service.h

 
#ifndef WRENCH_SERVICE_H
#define WRENCH_SERVICE_H
 
 
#include <string>
#include <map>
 
#include <wrench/simgrid_S4U_util/S4U_Daemon.h>
 
namespace wrench {
 
    class Service : public S4U_Daemon {
 
    public:
 
 
 
        /***********************/
        /***********************/
 
        void start(std::shared_ptr<Service> this_service, bool daemonize, bool auto_restart);
        virtual void stop();
        void suspend();
        void resume();
 
        std::string getHostname();
 
        bool isUp();
 
        std::string getPropertyValueAsString(std::string);
        double getPropertyValueAsDouble(std::string);
        unsigned long getPropertyValueAsUnsignedLong(std::string);
        bool getPropertyValueAsBoolean(std::string);
 
        void assertServiceIsUp();
 
        double getNetworkTimeoutValue();
        void setNetworkTimeoutValue(double value);
 
        /***********************/
        /***********************/
 
        /***********************/
        /***********************/
 
        double getMessagePayloadValue(std::string);
 
        void setStateToDown();
 
        static void increaseNumCompletedServicesCount();
        static void clearTrackedServices();
        static void cleanupTrackedServices();
 
        /***********************/
        /***********************/
 
    protected:
 
        /***********************/
        /***********************/
 
        static void assertServiceIsUp(std::shared_ptr<Service> s) { s->assertServiceIsUp(); };
 
        friend class Simulation;
 
        ~Service();
 
        Service(std::string hostname, std::string process_name_prefix, std::string mailbox_name_prefix);
 
        // Property stuff
        void setProperty(std::string, std::string);
 
        void setProperties(std::map<std::string, std::string> default_property_values,
                           std::map<std::string, std::string> overriden_property_values);
 
        // MessagePayload stuff
        void setMessagePayload(std::string, double);
 
        void setMessagePayloads(std::map<std::string, double> default_messagepayload_values,
                                std::map<std::string, double> overriden_messagepayload_values);
 
 
        void serviceSanityCheck();
 
        std::map<std::string, std::string> property_list;
 
        std::map<std::string, double> messagepayload_list;
 
        std::string name;
 
        double network_timeout = 30.0;
 
        template <class T>
        std::shared_ptr<T> getSharedPtr() {
            if (Service::service_shared_ptr_map.find(this) == Service::service_shared_ptr_map.end()) {
                throw std::runtime_error("Service::getSharedPtr(): master shared_ptr to service not found! This should happen only "
                                         "if the service has not been started, in which case this method shouldn't have been called");
            }
            auto shared_ptr = std::dynamic_pointer_cast<T>(Service::service_shared_ptr_map[this]);
            if (not shared_ptr) {
                throw std::runtime_error("Service::getSharedPtr(): Invalid provided template");
            }
            return shared_ptr;
        }
 
        template <class T>
        static std::shared_ptr<T> getServiceByName(std::string name) {
            for (auto const &s : Service::service_shared_ptr_map) {
                if (s.first->getName() == name) {
                    return std::dynamic_pointer_cast<T>(s.second);
                }
            }
            return nullptr;
        }
 
 
    private:
 
        static std::unordered_map<Service *, std::shared_ptr<Service>> service_shared_ptr_map;
 
        bool shutting_down = false;
 
        static unsigned long num_terminated_services;
 
 
        /***********************/
        /***********************/
 
    };
};
 
 
#endif //WRENCH_SERVICE_H