nrp_core_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 NRP_CORE_SERVER_H
#define NRP_CORE_SERVER_H
 
#include <thread>
#include <mutex>
#include <condition_variable>
#include <grpcpp/grpcpp.h>
 
#include "nrp_protobuf/nrp_server.grpc.pb.h"
#include "nrp_simulation/simulation/simulation_manager.h"
#include "nrp_protobuf/proto_ops/protobuf_ops.h"
 
class NrpCoreServer : public NrpCore::NrpCore::Service
{
public:
    enum class RequestType { None, Initialize, RunLoop, RunUntilTimeout, StopLoop, Reset, Shutdown };
 
    NrpCoreServer(const std::string & address, std::shared_ptr<SimulationManager> && manager);
 
    void runServerLoop();
 
    void stopServerLoop();
 
private:
 
 
    void waitForRequest();
 
    bool isRequestPending() const;
 
 
    RequestType getRequestType() const;
 
    unsigned getRequestNumIterations() const;
 
 
    void resetRequest();
 
    void markRequestAsProcessed(const SimulationManager::RequestResult & result);
 
 
    grpc::Status requestHelper(std::unique_lock<std::mutex> & lock, RequestType requestType, NrpCore::SimStateMessage * returnMessage);
 
    void prepareTrajectory(NrpCore::Trajectory * trajectory);
 
    void setReturnMessageContent(const SimulationManager::RequestResult& res, NrpCore::SimStateMessage * returnMessage);
 
    std::vector<std::shared_ptr<const DataPackInterface>> extractExternalDataPacks(const NrpCore::DataPacks & message);
 
    grpc::Status initialize(grpc::ServerContext * , const NrpCore::EmptyMessage * message, NrpCore::InitializeResponse * returnMessage) override;
 
    grpc::Status runLoop(grpc::ServerContext * , const NrpCore::RunLoopMessage * message, NrpCore::RunLoopResponse * status) override;
 
    grpc::Status runUntilTimeout(grpc::ServerContext * , const NrpCore::EmptyMessage * , NrpCore::RunLoopResponse * returnMessage) override;
 
    grpc::Status stopLoop(grpc::ServerContext * , const NrpCore::EmptyMessage * , NrpCore::Response * returnMessage) override;
 
    grpc::Status reset(grpc::ServerContext * , const NrpCore::ResetMessage * message, NrpCore::ResetResponse * returnMessage) override;
 
    grpc::Status shutdown(grpc::ServerContext * , const NrpCore::EmptyMessage * , NrpCore::Response * returnMessage) override;
 
 
    std::mutex _mutex;
 
    std::condition_variable _consumerConditionalVar;
 
    std::condition_variable _producerConditionalVar;
 
    std::unique_lock<std::mutex> _lock;
 
 
    std::unique_ptr<grpc::Server> _server;
 
    RequestType _requestType = RequestType::None;
 
    unsigned _numIterations = 0;
 
    SimulationManager::RequestResult _requestResult;
 
    std::shared_ptr<SimulationManager> _manager;
 
    std::vector<std::unique_ptr<protobuf_ops::NRPProtobufOpsIface>> _protoOps;
 
};
 
#endif // NRP_CORE_SERVER_H
 
// EOF