HardwareAdaptergRPC.h

Go to the documentation of this file.

// This file is part of DynExp.
 
#pragma once
 
#include "stdafx.h"
#include "HardwareAdapterEthernet.h"
 
namespace DynExpHardware
{
    template <typename gRPCStub>
    class gRPCHardwareAdapter;
 
    class gRPCException : public Util::Exception
    {
        static constexpr auto UNIMPLEMENTED_ErrorMsg = "The connected gRPC server does not implement the called gRPC stub function. Check the server configuration.";
 
    public:
        gRPCException(const grpc::Status Result, const std::source_location Location = std::source_location::current()) noexcept;
    };
 
    template <typename gRPCStub>
    class gRPCHardwareAdapterParams : public DynExp::HardwareAdapterParamsBase
    {
    public:
        gRPCHardwareAdapterParams(DynExp::ItemIDType ID, const DynExp::DynExpCore& Core)
            : HardwareAdapterParamsBase(ID, Core), NetworkParams(*this) {}
 
        virtual ~gRPCHardwareAdapterParams() = default;
 
        virtual const char* GetParamClassTag() const noexcept override { return "gRPCHardwareAdapterParams"; }
 
        DynExp::NetworkParamsExtension NetworkParams;                                   
 
    private:
        void ConfigureParamsImpl(dispatch_tag<HardwareAdapterParamsBase>) override final { ConfigureParamsImpl(dispatch_tag<gRPCHardwareAdapterParams>()); }
        virtual void ConfigureParamsImpl(dispatch_tag<gRPCHardwareAdapterParams>) {}    
    };
 
    template <typename gRPCStub>
    class gRPCHardwareAdapterConfigurator : public DynExp::HardwareAdapterConfiguratorBase
    {
    public:
        using ObjectType = gRPCHardwareAdapter<gRPCStub>;
        using ParamsType = gRPCHardwareAdapterParams<gRPCStub>;
 
        gRPCHardwareAdapterConfigurator() = default;
        virtual ~gRPCHardwareAdapterConfigurator() = default;
 
    private:
        virtual DynExp::ParamsBasePtrType MakeParams(DynExp::ItemIDType ID, const DynExp::DynExpCore& Core) const override { return DynExp::MakeParams<gRPCHardwareAdapterConfigurator>(ID, Core); }
    };
 
    template <typename gRPCStub>
    class gRPCHardwareAdapter : public DynExp::HardwareAdapterBase
    {
    public:
        using ParamsType = gRPCHardwareAdapterParams<gRPCStub>;                                         
        using ConfigType = gRPCHardwareAdapterConfigurator<gRPCStub>;                                   
        using gRPCStubType = gRPCStub;                                                                  
 
        constexpr static auto Name() noexcept { return "gRPC Hardware Adapter"; }                       
        constexpr static auto Category() noexcept { return "Communication"; }                           
 
        gRPCHardwareAdapter(const std::thread::id OwnerThreadID, DynExp::ParamsBasePtrType&& Params)    
            : HardwareAdapterBase(OwnerThreadID, std::move(Params)) {}
        virtual ~gRPCHardwareAdapter();
 
        virtual std::string GetName() const override { return Name(); }
        virtual std::string GetCategory() const override { return Category(); }
 
    protected:
 
        typename gRPCStub::Stub& GetStubUnsafe() const;
 
        void CheckError(const grpc::Status Result, const std::source_location Location = std::source_location::current()) const;
 
        bool IsOpenedUnsafe() const noexcept { return StubPtr.get(); }
 
    private:
        void ResetImpl(dispatch_tag<HardwareAdapterBase>) override final;
        virtual void ResetImpl(dispatch_tag<gRPCHardwareAdapter>) {}                                    
 
        void EnsureReadyStateChild() override final;
        bool IsReadyChild() const override final;
        bool IsConnectedChild() const noexcept override final;
 
 
        void OpenUnsafe();
 
        void CloseUnsafe();
 
 
        virtual void OpenUnsafeChild() {}
 
        virtual void CloseUnsafeChild() {}
 
        std::unique_ptr<typename gRPCStub::Stub> StubPtr;                                               
    };
 
    template <typename gRPCStub>
    gRPCHardwareAdapter<gRPCStub>::~gRPCHardwareAdapter()
    {
        // Not locking, since the object is being destroyed. This should be inherently thread-safe.
        CloseUnsafe();
    }
 
    template <typename gRPCStub>
    typename gRPCStub::Stub& gRPCHardwareAdapter<gRPCStub>::GetStubUnsafe() const
    {
        if (!IsOpenedUnsafe())
            ThrowExceptionUnsafe(std::make_exception_ptr(Util::NotAvailableException("The gRPC stub is not connected yet.", Util::ErrorType::Error)));
 
        return *StubPtr;
    }
 
    template <typename gRPCStub>
    void gRPCHardwareAdapter<gRPCStub>::CheckError(const grpc::Status Result, const std::source_location Location) const
    {
        if (Result.ok())
            return;
 
        // AcquireLock() has already been called by an (in)direct caller of this function.
        ThrowExceptionUnsafe(std::make_exception_ptr(gRPCException(Result, Location)));
    }
 
    template <typename gRPCStub>
    void gRPCHardwareAdapter<gRPCStub>::ResetImpl(dispatch_tag<HardwareAdapterBase>)
    {
        // auto lock = AcquireLock(); not necessary here, since DynExp ensures that Object::Reset() can only
        // be called if respective object is not in use.
 
        CloseUnsafe();
 
        ResetImpl(dispatch_tag<gRPCHardwareAdapter>());
    }
 
    template <typename gRPCStub>
    void gRPCHardwareAdapter<gRPCStub>::EnsureReadyStateChild()
    {
        auto lock = AcquireLock(HardwareOperationTimeout);
 
        OpenUnsafe();
    }
 
    template <typename gRPCStub>
    bool gRPCHardwareAdapter<gRPCStub>::IsReadyChild() const
    {
        auto lock = AcquireLock(HardwareOperationTimeout);
 
        auto Exception = GetExceptionUnsafe();
        Util::ForwardException(Exception);
 
        return IsOpenedUnsafe();
    }
 
    template <typename gRPCStub>
    bool gRPCHardwareAdapter<gRPCStub>::IsConnectedChild() const noexcept
    {
        try
        {
            auto lock = AcquireLock(HardwareOperationTimeout);
 
            return IsOpenedUnsafe();
        }
        catch (...)
        {
            return false;
        }
    }
 
    template <typename gRPCStub>
    void gRPCHardwareAdapter<gRPCStub>::OpenUnsafe()
    {
        if (IsOpenedUnsafe())
            return;
 
        auto DerivedParams = dynamic_Params_cast<gRPCHardwareAdapter>(GetParams());
 
        // TODO: Offer SSL credentials.
        StubPtr = gRPCStub::NewStub(grpc::CreateChannel(DerivedParams->NetworkParams.MakeAddress(), grpc::InsecureChannelCredentials()));
 
        OpenUnsafeChild();
    }
 
    template <typename gRPCStub>
    void gRPCHardwareAdapter<gRPCStub>::CloseUnsafe()
    {
        CloseUnsafeChild();
 
        StubPtr.reset();
    }
}