rpc_stubs.h

Go to the documentation of this file.

 
#pragma once
 
#include "rpc_object_client_intf.h"
#include "rpc_object_server_registry_intf.h"
#include "adtf_client_connector.h"
 
#include <jsonrpccpp/server/abstractserverconnector.h>
#include <a_util/result.h>
#include <rpc/json_rpc.h>
#include <rpc/rpc_server.h>
#include <json/value.h>
 
#include <adtf_utils.h>
#include <adtfucom3/adtf_ucom3.h>
#include <adtfbase/string_intf.h>
#include <adtfbase/rawmemory_intf.h>
 
#include <sstream>
 
#ifndef EXCEPTION_TO_DEFAULT
#define EXCEPTION_TO_DEFAULT(__default, __body) \
    try                                         \
    {                                           \
        __body                                  \
    }                                           \
    catch (...)                                 \
    {                                           \
        return __default;                       \
    }
#endif
 
#ifndef EXCEPTION_TO_DEFAULT_AND_LOG
    #define EXCEPTION_TO_DEFAULT_AND_LOG(__default, __body) \
        try                                         \
        {                                           \
            __body                                  \
        }                                           \
        catch (const std::exception& oEx)           \
        {                                           \
            LOG_ERROR(oEx.what());                  \
            return __default;                       \
        }                                           \
        catch (const tResult& oResult)              \
        {                                           \
            LOG_RESULT(oResult);                    \
            return __default;                       \
        }                                           \
        catch (...)                                 \
        {                                           \
            return __default;                       \
        }
#endif
 
#ifndef EXCEPTION_TO_RESULT
#if A_UTILS_VERSION_MAJOR < 4
    #define EXCEPTION_TO_RESULT(__body)                \
        try                                            \
        {                                              \
            __body                                     \
        }                                              \
        catch (...)                                    \
        {                                              \
            return a_util::result::Result(ERR_FAILED); \
        }
#else
    #define EXCEPTION_TO_RESULT(__body)                                       \
        try                                                                   \
        {                                                                     \
            __body                                                            \
        }                                                                     \
        catch (const std::exception& oEx)                                     \
        {                                                                     \
            RETURN_ERROR_DESC(ERR_FAILED, "RPC call failed: %s", oEx.what()); \
        }                                                                     \
        catch (...)                                                           \
        {                                                                     \
            RETURN_ERROR(ERR_FAILED);                                         \
        }
#endif
#endif
 
namespace adtf
{
namespace remote
{
namespace hollow
{
 
class cAdtfJsonConverter
{
 
public:
 
    static inline tResult ToResult(const Json::Value& oValue)
    {
        if (oValue["ErrorCode"].asInt() == ERR_NOERROR.error_code)
        {
            return tResult(ERR_NOERROR);
        }
        else
        {
            return tResult(oValue["ErrorCode"].asInt(),
                oValue["Description"].asString().c_str(),
                oValue["Line"].asInt(),
                oValue["File"].asString().c_str(),
                oValue["Function"].asString().c_str());
        }
    }
 
    static inline a_util::result::Result ToResult5(const tResult& oResult)
    {
        return a_util::result::Result(oResult.GetErrorCode().value,
            oResult.GetDescription(),
            oResult.GetLine(),
            oResult.GetFile(),
            oResult.GetFunction());
    }
 
    static inline tResult ToResult4(const a_util::result::Result& oResult)
    {
        return tResult(oResult.getErrorCode(),
            oResult.getDescription(),
            oResult.getLine(),
            adtf::util::cFilename(oResult.getFile()).GetName(),
            oResult.getFunction());
    }
 
    static inline Json::Value ToJson(const tResult & nResult)
    {
        Json::Value oResult;
        oResult["ErrorCode"] = nResult.GetErrorCode().value;
        oResult["Description"] = nResult.GetDescription();
        oResult["Line"] = nResult.GetLine();
        oResult["File"] = nResult.GetFile();
        oResult["Function"] = nResult.GetFunction();
        return oResult;
    }
 
    static inline std::string ToString(uint64_t nValue)
    {
#ifdef HAVE_STD_TO_STRING
        return std::to_string(nValue);
#else
        // Bug in g++ 5.x.x header file, not having std::to_string for C++11
        std::ostringstream stream;
        stream << nValue;
        return stream.str();
#endif
    }
 
    static inline std::string ToString(int64_t nValue)
    {
#ifdef HAVE_STD_TO_STRING
        return std::to_string(nValue);
#else
        // Bug in g++ 5.x.x header file, not having std::to_string for C++11
        std::ostringstream stream;
        stream << nValue;
        return stream.str();
#endif
    }
 
    static inline int64_t Stoll(const std::string& strValue)
    {
#ifdef HAVE_STD_STOLL
        return std::stoll(strValue);
#else
        // Bug in g++ 5.x.x header file, not having std::sto(u)ll for C++11
        return strtoll(strValue.c_str(), 0, 10);
#endif
    }
 
    static inline uint64_t Stoull(const std::string& strValue)
    {
#ifdef HAVE_STD_STOLL
        return std::stoull(strValue);
#else
        // Bug in g++ 5.x.x header file, not having std::sto(u)ll for C++11
        return strtoull(strValue.c_str(), 0, 10);
#endif
    }
 
};
 
template <typename Stub, typename Interface>
class rpc_remote_interface :
    private rpc::jsonrpc_remote_object<Stub, hollow::cADTFClientConnector, adtf::util::cString>,
    public IRPCObjectClient,
    protected cAdtfJsonConverter,
    public Interface
{
public:
    rpc_remote_interface(const adtf::util::cString& strUrl)
        : rpc::jsonrpc_remote_object<Stub, hollow::cADTFClientConnector, adtf::util::cString>(strUrl)
    {
    }
 
    tResult GetRPCIID(base::ant::IString&& strIID) const
    {
        strIID.Set(adtf::ucom::get_iid<Interface>());
        RETURN_NOERROR;
    }
 
    tResult GetName(base::ant::IString&& strName) const
    {
        strName.Set(Interface::DEFAULT_NAME);
        RETURN_NOERROR;
    }
 
protected:
    Stub& GetStub() const
    {
        return *const_cast<Stub*>(static_cast<const Stub*>(this));
    }
 
};
 
template <typename ServerStub, typename Interface>
class rpc_object_server:
    private rpc::jsonrpc_object_server<ServerStub>,
    protected cAdtfJsonConverter,
    public ucom::catwo::object<remote::ant::IRPCObjectServer, remote::catwo::IRPCInterfaceDefinition>
{
    public:
        tResult Receive(const base::ant::IRawMemory& oRequest,
                        base::ant::IRawMemory&& oResponse) override
        {
            try
            {
                auto pData = static_cast<const char*>(oRequest.Get());
                std::string strRequest(pData, pData + oRequest.GetSize());
                std::string strResponse;
                rpc::jsonrpc_object_server<ServerStub>::ProcessRequest(strRequest, strResponse);
                oResponse.Set(strResponse.c_str(), strResponse.size());
            }
            catch(...)
            {
                RETURN_ERROR(ERR_UNEXPECTED);
            }
 
            RETURN_NOERROR;
        }
 
        tResult GetRPCIID(base::ant::IString&& strIID) const override
        {
            return strIID.Set(adtf::ucom::get_iid<Interface>());
        }
 
        tResult GetRPCName(base::ant::IString&& strRPCName) const override
        {
            return strRPCName.Set(m_strRPCObjectName);
        }
 
        tResult SetRPCName(const char* strRPCName) override
        {
            m_strRPCObjectName = strRPCName;
            RETURN_NOERROR;
        }
 
        tResult GetInterfaceDefinition(base::ant::IString&& strInterfaceDefinition) const override
        {
            return strInterfaceDefinition.Set(ServerStub::interface_definition);
        }
 
    private:
        adtf::util::cString m_strRPCObjectName;
};
 
}
 
using hollow::rpc_remote_interface;
using hollow::rpc_object_server;
using hollow::cAdtfJsonConverter;
 
}
}