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