SessionService.h

Go to the documentation of this file.

/*
 * SessionService.h
 *
 *  Created on: November 26, 2020
 *  Author: Alexander Kuester
 *  Copyright (c) 2020 openTwin
 */
 
#pragma once
 
// SessionService header
#include "globalDatatypes.h"
#include "PortManager.h"
#include "Service.h"
#include "GlobalDirectoryService.h"
 
#include "OTCore/ServiceBase.h"
#include "OTCore/LogModeManager.h"
#include "OTCommunication/ActionTypes.h"
#include "OTCommunication/ActionHandler.h"
#include "OTCommunication/ActionHandleConnector.h"
#include "OTSystem/SystemInformation.h"
 
// C++ header
#include <map>
#include <vector>
#include <string>
 
class Session;
class RelayService;
class GlobalSessionService;
 
class SessionService : public ot::ActionHandler {
public:
    SessionService();
    virtual ~SessionService() {}; // todo: add cleanup
    
    static SessionService * instance(void);
 
    // ######################################################################################
 
    // Setter / Getter
 
    void setIp(const std::string& _ip) { m_ip = _ip; };
    const std::string& ip(void) const { return m_ip; };
 
    void setPort(const std::string& _port);
    const std::string& port(void) const { return m_port; };
 
    void setId(ot::serviceID_t _id) { m_id = _id; };
    ot::serviceID_t id(void) const { return m_id; };
 
    std::string url(void) const { return m_ip + ":" + m_port; };
 
    void setDataBaseURL(const std::string& _url) { m_dataBaseURL = _url; }
 
    const std::string& dataBaseURL(void) const { return m_dataBaseURL; }
 
    void setSiteID(std::string _ID) { m_siteID = _ID; }
 
    const std::string& siteID(void) const { return m_siteID; }
 
    void setAuthorisationServiceURL(const std::string& _url) { m_serviceAuthorisationURL = _url; }
 
    const std::string& serviceAuthorisationURL(void) const { return m_serviceAuthorisationURL; }
 
    void setGlobalDirectoryServiceURL(const std::string& _url);
 
    bool isServiceInDebugMode(const std::string& _serviceName);
 
    // ######################################################################################
 
    // Getter
    
    // ######################################################################################
 
    // Service management
 
    Session * createSession(
        const std::string &                     _sessionID,
        const std::string &                     _userName,
        const std::string &                     _projectName,
        const std::string &                     _collectionName,
        const std::string &                     _sessionType
    );
 
    Session * getSession(const std::string& _sessionID);
 
    bool runMandatoryServices(
        const std::string &                     _sessionID
    );
 
    bool runMandatoryServices(
        Session *                               _session
    );
 
    void serviceClosing(
        Service *                               _service,
        bool                                    _notifyOthers,
        bool                                    _autoCloseSessionIfMandatory = true
    );
 
    void removeSession(Session* _session);
 
    void forgetSession(Session* _session);
 
    std::list<const Session *> sessions(void);
    
    bool runServiceInDebug(const std::string& _serviceName, const std::string& _serviceType, Session* _session, std::string& _serviceURL);
    
    bool runRelayService(Session * _session, std::string& _websocketURL, std::string& _serviceURL);
 
    void setGlobalSessionService(GlobalSessionService * _gss) { m_globalSessionService = _gss; }
 
    Service * getServiceFromURL(const std::string& _url);
 
    void initializeSystemInformation();
 
    void updateLogMode(const ot::LogModeManager& _newData);
 
private:
    // Message handling
 
    OT_HANDLER(handleGetDBURL, SessionService, OT_ACTION_CMD_GetDatabaseUrl, ot::ALL_MESSAGE_TYPES)
    OT_HANDLER(handleGetAuthURL, SessionService, OT_ACTION_CMD_GetAuthorisationServerUrl, ot::ALL_MESSAGE_TYPES)
    OT_HANDLER(handleGetGlobalServicesURL, SessionService, OT_ACTION_CMD_GetGlobalServicesUrl, ot::ALL_MESSAGE_TYPES)
 
    OT_HANDLER(handleGetSystemInformation, SessionService, OT_ACTION_CMD_GetSystemInformation, ot::SECURE_MESSAGE_TYPES)
    OT_HANDLER(handleGetMandatoryServices, SessionService, OT_ACTION_CMD_GetMandatoryServices, ot::SECURE_MESSAGE_TYPES)
 
    OT_HANDLER(handleRegisterNewService, SessionService, OT_ACTION_CMD_RegisterNewService, ot::ALL_MESSAGE_TYPES)
    OT_HANDLER(handleCreateNewSession, SessionService, OT_ACTION_CMD_CreateNewSession, ot::ALL_MESSAGE_TYPES)
 
    OT_HANDLER(handleCheckProjectOpen, SessionService, OT_ACTION_CMD_IsProjectOpen, ot::SECURE_MESSAGE_TYPES)
    OT_HANDLER(handleSendBroadcastMessage, SessionService, OT_ACTION_CMD_SendBroadcastMessage, ot::SECURE_MESSAGE_TYPES)
    OT_HANDLER(handleGetServicesInSession, SessionService, OT_ACTION_CMD_GetSessionServices, ot::SECURE_MESSAGE_TYPES)
    OT_HANDLER(handleGetSessionExists, SessionService, OT_ACTION_CMD_GetSessionExists, ot::SECURE_MESSAGE_TYPES)
    OT_HANDLER(handleServiceClosing, SessionService, OT_ACTION_CMD_ServiceClosing, ot::SECURE_MESSAGE_TYPES)
    OT_HANDLER(handleMessage, SessionService, OT_ACTION_CMD_Message, ot::SECURE_MESSAGE_TYPES)
    OT_HANDLER(handleShutdownSession, SessionService, OT_ACTION_CMD_ShutdownSession, ot::SECURE_MESSAGE_TYPES)
    OT_HANDLER(handleServiceFailure, SessionService, OT_ACTION_CMD_ServiceFailure, ot::SECURE_MESSAGE_TYPES)
    OT_HANDLER(handleEnableServiceDebug, SessionService, OT_ACTION_CMD_ServiceEnableDebug, ot::SECURE_MESSAGE_TYPES)
    OT_HANDLER(handleDisableServiceDebug, SessionService, OT_ACTION_CMD_ServiceDisableDebug, ot::SECURE_MESSAGE_TYPES)
    OT_HANDLER(handleReset, SessionService, OT_ACTION_CMD_Reset, ot::SECURE_MESSAGE_TYPES) // todo: you thought i work? well.. no i do not (yet) :D
    OT_HANDLER(handleGetDebugInformation, SessionService, OT_ACTION_CMD_GetDebugInformation, ot::SECURE_MESSAGE_TYPES)
    OT_HANDLER(handleCheckStartupCompleted, SessionService, OT_ACTION_CMD_CheckStartupCompleted, ot::SECURE_MESSAGE_TYPES)
    OT_HANDLER(handleServiceShow, SessionService, OT_ACTION_CMD_ServiceShow, ot::SECURE_MESSAGE_TYPES)
    OT_HANDLER(handleServiceHide, SessionService, OT_ACTION_CMD_ServiceHide, ot::SECURE_MESSAGE_TYPES)
    OT_HANDLER(handleAddMandatoryService, SessionService, OT_ACTION_CMD_AddMandatoryService, ot::SECURE_MESSAGE_TYPES)
    OT_HANDLER(handleRegisterNewGlobalDirectoryService, SessionService, OT_ACTION_CMD_RegisterNewGlobalDirecotoryService, ot::SECURE_MESSAGE_TYPES)
    OT_HANDLER(handleServiceStartupFailed, SessionService, OT_ACTION_CMD_ServiceStartupFailed, ot::SECURE_MESSAGE_TYPES)
 
    OT_HANDLER(handleSetGlobalLogFlags, SessionService, OT_ACTION_CMD_SetGlobalLogFlags, ot::SECURE_MESSAGE_TYPES)
 
    void workerShutdownSession(ot::serviceID_t _serviceId, Session* _session);
 
    std::string                                 m_dataBaseURL;                      
    std::string                                 m_siteID;                           
    std::string                                 m_serviceAuthorisationURL;          
 
    std::string                                 m_ip;
    std::string                                 m_port;
    ot::serviceID_t                             m_id;
    ot::SystemInformation                       m_systemLoadInformation;
 
    //NOTE, debug only this variable contains the IP address that is used for the services 
    
    std::map<std::string, bool>                 m_serviceDebugList;
    std::map<std::string,
        std::vector<ot::ServiceBase> *>         m_mandatoryServicesMap;             
    std::map<std::string, Session *>            m_sessionMap;                       
 
    GlobalSessionService *                      m_globalSessionService;
    GlobalDirectoryService *                    m_globalDirectoryService;
 
    std::list<std::string> m_sessionShutdownQueue;
 
    ot::LogModeManager m_logModeManager;
 
    SessionService(const SessionService&) = delete;
    SessionService & operator =(const SessionService&) = delete;
};