Example Demo RPC

Table of Contents

• Description
• Prebuilt Binaries
• Source Code
  • Json
  • Interfaces
  • Service Client
  • Service Server
  • Filter Client
  • Filter Interface
  • Plugin

Description

Shows how to access the rpc interfaces.

Prebuilt Binaries

• Demo Calculator
• Demo Calculator RPC Client
• Demo Calculator RPC Interface Provider
• Demo Calculator RPC Server

Source Code

./examples/demo_adtfplugins/demo_rpc/

Json

calculator.json

[
  // see the documentation at https://github.com/cinemast/libjson-rpc-cpp
  // that describes this interface definition format
 
  {
    "name": "Add",
    "params": {
      "nValue1": 1,
      "nValue2": 1
    },
    "returns": 1
  },
  {
    "name": "Subtract",
    "params": {
      "nValue1": 1,
      "nValue2": 1
    },
    "returns": 1
  },
  {
    "name": "Multiply",
    "params": {
      "nValue1": 1,
      "nValue2": 1
    },
    "returns": 1
  },
  {
    "name": "Divide",
    "params": {
      "nValue1": 1,
      "nValue2": 1
    },
    "returns": 1
  },
  {
    "name": "SetDelay",
    "params": {
      "nSeconds": 1
    },
    "returns": {
      "ErrorCode": 0,
      "Description": "no error",
      "Line": 0,
      "File": "file.cpp",
      "Function": "foo"
    }
  }
 
 
]

Interfaces

calculator_intf.h

 
#pragma once
 
class ICalculatorRPC
{
    public:
        ADTF_IID(ICalculatorRPC, "calculator.demo.remote.adtf");
        static constexpr const tChar* const DEFAULT_NAME = "calculator";
   
};
 
class ICalculator : public adtf::ucom::ant::IObject
{
public:
    ADTF_IID(ICalculator, "calculator.demo.filter.adtf");
 
    virtual int Add(int nValue1, int nValue2) = 0;
    virtual int Subtract(int nValue1, int nValue2) = 0;
    virtual int Multiply(int nValue1, int nValue2) = 0;
    virtual int Divide(int nValue1, int nValue2) = 0;
    virtual tResult SetDelay(int nSeconds) = 0;
};

demo_rpc_remote_interface.h

 
#pragma once
 
#include <adtf_remotesdk.h>
 
 // newer GCC versions warn about the deprecated throws declarations used by jsonrpc-cpp
#ifdef __GNUC__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated"
#endif
 
#include <calculatorclientstub.h>
 
#ifdef __GNUC__
#pragma GCC diagnostic pop
#endif
 

class cRemoteCalculator : public  adtf::remote::rpc_remote_interface<rpc_stubs::cCalculatorClientStub, ICalculatorRPC>, public object <ICalculator>
{
public:
    using rpc_remote_interface::rpc_remote_interface;
 
    ADTF_CLASS_ID(cRemoteCalculator, "calculator.demo.remote.adtf");
 
    int Add(int nValue1, int nValue2) override EXCEPTION_TO_DEFAULT(0,
    {
        return GetStub().Add(nValue1, nValue2);
    })
 
    int Subtract(int nValue1, int nValue2) override EXCEPTION_TO_DEFAULT(0,
    {
        return GetStub().Subtract(nValue1, nValue2);
    })
 
    int Multiply(int nValue1, int nValue2) override EXCEPTION_TO_DEFAULT(0,
    {
        return GetStub().Multiply(nValue1, nValue2);
    })
 
    int Divide(int nValue1, int nValue2) override EXCEPTION_TO_DEFAULT(0,
    {
        return GetStub().Divide(nValue1, nValue2);
    })
 
    tResult SetDelay(int nSeconds) override EXCEPTION_TO_RESULT(
    {
        return ToResult(GetStub().SetDelay(nSeconds));
    })
};

Service Client

demo_rpc_client.h

 
#pragma once
 
#include <adtfsystemsdk/adtf_service.h>
 
#ifndef ADTF_EXAMPLES_CID
#define ADTF_EXAMPLES_CID ".local.cid"
#endif

#define CID_DEMO_ADTF_RPC_CLIENT "demo_calculator_rpc_client.service" ADTF_EXAMPLES_CID
 
class cRPCClientService final : public adtf::system::cADTFService
{
    public:
        ADTF_CLASS_ID_NAME(cRPCClientService, CID_DEMO_ADTF_RPC_CLIENT, "Demo Calculator RPC Client");
 
    public: // overrides cService
        cRPCClientService();
        ~cRPCClientService() override;
 
        virtual tResult ServiceInit() override;
 
    private:
        adtf::base::property_variable<adtf::util::cString> m_strURL{"$(ADTF_REMOTE_CONTROL_URL)/calculator"};
};

demo_rpc_client.cpp

 
#include <adtf_systemsdk.h>
 
using namespace adtf::ucom;
using namespace adtf::base;
using namespace adtf::system;
 
#include "demo_rpc_client.h"
#include "calculator_intf.h"
#include "demo_rpc_remote_interface.h"
 
cRPCClientService::cRPCClientService()
{
    // sets a short description for the component
    SetDescription("Use this service to extend the ADTF System with a calculator client using RPC interfaces.");
 
    // set help link to jump to documentation from ADTF Configuration Editor
    SetHelpLink("$(ADTF_DIR)/doc/html/page_demo_calculator_rpc_client.html");
 
    // set default runlevel
    SetDefaultRunlevel(tADTFRunLevel::RL_Session);
 
    m_strURL.SetDescription("State a RPC endpoint of the current ADTF System");
    RegisterPropertyVariable("remote_control_url", m_strURL);
}
 
cRPCClientService::~cRPCClientService()= default;
 
tResult cRPCClientService::ServiceInit()
{
    RETURN_IF_FAILED(cADTFService::ServiceInit());
 
    // direct use of the stub methods
    {
        adtf::remote::remote_object<rpc_stubs::cCalculatorClientStub> oRemoteCalculator(m_strURL->GetPtr());
        int nThree = oRemoteCalculator.Add(1, 2);
        LOG_INFO("The result of 1 + 2 equals %d", nThree);
    }
 
    // use our mapped interface methods
    {
        object_ptr<ICalculator> pRemoteCalculator = make_object_ptr<cRemoteCalculator>(m_strURL->GetPtr());
        int nTwo = pRemoteCalculator->Multiply(1, 2);
        LOG_INFO("The result of 1 * 2 equals %d", nTwo);
    }
 
    RETURN_NOERROR;
}

Service Server

demo_rpc_server.h

 
#pragma once
 
#include <adtfsystemsdk/adtf_service.h>
 
#ifndef ADTF_EXAMPLES_CID
#define ADTF_EXAMPLES_CID ".local.cid"
#endif

#define CID_DEMO_ADTF_RPC_SERVER "demo_calculator_rpc_server.service" ADTF_EXAMPLES_CID
 
class cRPCServerService final : public adtf::system::cADTFService
{
    public:
        ADTF_CLASS_ID_NAME(cRPCServerService, CID_DEMO_ADTF_RPC_SERVER, "Demo Calculator RPC Server");
 
    public: // overrides cService
        cRPCServerService();
        ~cRPCServerService() override;
 
        virtual tResult ServiceInit() override;
        virtual tResult ServiceShutdown() override;
};

demo_rpc_server.cpp

 
#include <adtf_systemsdk.h>
 
using namespace adtf::ucom;
using namespace adtf::base;
using namespace adtf::system;
 
#include "demo_rpc_server.h"
 
#include "demo_rpc_object_server.h"
 
cRPCServerService::cRPCServerService()
{
    // sets a short description for the component
    SetDescription("Use this service to extend the ADTF System with a calculator server using RPC interfaces.");
 
    // set help link to jump to documentation from ADTF Configuration Editor
    SetHelpLink("$(ADTF_DIR)/doc/html/page_demo_calculator_rpc_server.html");
}
 
cRPCServerService::~cRPCServerService() = default;
 
tResult cRPCServerService::ServiceInit()
{
    RETURN_IF_FAILED(cADTFService::ServiceInit());
 
    // create our server object
    object_ptr<adtf::remote::IRPCObjectServer> pServerObject = make_object_ptr<cCalculator>();
    // and register it at the RPC object registry
    RETURN_IF_FAILED(adtf::remote::rpc_register_object_server(ICalculatorRPC::DEFAULT_NAME, pServerObject));
    RETURN_NOERROR;
}
 
tResult cRPCServerService::ServiceShutdown()
{
    // tell the registry that our RPC object is no longer available
    adtf::remote::rpc_unregister_object_server(ICalculatorRPC::DEFAULT_NAME);
    RETURN_NOERROR;
}

Filter Client

demo_calculator_client_filter.h

 
#pragma once
 
#include "calculator_intf.h"
 
#ifndef ADTF_EXAMPLES_CID
#define ADTF_EXAMPLES_CID ".local.cid"
#endif

#define CID_DEMO_ADTF_CALCULATION_FILTER "demo_calculator_client_filter.filter" ADTF_EXAMPLES_CID
 
class cCalculationClientFilter final : public adtf::filter::cFilter
{
    public:
        ADTF_CLASS_ID_NAME(cCalculationClientFilter, CID_DEMO_ADTF_CALCULATION_FILTER, "Demo Calculator");
 
    public: // overrides cFilter
        cCalculationClientFilter();
        ~cCalculationClientFilter() override;
 
        tResult Process(adtf::base::tNanoSeconds tmTimeOfTrigger,
            adtf::streaming::IRunner* pRunner) override;
 
        tResult Init(tInitStage eStage) override;
 
    private:
        adtf::filter::interface_client<ICalculator> m_oInterfaceClient;
        adtf::base::property_variable<int32_t> m_oServerDelay = { 0 };
};
 

demo_calculator_client_filter.cpp

 
#include <adtf_filtersdk.h>
 
using namespace adtf::base;
using namespace adtf::streaming;
 
#include "demo_calculator_client_filter.h"
 
cCalculationClientFilter::cCalculationClientFilter()
{
    // create a interface client pin to access the calculator interface
    m_oInterfaceClient = CreateInterfaceClient<ICalculator>("calculator_client");
    SetDescription("calculator_client", "Interface client to call a calculator function from a server");
 
    // create a trigger function that can be connected to an active runner.
    CreateRunner("trigger", cTimerTriggerHint(std::chrono::seconds{ 1 }));
    SetDescription("trigger", "Runner to periodically trigger the function which prints the timestamp of the trigger");
 
    // sets a short description for the component
    SetDescription("Use this filter to provide a client which accesses the printer interface from Demo Interface Printer (see Streaming Sources).");
 
    // set help link to jump to documentation from ADTF Configuration Editor
    SetHelpLink("$(ADTF_DIR)/doc/html/page_demo_calculator_client.html");
 
    // describe and register property we will set via the rpc interface
    m_oServerDelay.SetDescription("To construct an example that should show how you can make a server call with an error return, you can set an artificial delay on the server here");
    RegisterPropertyVariable("server_delay", m_oServerDelay);
}
 
cCalculationClientFilter::~cCalculationClientFilter() = default;
 
tResult cCalculationClientFilter::Process(tNanoSeconds /*tmTimeOfTrigger*/, IRunner * /*pRunner*/)
{
    // call remote function
    LOG_INFO("Sum: %d", m_oInterfaceClient->Add(2, 1));
 
    RETURN_NOERROR;
}
 
tResult cCalculationClientFilter::Init(tInitStage eStage)
{
    RETURN_IF_FAILED(cFilter::Init(eStage));
    if (eStage == tInitStage::StageGraphReady)
    {
        // use of error code in rpc interface to stop initialisation if server dosn't except parameter
        RETURN_IF_FAILED(m_oInterfaceClient->SetDelay(m_oServerDelay));
    }
 
    RETURN_NOERROR;
};

Filter Interface

demo_rpc_interface_filter.h

 
#pragma once
 
#include <adtffiltersdk/filter.h>
#include "calculator_intf.h"
 
#ifndef ADTF_EXAMPLES_CID
#define ADTF_EXAMPLES_CID ".local.cid"
#endif

#define CID_DEMO_ADTF_RPC_TO_INTERFACE_FILTER "demo_calculator_rpc_interface.filter" ADTF_EXAMPLES_CID
 
class cRPCInterfaceFilter final : public adtf::filter::cFilter
{
    public:
        ADTF_CLASS_ID_NAME(cRPCInterfaceFilter, CID_DEMO_ADTF_RPC_TO_INTERFACE_FILTER, "Demo Calculator RPC Interface Provider");
 
    public: // overrides cService
        cRPCInterfaceFilter();
        ~cRPCInterfaceFilter() override;
 
        tResult Init(tInitStage) override;
 
    private:
        adtf::base::property_variable<adtf::util::cString> m_strUrl{ "$(ADTF_REMOTE_CONTROL_URL)/calculator" };
        adtf::ucom::object_ptr<adtf::streaming::cBindingServer> m_pBindingServer;
};

demo_rpc_interface_filter.cpp

 
#include <adtf_filtersdk.h>
 
using namespace adtf::ucom;
using namespace adtf::base;
using namespace adtf::streaming;
 
#include "demo_rpc_interface_filter.h"
#include "demo_rpc_remote_interface.h"
 
cRPCInterfaceFilter::cRPCInterfaceFilter()
{
    // sets a short description for the component
    SetDescription("Use this filter to convert the rpc interface into a filter interface to provide the calculator functionality to other filters.");
 
    // set help link to jump to documentation from ADTF Configuration Editor
    SetHelpLink("$(ADTF_DIR)/doc/html/page_demo_calculator_rpc_interface_provider.html");
 
    // describe and register property
    m_strUrl.SetDescription("URL to the server object");
    RegisterPropertyVariable("url", m_strUrl);
}
 
cRPCInterfaceFilter::~cRPCInterfaceFilter() = default;
 
tResult cRPCInterfaceFilter::Init(tInitStage oStage)
{
    RETURN_IF_FAILED(cFilter::Init(oStage));
 
    if(oStage == tInitStage::StageFirst)
    {
        // create a interface server to provide the remote interface via the calculator pin
        CreateInterfaceServer<ICalculator>("calculator",
            ucom_object_ptr_cast<ICalculator>( make_object_ptr<cRemoteCalculator>(m_strUrl)));
        SetDescription("calculator", "Calculator interface example via RPC");
    }
 
    RETURN_NOERROR;
}

Plugin

plugin.cpp

 
#include "demo_string_sending_filter.h"
#include "demo_string_receiving_filter.h"

ADTF_PLUGIN("Demo String Handling Filters Plugin",
            cDemoStringSending,
            cDemoStringReceiving);