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

• Taking loaned samples

• Taking samples by copy

• Correlation between requests and replies

Replier: receiving requests and sending replies

• SimpleReplier example

• Basic Replier example

• Taking loaned samples

• Taking samples by copy

Error handling

• Error handling example

Creating a Requester

• Setting up a participant

• Creating a Requester

          
          // Note: error checking omitted for simplicity
          
          // Create a DomainParticipant
          DomainParticipant participant = 
                  DomainParticipantFactory.get_instance().create_participant(
                      domainId, DomainParticipantFactory.PARTICIPANT_QOS_DEFAULT, 
                      null, StatusKind.STATUS_MASK_NONE);
                 
          // Create a Requester (if creation fails an exception is thrown)
          // Foo is the request type and FooTypeSupport is its DDS TypeSupport
          // Bar is the reply type and BarTypeSupport is its DDS TypeSupport
          Requester<Foo, Bar> requester = 
                  new Requester<Foo, Bar>(
                          participant, "TestService",
                          FooTypeSupport.get_instance(),
                          BarTypeSupport.get_instance());
          

• Finalizing a Requester

          requester.close();

  See Also

  Creating a Requester with optional parameters

  Configuring Request-Reply QoS profiles

Creating a Requester with optional parameters

• Setting up a participant

• Creating a Requester with optional parameters

          
          // Note: error checking omitted for simplicity
          
          // Create a DomainParticipant
          DomainParticipant participant = 
                  DomainParticipantFactory.get_instance().create_participant(
                          0, DomainParticipantFactory.PARTICIPANT_QOS_DEFAULT, 
                          null, StatusKind.STATUS_MASK_NONE);
          
          // Create a Requester with a QoS profile (located for example in
          // USER_QOS_PROFILES.xml, in the current working directory)
          Requester<Foo, Bar> requester = 
                  new Requester<Foo, Bar>(
                      new RequesterParams(
                          participant,
                          FooTypeSupport.get_instance(),
                          BarTypeSupport.get_instance())
                      .setServiceName("TestService")
                      .setQosProfile("RequestReplyExampleProfiles", 
                                     "RequesterExampleProfile"));
          

  See Also

  Creating a Requester

Basic Requester example

• Creating a Requester
• Creating a Requester with optional parameters

• Basic Requester example

          
          // Send request
          Foo request = new Foo();
          request.message = "A request";
          requester.sendRequest(request);
          
          // Create reply Sample
          Sample<Bar> reply = requester.createReplySample();
          
          // Receive reply (wait for it and get the sample)
          boolean received = requester.receiveReply(reply , MAX_WAIT);
          
          if (received) {
              if (reply.getInfo().valid_data) {
                  System.out.println("Received reply: " + reply.getData().message);
              } else {
                  System.out.println("Received invalid reply");
              }
          } else {
              System.out.println("Reply not received");
          }
          

• Basic Requester example using the String built-in type

          
          // Create a requester using the String 
          // type with the DDS StringTypeSupport
          Requester<String, String> requester = 
                  new Requester<String, String>(
                      new RequesterParams(
                          participant,
                          StringTypeSupport.get_instance(),
                          StringTypeSupport.get_instance())
                      .setServiceName("TestServiceString")
                      .setQosProfile("MyLibrary", "RequesterProfile"));
          
          // Send request
          requester.sendRequest("A request");
          
          // Create reply Sample
          Sample<String> reply = requester.createReplySample();
          
          // Receive reply (wait for it and get the sample)
          boolean received = requester.receiveReply(reply , MAX_WAIT);
          
          if (received && reply.getInfo().valid_data) {
              System.out.println("Received reply: " + reply.getData());
          }
          

• Basic Requester example using DynamicData.

          
          // Instantiate DynamicData type support. For simplicity we create them
          // from existing, generated TypeCode objects (Foo and Bar)
          DynamicDataTypeSupport fooDynamicTypeSupport = new DynamicDataTypeSupport(
                  FooTypeCode.VALUE, new DynamicDataTypeProperty_t());
          DynamicDataTypeSupport barDynamicTypeSupport = new DynamicDataTypeSupport(
                  BarTypeCode.VALUE, new DynamicDataTypeProperty_t());
          
          // Create a requester using a DynamicData type support
          Requester<DynamicData, DynamicData> requester = 
                  new Requester<DynamicData, DynamicData>(
                          participant, "TestService",
                          fooDynamicTypeSupport,
                          barDynamicTypeSupport);
          
          // Create a Foo instance
          DynamicData foo = (DynamicData) fooDynamicTypeSupport.create_data();
          foo.set_string("message", DynamicData.MEMBER_ID_UNSPECIFIED, 
                  "A dynamic request");
          
          // Send request
          requester.sendRequest(foo);
          
          // Create reply Sample
          Sample<DynamicData> reply = requester.createReplySample();
          
          // Receive reply (wait for it and get the sample)
          boolean received = requester.receiveReply(reply , MAX_WAIT);
          
          if (received && reply.getInfo().valid_data) {
              System.out.println("Received reply: " + 
                  reply.getData().get_string("message", DynamicData.MEMBER_ID_UNSPECIFIED));
          }
          

  See Also

  Basic Replier example

Taking loaned samples

• Get iterator to loaned replies (no copies)

          
          // Take loaned samples
          // Unlike receiveReplies(), takeReplies() doesn't block. It returns an
          // empty collection if there are no replies at that moment.
          // (before that we can call requester.wait_for_replies)
          Sample.Iterator<Bar> replies = requester.takeReplies();
  
          try {
              while (replies.hasNext()) {
                  Sample<Bar> reply = replies.next();
                  System.out.println("Received: " + reply.getData().message);
              }
          } finally {
              replies.close();
          }
          

  A more compact version using a try-with-resources block (since Java 7):

  try (Sample.Iterator<String> replies = requester.getReplies()) {
      while (replies.hasNext()) {
          Sample<String> reply = replies.next();
          System.out.println("Received: " + reply.getData());
      }
  }

See Also

Basic Requester example

Basic Replier example

Taking samples by copy

Taking samples by copy

• Get copies of the replies:

          
          ArrayList<Sample<Bar>> replies = new ArrayList<Sample<Bar>>();
          
          // Add to existing list, reusing and overwriting any existing elements
          requester.takeReplies(replies, 10);
          for (Sample<Bar> reply : replies) {
              System.out.println("Received: " + reply.getData().message);
          }
                  
          // Get replies in a newly created list
          List<Sample<Bar>> newList = requester.takeReplies(null, 10);
          for (Sample<Bar> reply : newList) {
              System.out.println("Received: " + reply.getData().message);
          }
          

  See Also

  Basic Replier example

  Taking loaned samples

Correlating requests and replies

• Creating a Requester

• Example 1) Waiting for a reply for a specific request

          
          // Create requests
          WriteSample<Foo> request1 = requester.createRequestSample();
          request1.getData().message = "Request 1";
          WriteSample<Foo> request2 = requester.createRequestSample();
          request2.getData().message = "Request 2";
          
          // Send requests using WriteSample
          requester.sendRequest(request1);
          requester.sendRequest(request2);
  
          // Wait for a reply to the second request
          Sample<Bar> reply = requester.createReplySample();
          requester.waitForReplies(1, MAX_WAIT, request2.getIdentity());
          requester.takeReply(reply, request2.getIdentity());
          
          assert reply.getRelatedIdentity().equals(request2.getIdentity());
          System.out.println("Received reply: " + reply.getData().message);
  
          // Wait for a reply to the first request
          requester.waitForReplies(1, MAX_WAIT, request1.getIdentity());
          requester.takeReply(reply, request1.getIdentity());
          
          assert reply.getRelatedIdentity().equals(request1.getIdentity());
          System.out.println("Received reply: " + reply.getData().message);
          

• Example 2) Correlate reply after receiving it

          
          // Create requests
          WriteSample<Foo> request1 = requester.createRequestSample();
          request1.getData().message = "Request 1";
          WriteSample<Foo> request2 = requester.createRequestSample();
          request2.getData().message = "Request 2";
          
          // Send requests using WriteSample
          requester.sendRequest(request1);
          requester.sendRequest(request2);
  
          // Wait for two replies
          boolean received = requester.waitForReplies(2, MAX_WAIT);
          if (!received) {
              System.out.println("Replies not received");
              return;
          }
          
          Sample.Iterator<Bar> replies = requester.takeReplies();
          try {
              while(replies.hasNext()) {
                  Sample<Bar> reply = replies.next();
                  if (reply.getRelatedIdentity().equals(
                          request1.getIdentity())) {
                      System.out.println(
                          "Received reply for request 1: " + reply.getData().message);
                  } else if (reply.getRelatedIdentity().equals(
                          request2.getIdentity())) {
                      System.out.println(
                          "Received reply for request 2: " + reply.getData().message);
                  } else {
                      // Should not happen
                      System.out.println("Received unexpected reply");
                  }
              }
          } finally {
              // Return the loan
              replies.close();
          }
          

  See Also

  Basic Requester example

  Basic Replier example

Creating a Replier

• Setting up a participant

• Creating a Replier

          
          // Create a DomainParticipant
          DomainParticipant participant = 
                  DomainParticipantFactory.get_instance().create_participant(
                          domain_id, DomainParticipantFactory.PARTICIPANT_QOS_DEFAULT, 
                          null, StatusKind.STATUS_MASK_NONE);
          
          // Create a Replier
          Replier<Foo, Bar> replier = 
                  new Replier<Foo, Bar>(
                          participant, "TestService",
                          FooTypeSupport.get_instance(),
                          BarTypeSupport.get_instance());
          

• Finalizing a Replier

          replier.close();

Basic Replier example

• Creating a Replier

• Basic Replier example

          
          // Create a Sample for reading
          Sample<Foo> request = replier.createRequestSample();
          
          // Receive one request
          boolean received = replier.receiveRequest(request, MAX_WAIT);
          
          if (!received) {
              System.out.println("Request not received");
              return false;
          }
          
          if (request.getInfo().valid_data) {
              // Send a reply for that request
              Bar reply = new Bar();
              reply.message = "Reply for " + request.getData().message;
              replier.sendReply(reply, request.getIdentity());
          }
          
          // Note: a replier can send more than one reply for the same request
          

  See Also

  Basic Requester example

SimpleReplier example

• Implement a listener

      class MySimpleReplierListener implements SimpleReplierListener<Foo, Bar> {
  
          private Bar reply = new Bar();
          
          public Bar onRequestAvailable(Sample<Foo> request) {
              if (request.getInfo().valid_data) {
                  // Return a reply
                  reply.message = "Simple reply for " + request.getData().message; 
                  return reply;
              } else {
                  // Do not reply to dispose/unregister samples
                  return null;
              }
          }
  
          public void returnLoan(Bar reply) {
              // nothing to do
          }
          
      }

• And create a SimpleReplier with the listener:

          
          // Create a SimpleReplier using a DomainParticipant, service name and
          // the a SimpleReplierListener implementation
          SimpleReplier<Foo, Bar> replier = 
                  new SimpleReplier<Foo, Bar>(
                          participant, "TestService",
                          new MySimpleReplierListener(),
                          FooTypeSupport.get_instance(), 
                          BarTypeSupport.get_instance());
          
          // After creation the SimpleReplier is already active and may call
          // the listener
          

  See Also

  Basic Requester example

Error handling example

• Catching an exception from the request-reply API

  
          // All the operations in the request-reply API
          // throw exceptions in case of error.
  
          // You can also set the verbosity level to warning for
          // additional information
          Logger.get_instance().set_verbosity(
                  LogVerbosity.NDDS_CONFIG_LOG_VERBOSITY_WARNING);
  
  
          //
          // For example, this replier is sending a reply for a nonexistent request
          //
          WriteSample<Bar> reply = replier.createReplySample();
          SampleIdentity_t invalidRequestId = new SampleIdentity_t();
          
          
          try {
              replier.sendReply(reply, invalidRequestId);
          } catch (RETCODE_BAD_PARAMETER ex) { 
              // You can also catch RETCODE_ERROR, which is more generic
              System.out.println("Exception while sending reply: " + ex);
          }
  

Configuring Request-Reply QoS profiles

If you do not specify your own quality of service parameters (in com.rti.connext.requestreply.RequesterParams and com.rti.connext.requestreply.ReplierParams<TReq,TRep>), a com.rti.connext.requestreply.Requester<TReq,TRep> and com.rti.connext.requestreply.Replier<TReq,TRep> 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 com.rti.connext.requestreply.Requester<TReq,TRep> using this profile.

See Also

Creating a Requester with optional parameters

Configuring QoS Profiles with XML