Request-Reply Examples

Examples on how to use the request-reply API. More...

Examples on how to use the request-reply API.

Request-Reply code examples.

Request-Reply Examples

DDS Types

RTI Connext uses DDS data types for sending and receiving requests and replies. Valid types are those generated by the rtiddsgen code generator, the DDS built-in types, and DynamicData. Refer to the User's Manual and the following links for more information:

• Creating user data types using rtiddsgen,
• Using the DDS built-in types,
• Using DynamicData

Set up

• Create a DomainParticipant
• Create a requester
• Create a requester with parameters
• Create a replier

Requester: sending requests and receiving replies

• Basic Requester example
• Correlation between requests and replies

Replier: receiving requests and sending replies

• Basic Replier example
• SimpleReplier example

Requester Creation

• Setting up a DomainParticipant
• Creating a Requester

      using namespace rti::request;
  
      dds::domain::DomainParticipant participant(domain_id);
  
      Requester<Foo, Bar> requester(participant, "TestService");
  

Creating a Requester with optional parameters

• Setting up a DomainParticipant
• Creating a Requester with additional parameters

      using namespace rti::request;
  
      // Create a DomainParticipant
      dds::domain::DomainParticipant participant(domain_id);
  
      // Create a Requester with a QoS profile (located for example in
      // USER_QOS_PROFILES.xml, in the current working directory, which the
      // default QosProvider will load)
      RequesterParams requester_params(participant);
      requester_params.service_name("TestService");
  
      dds::core::QosProvider qos_provider = dds::core::QosProvider::Default();
      requester_params.datareader_qos(
              qos_provider.datareader_qos("RequestReplyExampleProfiles::RequesterExampleProfile"));
      requester_params.datawriter_qos(
              qos_provider.datawriter_qos("RequestReplyExampleProfiles::RequesterExampleProfile"));
  
  
      Requester<Foo, Bar> requester(requester_params);
  

  See also

  Requester Creation

  Configuring Request-Reply QoS profiles

Basic Requester example

• Requester Creation
• Creating a Requester with optional parameters
• Basic Requester example

      using namespace rti::request;
  
      // Send request
      Foo request("A Request");
      requester.send_request(request);
  
      // Receive reply (wait for it and get the sample)
      auto replies = requester.receive_replies(MAX_WAIT);
  
      if (replies.length() == 0) {
          std::cout << "Reply not received\n";
      }
  
      for (const auto& reply : replies) {
          if (reply.info().valid()) {
              std::cout << "Received reply: " << reply.data() << std::endl;
          } else {
              std::cout << "Received invalid reply\n";
          }
      }
  

  See also

  Basic Replier example

  SimpleReplier example

Correlating requests and replies

• Requester Creation
• Example 1) Waiting for a reply to a specific request

  
      using namespace rti::request;
  
      // Create requests
      Foo request1("Request 1"), request2("Request 2");
  
      // Send requests and save request ID
      rti::core::SampleIdentity request_id1 = requester.send_request(request1);
      rti::core::SampleIdentity request_id2 = requester.send_request(request2);
  
      // Wait for a reply to the second request
      bool received = requester.wait_for_replies(1, MAX_WAIT, request_id2);
  
      if (!received) {
          std::cout << "Did not receive reply for request 2" << std::endl;
          return;
      }
  
      // Take that reply
      dds::sub::LoanedSamples<Bar> replies = requester.take_replies(request_id2);
      if (replies.length() == 0) {
          throw std::runtime_error("did not receive any replies");
      }
  
      // This postcondition should always be true
      if (replies[0].info()->related_original_publication_virtual_sample_identity()
              != request_id2) {
          throw std::runtime_error("postcondition failed");
      }
  
      if (replies[0].info().valid()) {
          std::cout << "Received reply for request 2: "
                    << replies[0].data() << std::endl;
      }
  
      // Wait for a reply to the first request
      received = requester.wait_for_replies(1, MAX_WAIT, request_id1);
  
      if (!received) {
          std::cout << "Did not receive reply for request 1" << std::endl;
          return;
      }
  
      // Take that reply
      replies = requester.take_replies(request_id1);
      if (replies.length() == 0) {
          throw std::runtime_error("did not receive any replies");
      }
  
      // This postcondition should always be true
      if (replies[0].info()->related_original_publication_virtual_sample_identity()
              != request_id1) {
          throw std::runtime_error("postcondition failed");
      }
  
      if (replies[0].info().valid()) {
          std::cout << "Received reply for request 1: "
                    << replies[0].data() << std::endl;
      }
  

• Example 2) Correlating a reply after receiving it

  
      using namespace rti::request;
  
      // Create requests
      Foo request1("Request 1"), request2("Request 2");
  
      // Send requests and save request ID
      rti::core::SampleIdentity request_id1 = requester.send_request(request1);
      rti::core::SampleIdentity request_id2 = requester.send_request(request2);
  
      // Wait for two replies. In this case we don't mind the
      // reception order
      bool received = requester.wait_for_replies(2, MAX_WAIT);
      if (!received) {
          std::cout << "Replies not received" << std::endl;
          return;
      }
  
      // Get all the replies
      auto replies = requester.take_replies();
  
      // Find the reply for request 1.
      //
      // We search using the STL find_if algorithm. The search range is all
      // the elements in the replies container (from beginning to end).
      // We use a predicate included in the API that evaluates to
      // true when a Sample's related_identity equals the identity that
      // is passed to the constructor (request_id1, in this case)
      auto it = std::find_if(
              replies.begin(),
              replies.end(),
              IsReplyRelatedPredicate<Bar>(request_id1));
  
      if (it != replies.end()) {
          std::cout << "Received reply for request 1: "
                    << it->data() << std::endl;
      }
  
      // Find the reply for request 2
      it = std::find_if(
              replies.begin(),
              replies.end(),
              IsReplyRelatedPredicate<Bar>(request_id2));
  
      if (it != replies.end()) {
          std::cout << "Received reply for request 2: "
                    << it->data() << std::endl;
      }
  

  See also

  Basic Requester example

  Basic Replier example

Creating a Replier

• Setting up a DomainParticipant
• Create a Replier

      using namespace rti::request;
  
      dds::domain::DomainParticipant participant(domain_id);
  
      // Use the same service name as the Requester's
      Replier<Foo, Bar> replier(participant, "TestService");
  

Basic Replier example

• Creating a Replier
• Basic Replier example

  
      using namespace rti::request;
  
      // Receive requests
      dds::sub::LoanedSamples<Foo> requests = replier.receive_requests(MAX_WAIT);
      for (const auto& request : requests) {
          if (!request.info().valid()) {
              continue;
          }
  
          Bar reply("Reply for " + request.data().message());
  
          // Send a reply for this request, identified by the ID in
          // request.info()
          replier.send_reply(reply, request.info());
  
          // Note: a replier can send more than one reply for the same request
          // replier.send_reply(Bar("Another reply"), request.info());
      }
  

  See also

  Basic Requester example

SimpleReplier example

    using namespace rti::request;

    SimpleReplier<Foo, Bar> replier(
        participant,
        "TestService",
        [](const Foo& request)
        {
            return Bar(std::string("Simple reply for ") + request.message());
        }
    );

    // After creation the SimpleReplier is already active and the functor will
    // be called upon receiving a request.

See also

Basic Requester example

Configuring Request-Reply QoS profiles

If you do not specify your own QoS parameters (in RequesterParams and ReplierParams), a rti::request::Requester and rti::request::Replier are created using a default configuration. That configuration is equivalent to the one in the following QoS profile called "default":

<?xml version="1.0"?>

<dds xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:noNamespaceSchemaLocation="../../../resource/schema/rti_dds_qos_profiles.xsd">

    <qos_library name="RequestReplyExampleProfiles">

        <!-- Default QoS:

             This profile contains the QoS that Requesters and Repliers
             would use by default. We can use it as a base profile to inherit
             from and override some parameters
         -->
        <qos_profile name="default">
            <datawriter_qos>

                <!-- Strict reliable -->
                <reliability>
                    <kind>RELIABLE_RELIABILITY_QOS</kind>
                    <max_blocking_time>
                        <sec>10</sec>
                        <nanosec>0</nanosec>
                    </max_blocking_time>
                </reliability>

                <history>
                    <kind>KEEP_ALL_HISTORY_QOS</kind>
                </history>

                <!-- These are typical protocol parameters for a reliable
                     DataWriter -->
                <protocol>
                    <rtps_reliable_writer>
                        <max_heartbeat_retries>
                            LENGTH_UNLIMITED
                        </max_heartbeat_retries>
                        <heartbeats_per_max_samples>
                            2
                        </heartbeats_per_max_samples>
                        <heartbeat_period>
                            <sec>0</sec>
                            <nanosec>100000000</nanosec> <!--100ms -->
                        </heartbeat_period>
                        <fast_heartbeat_period>
                            <sec>0</sec>
                            <nanosec>10000000</nanosec> <!--10ms -->
                        </fast_heartbeat_period>
                        <late_joiner_heartbeat_period>
                            <sec>0</sec>
                            <nanosec>10000000</nanosec> <!--10ms -->
                        </late_joiner_heartbeat_period>
                        <max_nack_response_delay>
                            <sec>0</sec>
                            <nanosec>0</nanosec>
                        </max_nack_response_delay>
                        <min_nack_response_delay>
                            <sec>0</sec>
                            <nanosec>0</nanosec>
                        </min_nack_response_delay>
                        <max_send_window_size>32</max_send_window_size>
                        <min_send_window_size>32</min_send_window_size>
                    </rtps_reliable_writer>
                </protocol>

                <writer_resource_limits>
                    <!-- This setting enables efficient communication
                         between a replier and an arbitrary number of requesters
                     -->
                    <max_remote_reader_filters>
                        LENGTH_UNLIMITED
                    </max_remote_reader_filters>
                </writer_resource_limits>
            </datawriter_qos>

            <datareader_qos>
                <!-- Strict reliable -->
                <reliability>
                    <kind>RELIABLE_RELIABILITY_QOS</kind>
                    <max_blocking_time>
                        <sec>10</sec>
                        <nanosec>0</nanosec>
                    </max_blocking_time>
                </reliability>

                <history>
                    <kind>KEEP_ALL_HISTORY_QOS</kind>
                </history>

                <!-- These are typical protocol parameters for a reliable
                     DataReader -->
                <protocol>
                    <rtps_reliable_reader>
                        <max_heartbeat_response_delay>
                            <sec>0</sec>
                            <nanosec>0</nanosec>
                        </max_heartbeat_response_delay>
                        <min_heartbeat_response_delay>
                            <sec>0</sec>
                            <nanosec>0</nanosec>
                        </min_heartbeat_response_delay>
                    </rtps_reliable_reader>
                </protocol>

            </datareader_qos>

        </qos_profile>

        <!-- This is the profile used by the Requester.
             It inherits from "default", defined above,
             and overrides some QoS -->
        <qos_profile name="RequesterExampleProfile"
                     base_name="default">

            <!-- QoS for the data writer that sends requests -->
            <datawriter_qos>
                <durability>
                    <kind>TRANSIENT_LOCAL_DURABILITY_QOS</kind>
                </durability>
            </datawriter_qos>

            <!-- QoS for the data reader that receives replies -->
            <datareader_qos>
                <durability>
                    <kind>VOLATILE_DURABILITY_QOS</kind>
                </durability>
            </datareader_qos>
        </qos_profile>

        <!-- This is the profile used by the Replier.
             It inherits from "default", defined above,
             and overrides some QoS -->
        <qos_profile name="ReplierExampleProfile"
                     base_name="default">

            <!-- QoS for the data writer that sends replies -->
            <datawriter_qos>
                <durability>
                    <kind>VOLATILE_DURABILITY_QOS</kind>
                </durability>
            </datawriter_qos>

            <!-- QoS for the data reader that receives requests -->
            <datareader_qos>
                <durability>
                    <kind>TRANSIENT_LOCAL_DURABILITY_QOS</kind>
                </durability>
            </datareader_qos>
        </qos_profile>

    </qos_library>
</dds>

You can use the profile called "RequesterExampleProfile", which modifies some parameters from the default. The example Creating a Requester with optional parameters shows how to create a rti::request::Requester using this profile.

See also

Creating a Requester with optional parameters

Configuring QoS Profiles with XML