engine_json_registration_server.h

Go to the documentation of this file.

/* * NRP Core - Backend infrastructure to synchronize simulations
 *
 * Copyright 2020-2023 NRP Team
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 * This project has received funding from the European Union’s Horizon 2020
 * Framework Programme for Research and Innovation under the Specific Grant
 * Agreement No. 945539 (Human Brain Project SGA3).
 */
 
#ifndef ENGINE_JSON_REGISTRATION_SERVER_H
#define ENGINE_JSON_REGISTRATION_SERVER_H
 
#include <pistache/router.h>
#include <pistache/endpoint.h>
 
#include "nrp_general_library/datapack_interface/datapack_interface.h"
 
class EngineJSONRegistrationServer
{
        struct RequestHandler : Pistache::Http::Handler
        {
            HTTP_PROTOTYPE(RequestHandler);
 
            RequestHandler(EngineJSONRegistrationServer *pServer);
            ~RequestHandler() override;
 
            void onRequest(const Pistache::Http::Request& req, Pistache::Http::ResponseWriter response) override;
 
            private:
                EngineJSONRegistrationServer *_pServer = nullptr;
        };
 
        using engine_name_t = decltype(DataPackIdentifier::EngineName);
 
    public:
        static constexpr std::string_view JSONEngineName = "engine_name";
 
        static constexpr std::string_view JSONAddress = "address";
 
        static EngineJSONRegistrationServer *getInstance();
 
        static EngineJSONRegistrationServer *resetInstance(const std::string &serverAddress);
 
        static void clearInstance();
 
        static std::string tryInstantiate(const std::string & initialAddress, const unsigned numRetries);
 
        // Delete copy and move operations for singleton
        EngineJSONRegistrationServer(const EngineJSONRegistrationServer&) = delete;
        EngineJSONRegistrationServer(EngineJSONRegistrationServer&&) = delete;
 
        EngineJSONRegistrationServer &operator=(const EngineJSONRegistrationServer&) = delete;
        EngineJSONRegistrationServer &operator=(EngineJSONRegistrationServer&&) = delete;
 
        ~EngineJSONRegistrationServer();
 
        void startServerAsync();
 
        void shutdownServer();
 
        const std::string serverAddress() const;
 
        bool isRunning() const;
 
        size_t getNumWaitingEngines();
 
        std::string retrieveEngineAddress(const engine_name_t &engineName);
 
        std::string requestEngine(const engine_name_t &engineName);
 
        void registerEngineAddress(const engine_name_t &engineName, const std::string &address);
 
        static bool sendClientEngineRequest(const std::string &address, const engine_name_t &engineName, const std::string &engineAddress, const unsigned int numTries = 1, const unsigned int waitTime = 0);
 
    private:
        bool _serverRunning = false;
 
        std::string _address;
 
        Pistache::Http::Endpoint _endpoint;
 
        std::mutex _lock;
 
        std::map<decltype(DataPackIdentifier::EngineName), std::string> _registeredAddresses;
 
        static std::unique_ptr<EngineJSONRegistrationServer> _instance;
 
        EngineJSONRegistrationServer(const std::string &address);
 
        friend struct EngineJSONRegistrationServer::RequestHandler;
};
 
#endif // ENGINE_JSON_REGISTRATION_SERVER_H