engine_json_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_SERVER_H
#define ENGINE_JSON_SERVER_H
 
#include "nrp_json_engine_protocol/config/engine_json_config.h"
#include "nrp_json_engine_protocol/engine_server/json_datapack_controller.h"
 
#include "nrp_general_library/datapack_interface/datapack.h"
#include "nrp_general_library/utils/time_utils.h"
#include "nrp_general_library/utils/nrp_logger.h"
 
#include <map>
#include <memory>
#include <pistache/router.h>
#include <pistache/endpoint.h>
#include <nlohmann/json.hpp>
 
class EngineJSONServer
{
        static constexpr auto ShutdownWaitTime = std::chrono::milliseconds(10*1000);
 
    protected:
        static constexpr std::string_view GetDataPackInformationRoute = EngineJSONConfigConst::EngineServerGetDataPacksRoute;
        static constexpr std::string_view SetDataPackRoute = EngineJSONConfigConst::EngineServerSetDataPacksRoute;
        static constexpr std::string_view RunLoopStepRoute = EngineJSONConfigConst::EngineServerRunLoopStepRoute;
        static constexpr std::string_view InitializeRoute = EngineJSONConfigConst::EngineServerInitializeRoute;
        static constexpr std::string_view ResetRoute = EngineJSONConfigConst::EngineServerResetRoute;
        static constexpr std::string_view ShutdownRoute = EngineJSONConfigConst::EngineServerShutdownRoute;
 
    public:
        using mutex_t = std::timed_mutex;
        using lock_t = std::unique_lock<EngineJSONServer::mutex_t>;
 
        EngineJSONServer(const std::string &engineAddress, const std::string &engineName, const std::string &clientAddress);
 
        EngineJSONServer() = delete;
 
        virtual ~EngineJSONServer();
 
        // Delete copy mechanisms
        EngineJSONServer(const EngineJSONServer&) = delete;
        EngineJSONServer &operator=(const EngineJSONServer&) = delete;
 
 
        bool isServerRunning() const;
 
        void startServerAsync();
 
        void startServer();
 
        void shutdownServer();
 
        uint16_t serverPort() const;
 
        std::string serverAddress() const;
 
        void registerDataPack(const std::string &datapackName, JsonDataPackController *interface);
 
        void registerDataPackNoLock(const std::string &datapackName, JsonDataPackController *interface);
 
        virtual SimulationTime runLoopStep(SimulationTime timeStep) = 0;
 
        virtual nlohmann::json initialize(const nlohmann::json &data, EngineJSONServer::lock_t &datapackLock) = 0;
 
        virtual nlohmann::json reset(EngineJSONServer::lock_t &datapackLock) = 0;
 
        virtual nlohmann::json shutdown(const nlohmann::json &data) = 0;
 
        bool shutdownFlag();
 
    protected:
        mutex_t _datapackLock;
 
        void clearRegisteredDataPacks();
 
 
        virtual nlohmann::json getDataPackData(const nlohmann::json &reqData);
 
        virtual void setDataPackData(const nlohmann::json &reqData);
 
        const std::string &getEngineName() { return _engineName; }
 
    private:
        bool _serverRunning = false;
 
        bool _shutdownFlag = false;
 
        std::mutex _shutdown_mutex;
 
        std::string _serverAddress;
 
        Pistache::Rest::Router _router;
 
        std::string _engineName;
 
        using enpoint_ptr_t = std::unique_ptr<Pistache::Http::Endpoint>;
 
        enpoint_ptr_t _pEndpoint = nullptr;
 
        std::map<std::string, JsonDataPackController*> _datapacksControllers;
 
        NRPLogger _loggerCfg;
 
        static Pistache::Rest::Router setRoutes(EngineJSONServer *server);
 
        static nlohmann::json parseRequest(const Pistache::Rest::Request &req, Pistache::Http::ResponseWriter &res);
 
        void getDataPackDataHandler(const Pistache::Rest::Request &req, Pistache::Http::ResponseWriter res);
 
        void setDataPackProcessorr(const Pistache::Rest::Request &req, Pistache::Http::ResponseWriter res);
 
        static const std::string &getIteratorKey(const nlohmann::json::const_iterator &jsonIterator);
 
        void runLoopStepHandler(const Pistache::Rest::Request &req, Pistache::Http::ResponseWriter res);
 
        void initializeHandler(const Pistache::Rest::Request &req, Pistache::Http::ResponseWriter res);
 
        void resetHandler(const Pistache::Rest::Request &req, Pistache::Http::ResponseWriter res);
 
        void shutdownHandler(const Pistache::Rest::Request &req, Pistache::Http::ResponseWriter res);
 
        static Pistache::Http::Endpoint createEndpoint(std::string *engineAddress, const std::string &engineName);
 
        friend class EngineJSONServerTest_Functions_Test;
        friend class TestEngineJSONServer;
};
 
#endif // ENGINE_JSON_SERVER_H