ServiceManager.h

Go to the documentation of this file.

#pragma once
 
#include "ServiceInformation.h"
#include "SessionInformation.h"
 
#include <map>
#include <string>
#include <vector>
#include <list>
#include <mutex>
 
#include "OTCore/JSON.h"
#include "OTSystem/Network.h"
 
class Service;
namespace std { class thread; }
 
class ServiceManager {
public:
    ServiceManager();
    virtual ~ServiceManager();
 
    void addToJsonObject(ot::JsonValue& _object, ot::JsonAllocator& _allocator);
 
    // ##################################################################################################################################
 
    // Setter/Getter
 
    void setServiceIP(const std::string& _ip) { m_servicesIpAddress = _ip; }
    
    const std::string& lastError(void) const { return m_lastError; }
 
    void setSiteID(const std::string& _siteID) { m_siteID = _siteID; }
    const std::string& siteID(void) const { return m_siteID; }
 
    // ##################################################################################################################################
 
    // Service control
 
    bool requestStartService(const SessionInformation& _sessionInformation, const ServiceInformation& _serviceInformation);
 
    bool requestStartRelayService(const SessionInformation& _sessionInformation, std::string& _websocketUrl, std::string& _relayServiceURL);
 
    void sessionClosed(const std::string& _sessionID);
 
    void serviceDisconnected(const std::string& _sessionID, const ServiceInformation& _info, const std::string& _serviceURL);
 
    void GetSessionInformation(ot::JsonArray &sessionInfo, ot::JsonAllocator &allocator);
 
private:
 
    struct RequestedService {
        SessionInformation session;
        ServiceInformation service;
        unsigned int startAttempt;
    };
    struct InitializingService {
        Service * service;
        RequestedService startInfo;
        int initializeAttempt; 
    };
 
    void runThreads(void);
    
    void serviceStartFailed(RequestedService _info);
    void sendInitializeMessage(InitializingService _info);
    void serviceInitializeFailed(InitializingService _info);
 
    std::vector<Service *> * sessionServices(const SessionInformation& _sessionInformation);
    bool restartServiceAfterCrash(const SessionInformation& _sessionInformation, Service * _service);
    void notifySessionEmergencyShutdown(const SessionInformation& _sessionInformation, Service * _crashedService);
 
    void workerServiceStarter(void);
    void workerServiceInitializer(void);
    void workerHealthCheck(void);
    void workerServiceStopper(void);
 
    std::string                                             m_servicesIpAddress;
    std::string                                             m_lastError;
    std::string                                             m_siteID;
    
    bool                                                    m_isShuttingDown;
 
    std::thread *                                           m_threadServiceStarter;
    std::thread *                                           m_threadServiceInitializer;
    std::thread *                                           m_threadHealthCheck;
    std::thread *                                           m_threadServiceStopper;
 
    std::map<SessionInformation, std::vector<Service *> *>  m_services;
    std::mutex                                              m_mutexServices;
 
    std::list<RequestedService>                             m_requestedServices;
    std::mutex                                              m_mutexRequestedServices;
 
    std::list<InitializingService>                          m_initializingServices;
    std::mutex                                              m_mutexInitializingServices;
 
    std::list<Service *>                                    m_stoppingServices;
    std::mutex                                              m_mutexStoppingServices;
};