gRPCInstrument.h

Go to the documentation of this file.

// This file is part of DynExp.
 
#pragma once
 
#include "stdafx.h"
#include "DynExpCore.h"
#include "HardwareAdapters/HardwareAdaptergRPC.h"
#include "MetaInstruments/DataStreamInstrument.h"
 
#include "Common.pb.h"
#include "Common.grpc.pb.h"
 
namespace DynExpInstr
{
    template <typename BaseInstr, typename std::enable_if_t<std::is_base_of_v<DynExp::InstrumentBase, BaseInstr>, int>, typename... gRPCStubs>
    class gRPCInstrument;
 
    constexpr DynExpProto::Common::FrequencyUnitType ToProtoFrequencyUnitType(DynExp::Units::UnitType Unit)
    {
        switch (Unit)
        {
        case DynExp::Units::UnitType::Freq_Hz: return DynExpProto::Common::FrequencyUnitType::Hz;
        case DynExp::Units::UnitType::Wavelength_nm: return DynExpProto::Common::FrequencyUnitType::nm;
        case DynExp::Units::UnitType::Inv_cm: return DynExpProto::Common::FrequencyUnitType::Inv_cm;
        default: throw Util::InvalidDataException("The given unit is not supported here. Did you forget to adjust this function or the UnitType enumeration in file \"Units.h\"?");
        }
    }
 
    constexpr DynExpProto::Common::IntensityUnitType ToProtoIntensityUnitType(DynExp::Units::UnitType Unit)
    {
        switch (Unit)
        {
        case DynExp::Units::UnitType::Arbitrary: return DynExpProto::Common::IntensityUnitType::Arbitrary;
        case DynExp::Units::UnitType::LogicLevel: return DynExpProto::Common::IntensityUnitType::LogicLevel;
        case DynExp::Units::UnitType::Counts: return DynExpProto::Common::IntensityUnitType::Counts;
        case DynExp::Units::UnitType::Volt: return DynExpProto::Common::IntensityUnitType::Volt;
        case DynExp::Units::UnitType::Ampere: return DynExpProto::Common::IntensityUnitType::Ampere;
        case DynExp::Units::UnitType::Power_W: return DynExpProto::Common::IntensityUnitType::Power_W;
        case DynExp::Units::UnitType::Power_dBm: return DynExpProto::Common::IntensityUnitType::Power_dBm;
        default: throw Util::InvalidDataException("The given unit is not supported here. Did you forget to adjust this function or the UnitType enumeration in file \"Units.h\"?");
        }
    }
 
    namespace gRPCInstrumentTasks
    {
        template <typename BaseInstr, std::enable_if_t<std::is_base_of_v<DynExp::InstrumentBase, BaseInstr>, int>, typename... gRPCStubs>
        class InitTask : public BaseInstr::InitTaskType
        {
        protected:
            template <typename Type>
            using dispatch_tag = DynExp::InitTaskBase::dispatch_tag<Type>;
 
        private:
            void InitFuncImpl(dispatch_tag<typename BaseInstr::InitTaskType>, DynExp::InstrumentInstance& Instance) override final
            {
                {
                    auto InstrParams = DynExp::dynamic_Params_cast<gRPCInstrument<BaseInstr, 0, gRPCStubs...>>(Instance.ParamsGetter());
                    auto InstrData = DynExp::dynamic_InstrumentData_cast<gRPCInstrument<BaseInstr, 0, gRPCStubs...>>(Instance.InstrumentDataGetter());
 
                    // TODO: Offer SSL credentials.
                    InstrData->StubPtrs = std::make_tuple(gRPCStubs::NewStub(grpc::CreateChannel(InstrParams->NetworkParams.MakeAddress(), grpc::InsecureChannelCredentials()))...);
                } // InstrParams and InstrData unlocked here.
 
                InitFuncImpl(dispatch_tag<InitTask>(), Instance);
            }
 
            virtual void InitFuncImpl(dispatch_tag<InitTask<BaseInstr, 0, gRPCStubs...>>, DynExp::InstrumentInstance& Instance) {}
        };
 
        template <typename BaseInstr, std::enable_if_t<std::is_base_of_v<DynExp::InstrumentBase, BaseInstr>, int>, typename... gRPCStubs>
        class ExitTask : public BaseInstr::ExitTaskType
        {
        protected:
            template <typename Type>
            using dispatch_tag = DynExp::ExitTaskBase::dispatch_tag<Type>;
 
        private:
            void ExitFuncImpl(dispatch_tag<typename BaseInstr::ExitTaskType>, DynExp::InstrumentInstance& Instance) override final
            {
                try
                {
                    ExitFuncImpl(dispatch_tag<ExitTask>(), Instance);
 
                    auto InstrData = DynExp::dynamic_InstrumentData_cast<gRPCInstrument<BaseInstr, 0, gRPCStubs...>>(Instance.InstrumentDataGetter());
 
                    InstrData->ResetStubPtrs();
                } // InstrData unlocked here.
                catch (...)
                {
                    // Swallow any exception which might arise from instrument shutdown since a failure
                    // of this function is not considered a severe error.
                }
            }
 
            virtual void ExitFuncImpl(dispatch_tag<ExitTask>, DynExp::InstrumentInstance& Instance) {}
        };
 
        template <typename BaseInstr, std::enable_if_t<std::is_base_of_v<DynExp::InstrumentBase, BaseInstr>, int>, typename... gRPCStubs>
        class UpdateTask : public BaseInstr::UpdateTaskType
        {
        protected:
            template <typename Type>
            using dispatch_tag = DynExp::UpdateTaskBase::dispatch_tag<Type>;
 
        private:
            void UpdateFuncImpl(dispatch_tag<typename BaseInstr::UpdateTaskType>, DynExp::InstrumentInstance& Instance) override final
            {
                UpdateFuncImpl(dispatch_tag<UpdateTask>(), Instance);
            }
 
            virtual void UpdateFuncImpl(dispatch_tag<UpdateTask>, DynExp::InstrumentInstance& Instance) {}
        };
    }
 
    template <typename gRPCStub>
    using StubPtrType = std::shared_ptr<typename gRPCStub::Stub>;
 
    template <typename BaseInstr, typename std::enable_if_t<std::is_base_of_v<DynExp::InstrumentBase, BaseInstr>, int>, typename... gRPCStubs>
    class gRPCInstrumentData : public BaseInstr::InstrumentDataType
    {
        friend class gRPCInstrumentTasks::InitTask<BaseInstr, 0, gRPCStubs...>;
        friend class gRPCInstrumentTasks::ExitTask<BaseInstr, 0, gRPCStubs...>;
 
    public:
        template <typename... ArgTs>
        gRPCInstrumentData(ArgTs&& ...Args) : BaseInstr::InstrumentDataType(std::forward<ArgTs>(Args)...) {}
 
        virtual ~gRPCInstrumentData() = default;
 
        template <size_t Index>
        auto GetStub() const noexcept { return std::get<Index>(StubPtrs); }
 
        template <typename T>
        auto GetStub() const noexcept { return std::get<StubPtrType<T>>(StubPtrs); }
 
    private:
        void ResetStubPtrs() { std::apply([](auto&... StubPtr) { (StubPtr.reset(), ...); }, StubPtrs); }
 
        void ResetImpl(DynExp::InstrumentDataBase::dispatch_tag<typename BaseInstr::InstrumentDataType>) override final
        {
            ResetStubPtrs();
 
            ResetImpl(DynExp::InstrumentDataBase::dispatch_tag<gRPCInstrumentData>());
        }
 
        virtual void ResetImpl(DynExp::InstrumentDataBase::dispatch_tag<gRPCInstrumentData>) {};
 
        std::tuple<StubPtrType<gRPCStubs>...> StubPtrs;
    };
 
    template <typename BaseInstr, typename std::enable_if_t<std::is_base_of_v<DynExp::InstrumentBase, BaseInstr>, int>, typename... gRPCStubs>
    class gRPCInstrumentParams : public BaseInstr::ParamsType
    {
    public:
        gRPCInstrumentParams(DynExp::ItemIDType ID, const DynExp::DynExpCore& Core)
            : BaseInstr::ParamsType(ID, Core), NetworkParams(*this) {}
 
        virtual ~gRPCInstrumentParams() = default;
 
        virtual const char* GetParamClassTag() const noexcept override { return "gRPCInstrumentParams"; }
 
        DynExp::NetworkParamsExtension NetworkParams;   
 
    private:
        void ConfigureParamsImpl(DynExp::InstrumentParamsBase::dispatch_tag<typename BaseInstr::ParamsType>) override final
        {
            ConfigureParamsImpl(DynExp::InstrumentParamsBase::dispatch_tag<gRPCInstrumentParams>());
        }
        
        virtual void ConfigureParamsImpl(DynExp::InstrumentParamsBase::dispatch_tag<gRPCInstrumentParams>) {}
 
        virtual const DynExp::NetworkParamsExtension* GetNetworkAddressParamsChild() const noexcept override { return &NetworkParams; }
    };
 
    template <typename BaseInstr, typename std::enable_if_t<std::is_base_of_v<DynExp::InstrumentBase, BaseInstr>, int>, typename... gRPCStubs>
    class gRPCInstrumentConfigurator : public BaseInstr::ConfigType
    {
    public:
        using ObjectType = gRPCInstrument<BaseInstr, 0, gRPCStubs...>;
        using ParamsType = gRPCInstrumentParams<BaseInstr, 0, gRPCStubs...>;
 
        gRPCInstrumentConfigurator() = default;
        virtual ~gRPCInstrumentConfigurator() = default;
 
    private:
        virtual DynExp::ParamsBasePtrType MakeParams(DynExp::ItemIDType ID, const DynExp::DynExpCore& Core) const override { return DynExp::MakeParams<gRPCInstrumentConfigurator>(ID, Core); }
    };
 
    template <typename BaseInstr, typename std::enable_if_t<std::is_base_of_v<DynExp::InstrumentBase, BaseInstr>, int>, typename... gRPCStubs>
    class gRPCInstrument : public BaseInstr
    {
    public:
        using ParamsType = gRPCInstrumentParams<BaseInstr, 0, gRPCStubs...>;                    
        using ConfigType = gRPCInstrumentConfigurator<BaseInstr, 0, gRPCStubs...>;              
        using InstrumentDataType = gRPCInstrumentData<BaseInstr, 0, gRPCStubs...>;              
 
        constexpr static auto Name() noexcept { return "gRPC Instrument"; }                     
        constexpr static auto Category() noexcept { return "Network Instruments (Clients)"; }   
 
    protected:
        gRPCInstrument(const std::thread::id OwnerThreadID, DynExp::ParamsBasePtrType&& Params)
            : BaseInstr(OwnerThreadID, std::move(Params)) {}
 
    public:
        virtual ~gRPCInstrument() {}
 
        virtual std::string GetName() const override { return Name(); }                         
        virtual std::string GetCategory() const override { return Category(); }                 
 
    private:
        void ResetImpl(DynExp::Object::dispatch_tag<BaseInstr>) override final { ResetImpl(DynExp::Object::dispatch_tag<gRPCInstrument>()); }
 
        virtual void ResetImpl(DynExp::Object::dispatch_tag<gRPCInstrument>) {}
 
        virtual std::unique_ptr<DynExp::InitTaskBase> MakeInitTask() const override { return DynExp::MakeTask<gRPCInstrumentTasks::InitTask<BaseInstr, 0, gRPCStubs...>>(); }
 
        virtual std::unique_ptr<DynExp::ExitTaskBase> MakeExitTask() const override { return DynExp::MakeTask<gRPCInstrumentTasks::ExitTask<BaseInstr, 0, gRPCStubs...>>(); }
 
        virtual std::unique_ptr<DynExp::UpdateTaskBase> MakeUpdateTask() const override { return DynExp::MakeTask<gRPCInstrumentTasks::UpdateTask<BaseInstr, 0, gRPCStubs...>>(); }
    };
 
    template <typename gRPCStub, typename RequestMsgType, typename ResponseMsgType>
    using StubFuncPtrType = grpc::Status(gRPCStub::*)(grpc::ClientContext*, const RequestMsgType&, ResponseMsgType*);
 
    template <typename gRPCStub, typename RequestMsgType, typename ResponseMsgType>
    inline ResponseMsgType InvokeStubFunc(StubPtrType<gRPCStub> StubPtr, StubFuncPtrType<gRPCStub, RequestMsgType, ResponseMsgType> StubFunc, const RequestMsgType& RequestMsg)
    {
        grpc::ClientContext Context;
        ResponseMsgType ReplyMsg;
 
        if (!StubPtr)
            throw Util::InvalidStateException("A stub pointer has not been initialized yet.");
        if (!StubFunc)
            throw Util::InvalidArgException("StubFunc must not be nullptr.");
 
        static const auto Timeout = std::chrono::milliseconds(2000);
        Context.set_deadline(std::chrono::system_clock::now() + Timeout);
        
        auto Result = (*StubPtr.*StubFunc)(&Context, RequestMsg, &ReplyMsg);
        if (!Result.ok())
            throw DynExpHardware::gRPCException(Result);
 
        return ReplyMsg;
    }
}