/* Delete all entities */ static int subscriber_shutdown( DDS_DomainParticipant *participant) { DDS_ReturnCode_t retcode; int status = 0; if (participant != NULL) { retcode = DDS_DomainParticipant_delete_contained_entities(participant); if (retcode != DDS_RETCODE_OK) { printf("delete_contained_entities error %d\n", retcode); status = -1; } retcode = DDS_DomainParticipantFactory_delete_participant( DDS_TheParticipantFactory, participant); if (retcode != DDS_RETCODE_OK) { printf("delete_participant error %d\n", retcode); status = -1; } } /* RTI Connext provides the finalize_instance() method on domain participant factory for users who want to release memory used by the participant factory. Uncomment the following block of code for clean destruction of the singleton. */ /* retcode = DDS_DomainParticipantFactory_finalize_instance(); if (retcode != DDS_RETCODE_OK) { printf("finalize_instance error %d\n", retcode); status = -1; } */ return status; }
int dds_domainparticipant_delete( dds_entity_t pp) { int result; result = DDS_DomainParticipant_delete_contained_entities(pp); if (result == DDS_RETCODE_OK) { DDS_DomainParticipantFactory factory = DDS_DomainParticipantFactory_get_instance(); result = DDS_DomainParticipantFactory_delete_participant(factory, pp); } return DDS_ERRNO(result, DDS_MOD_KERNEL, DDS_ERR_Mx); }
/* Deletes the domain participant and the rest of the entities that it contains. */ void delete_node(void) { error = DDS_DomainParticipant_delete_contained_entities (part); if (verbose) printf ("delete_node() DDS Entities deleted (error = %u).\r\n", error); delete_types(); if (verbose) printf ("delete_node() types deleted.\r\n"); error = DDS_DomainParticipantFactory_delete_participant (part); if (verbose) printf ("delete_node() DDS Participant deleted (error = %u).\r\n", error); }
static void make_state_reader () { DDS_DataReaderQos rd_qos; DDS_ReturnCode_t error; printf ("Create Reader\r\n"); /* === Create a subscriber === */ sub = DDS_DomainParticipant_create_subscriber (part, 0, NULL, 0); if (!sub) { fatal ("DDS_DomainParticipant_create_subscriber () returned an error!"); DDS_DomainParticipantFactory_delete_participant (part); } /* Test get_qos() fynctionality. */ if ((error = DDS_Subscriber_get_qos (sub, &sqos)) != DDS_RETCODE_OK) fatal ("DDS_Subscriber_get_qos () failed (%s)!", DDS_error (error)); /* Setup reader QoS parameters. */ DDS_Subscriber_get_default_datareader_qos (sub, &rd_qos); /* === create the reader === */ rd_qos.history.kind = DDS_KEEP_LAST_HISTORY_QOS; rd_qos.history.depth = 1; rd_qos.reliability.kind = DDS_RELIABLE_RELIABILITY_QOS; rd_qos.durability.kind = DDS_TRANSIENT_LOCAL_DURABILITY_QOS; rd_qos.ownership.kind = DDS_EXCLUSIVE_OWNERSHIP_QOS; dr = DDS_Subscriber_create_datareader (sub, topic_desc, &rd_qos, NULL, sm); if (!dr) fatal ("DDS_DomainParticipant_create_datareader () returned an error!"); DDS_DataReaderListener *l = DDS_DataReader_get_listener(dr); if (NULL != l) { l->on_data_available = dr_listener_data_available; error = DDS_DataReader_set_listener(dr, l, DDS_DATA_AVAILABLE_STATUS); } error = DDS_DataReader_enable(dr); /* === end program === */ if (test == 3) return; if (!writer) while (1) sleep (1); }
/* Delete all entities */ static int publisher_shutdown(DDS_DomainParticipant *participant, struct DDS_PublisherQos *publisher_qos, struct DDS_DataWriterQos *datawriter_qos) { DDS_ReturnCode_t retcode; int status = 0; if (participant != NULL) { retcode = DDS_DomainParticipant_delete_contained_entities(participant); if (retcode != DDS_RETCODE_OK) { printf("delete_contained_entities error %d\n", retcode); status = -1; } retcode = DDS_DomainParticipantFactory_delete_participant( DDS_TheParticipantFactory, participant); if (retcode != DDS_RETCODE_OK) { printf("delete_participant error %d\n", retcode); status = -1; } } retcode = DDS_PublisherQos_finalize(publisher_qos); if (retcode != DDS_RETCODE_OK) { printf("PublisherQos_finalize error %d\n", retcode); status = -1; } retcode = DDS_DataWriterQos_finalize(datawriter_qos); if (retcode != DDS_RETCODE_OK) { printf("DataWriterQos_finalize error %d\n", retcode); status = -1; } /* RTI Connext provides finalize_instance() method on domain participant factory for people who want to release memory used by the participant factory. Uncomment the following block of code for clean destruction of the singleton. */ /* retcode = DDS_DomainParticipantFactory_finalize_instance(); if (retcode != DDS_RETCODE_OK) { printf("finalize_instance error %d\n", retcode); status = -1; } */ return status; }
/* Delete all entities */ static int publisher_shutdown( DDS_DomainParticipant *participant) { DDS_ReturnCode_t retcode; int status = 0; if (participant != NULL) { retcode = DDS_DomainParticipant_delete_contained_entities(participant); if (retcode != DDS_RETCODE_OK) { printf("delete_contained_entities error %d\n", retcode); status = -1; } retcode = DDS_DomainParticipantFactory_delete_participant( DDS_TheParticipantFactory, participant); if (retcode != DDS_RETCODE_OK) { printf("delete_participant error %d\n", retcode); status = -1; } } /* RTI Data Distribution Service provides finalize_instance() method on domain participant factory and finalize() method on type support for people who want to release memory used by the participant factory and type support singletons. Uncomment the following block of code for clean destruction of the singletons. */ /* numbersTypeSupport_finalize(); retcode = DDS_DomainParticipantFactory_finalize_instance(); if (retcode != DDS_RETCODE_OK) { printf("finalize_instance error %d\n", retcode); status = -1; } */ return status; }
int main (int argc, char ** argv) #endif { /* Generic DDS entities */ DDS_DomainParticipant participant; DDS_Topic chatMessageTopic; DDS_Topic nameServiceTopic; DDS_Subscriber chatSubscriber; DDS_QueryCondition singleUser; DDS_ReadCondition newUser; DDS_StatusCondition leftUser; DDS_GuardCondition guard; DDS_WaitSet userLoadWS; DDS_LivelinessChangedStatus livChangStatus; /* QosPolicy holders */ DDS_TopicQos *setting_topic_qos; DDS_TopicQos *reliable_topic_qos; DDS_SubscriberQos *sub_qos; DDS_DataReaderQos *message_qos; /* DDS Identifiers */ DDS_DomainId_t domain = NULL; DDS_ReturnCode_t status; DDS_ConditionSeq *guardList = NULL; DDS_Duration_t timeout = DDS_DURATION_INFINITE; /* Type-specific DDS entities */ Chat_ChatMessageTypeSupport chatMessageTS; Chat_NameServiceTypeSupport nameServiceTS; Chat_NameServiceDataReader nameServer; Chat_ChatMessageDataReader loadAdmin; DDS_sequence_Chat_ChatMessage msgList = { 0, 0, DDS_OBJECT_NIL, FALSE }; DDS_sequence_Chat_NameService nsList = { 0, 0, DDS_OBJECT_NIL, FALSE }; DDS_SampleInfoSeq infoSeq = { 0, 0, DDS_OBJECT_NIL, FALSE }; DDS_SampleInfoSeq infoSeq2 = { 0, 0, DDS_OBJECT_NIL, FALSE }; /* Others */ DDS_StringSeq args; int closed = 0; DDS_unsigned_long i, j; DDS_long prevCount = 0; char *partitionName; char *chatMessageTypeName = NULL; char *nameServiceTypeName = NULL; pthread_t tid; pthread_attr_t tattr; printf("Starting UserLoad example.\n"); fflush(stdout); /* Create a DomainParticipant (using the 'TheParticipantFactory' convenience macro). */ participant = DDS_DomainParticipantFactory_create_participant ( DDS_TheParticipantFactory, domain, DDS_PARTICIPANT_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); checkHandle(participant, "DDS_DomainParticipantFactory_create_participant"); /* Register the required datatype for ChatMessage. */ chatMessageTS = Chat_ChatMessageTypeSupport__alloc(); checkHandle(chatMessageTS, "Chat_ChatMessageTypeSupport__alloc"); chatMessageTypeName = Chat_ChatMessageTypeSupport_get_type_name(chatMessageTS); status = Chat_ChatMessageTypeSupport_register_type( chatMessageTS, participant, chatMessageTypeName); checkStatus(status, "Chat_ChatMessageTypeSupport_register_type"); /* Register the required datatype for NameService. */ nameServiceTS = Chat_NameServiceTypeSupport__alloc(); checkHandle(nameServiceTS, "Chat_NameServiceTypeSupport__alloc"); nameServiceTypeName = Chat_NameServiceTypeSupport_get_type_name(nameServiceTS); status = Chat_NameServiceTypeSupport_register_type( nameServiceTS, participant, nameServiceTypeName); checkStatus(status, "Chat_NameServiceTypeSupport_register_type"); /* Set the ReliabilityQosPolicy to RELIABLE. */ reliable_topic_qos = DDS_TopicQos__alloc(); checkHandle(reliable_topic_qos, "DDS_TopicQos__alloc"); status = DDS_DomainParticipant_get_default_topic_qos(participant, reliable_topic_qos); checkStatus(status, "DDS_DomainParticipant_get_default_topic_qos"); reliable_topic_qos->reliability.kind = DDS_RELIABLE_RELIABILITY_QOS; /* Make the tailored QoS the new default. */ status = DDS_DomainParticipant_set_default_topic_qos(participant, reliable_topic_qos); checkStatus(status, "DDS_DomainParticipant_set_default_topic_qos"); /* Use the changed policy when defining the ChatMessage topic */ chatMessageTopic = DDS_DomainParticipant_create_topic( participant, "Chat_ChatMessage", chatMessageTypeName, reliable_topic_qos, NULL, DDS_STATUS_MASK_NONE); checkHandle(chatMessageTopic, "DDS_DomainParticipant_create_topic (ChatMessage)"); /* Set the DurabilityQosPolicy to TRANSIENT. */ setting_topic_qos = DDS_TopicQos__alloc(); checkHandle(setting_topic_qos, "DDS_TopicQos__alloc"); status = DDS_DomainParticipant_get_default_topic_qos(participant, setting_topic_qos); checkStatus(status, "DDS_DomainParticipant_get_default_topic_qos"); setting_topic_qos->durability.kind = DDS_TRANSIENT_DURABILITY_QOS; /* Create the NameService Topic. */ nameServiceTopic = DDS_DomainParticipant_create_topic( participant, "Chat_NameService", nameServiceTypeName, setting_topic_qos, NULL, DDS_STATUS_MASK_NONE); checkHandle(nameServiceTopic, "DDS_DomainParticipant_create_topic"); /* Adapt the default SubscriberQos to read from the "ChatRoom" Partition. */ partitionName = "ChatRoom"; sub_qos = DDS_SubscriberQos__alloc(); checkHandle(sub_qos, "DDS_SubscriberQos__alloc"); status = DDS_DomainParticipant_get_default_subscriber_qos (participant, sub_qos); checkStatus(status, "DDS_DomainParticipant_get_default_subscriber_qos"); sub_qos->partition.name._length = 1; sub_qos->partition.name._maximum = 1; sub_qos->partition.name._buffer = DDS_StringSeq_allocbuf (1); checkHandle(sub_qos->partition.name._buffer, "DDS_StringSeq_allocbuf"); sub_qos->partition.name._buffer[0] = DDS_string_alloc (strlen(partitionName) + 1); checkHandle(sub_qos->partition.name._buffer[0], "DDS_string_alloc"); strcpy (sub_qos->partition.name._buffer[0], partitionName); /* Create a Subscriber for the UserLoad application. */ chatSubscriber = DDS_DomainParticipant_create_subscriber(participant, sub_qos, NULL, DDS_STATUS_MASK_NONE); checkHandle(chatSubscriber, "DDS_DomainParticipant_create_subscriber"); /* Create a DataReader for the NameService Topic (using the appropriate QoS). */ nameServer = DDS_Subscriber_create_datareader( chatSubscriber, nameServiceTopic, DDS_DATAREADER_QOS_USE_TOPIC_QOS, NULL, DDS_STATUS_MASK_NONE); checkHandle(nameServer, "DDS_Subscriber_create_datareader (NameService)"); /* Adapt the DataReaderQos for the ChatMessageDataReader to keep track of all messages. */ message_qos = DDS_DataReaderQos__alloc(); checkHandle(message_qos, "DDS_DataReaderQos__alloc"); status = DDS_Subscriber_get_default_datareader_qos(chatSubscriber, message_qos); checkStatus(status, "DDS_Subscriber_get_default_datareader_qos"); status = DDS_Subscriber_copy_from_topic_qos(chatSubscriber, message_qos, reliable_topic_qos); checkStatus(status, "DDS_Subscriber_copy_from_topic_qos"); message_qos->history.kind = DDS_KEEP_ALL_HISTORY_QOS; /* Create a DataReader for the ChatMessage Topic (using the appropriate QoS). */ loadAdmin = DDS_Subscriber_create_datareader( chatSubscriber, chatMessageTopic, message_qos, NULL, DDS_STATUS_MASK_NONE); checkHandle(loadAdmin, "DDS_Subscriber_create_datareader (ChatMessage)"); /* Initialize the Query Arguments. */ args._length = 1; args._maximum = 1; args._buffer = DDS_StringSeq_allocbuf(1); checkHandle(args._buffer, "DDS_StringSeq_allocbuf"); args._buffer[0] = DDS_string_alloc (12); /* Enough for maximum size numbers. */ checkHandle(args._buffer[0], "DDS_string_alloc"); sprintf(args._buffer[0], "%d", 0); /* Create a QueryCondition that will contain all messages with userID=ownID */ singleUser = DDS_DataReader_create_querycondition( loadAdmin, DDS_ANY_SAMPLE_STATE, DDS_ANY_VIEW_STATE, DDS_ANY_INSTANCE_STATE, "userID=%0", &args); checkHandle(singleUser, "DDS_DataReader_create_querycondition (singleUser Query)"); /* Create a ReadCondition that will contain new users only */ newUser = DDS_DataReader_create_readcondition( nameServer, DDS_NOT_READ_SAMPLE_STATE, DDS_NEW_VIEW_STATE, DDS_ALIVE_INSTANCE_STATE); checkHandle(newUser, "DDS_DataReader_create_readcondition (newUser)"); /* Obtain a StatusCondition that triggers only when a Writer changes Liveliness */ leftUser = DDS_DataReader_get_statuscondition(loadAdmin); checkHandle(leftUser, "DDS_DataReader_get_statuscondition"); status = DDS_StatusCondition_set_enabled_statuses(leftUser, DDS_LIVELINESS_CHANGED_STATUS); checkStatus(status, "DDS_StatusCondition_set_enabled_statuses"); /* Create a bare guard which will be used to close the room */ escape = DDS_GuardCondition__alloc(); checkHandle(escape, "DDS_GuardCondition__alloc"); /* Create a waitset and add the ReadConditions */ userLoadWS = DDS_WaitSet__alloc(); checkHandle(userLoadWS, "DDS_WaitSet__alloc"); status = DDS_WaitSet_attach_condition(userLoadWS, newUser); checkStatus(status, "DDS_WaitSet_attach_condition (newUser)"); status = DDS_WaitSet_attach_condition(userLoadWS, leftUser); checkStatus(status, "DDS_WaitSet_attach_condition (leftUser)"); status = DDS_WaitSet_attach_condition(userLoadWS, escape); checkStatus(status, "DDS_WaitSet_attach_condition (escape)"); /* Initialize and pre-allocate the GuardList used to obtain the triggered Conditions. */ guardList = DDS_ConditionSeq__alloc(); checkHandle(guardList, "DDS_ConditionSeq__alloc"); guardList->_maximum = 3; guardList->_length = 0; guardList->_buffer = DDS_ConditionSeq_allocbuf(3); checkHandle(guardList->_buffer, "DDS_ConditionSeq_allocbuf"); /* Remove all known Users that are not currently active. */ status = Chat_NameServiceDataReader_take( nameServer, &nsList, &infoSeq, DDS_LENGTH_UNLIMITED, DDS_ANY_SAMPLE_STATE, DDS_ANY_VIEW_STATE, DDS_NOT_ALIVE_INSTANCE_STATE); checkStatus(status, "Chat_NameServiceDataReader_take"); status = Chat_NameServiceDataReader_return_loan(nameServer, &nsList, &infoSeq); checkStatus(status, "Chat_NameServiceDataReader_return_loan"); /* Start the sleeper thread. */ pthread_attr_init(&tattr); pthread_attr_setdetachstate(&tattr, PTHREAD_CREATE_DETACHED); pthread_create (&tid, &tattr, delayedEscape, NULL); pthread_attr_destroy(&tattr); while (!closed) { /* Wait until at least one of the Conditions in the waitset triggers. */ status = DDS_WaitSet_wait(userLoadWS, guardList, &timeout); checkStatus(status, "DDS_WaitSet_wait"); /* Walk over all guards to display information */ for (i = 0; i < guardList->_length; i++) { guard = guardList->_buffer[i]; if (guard == newUser) { /* The newUser ReadCondition contains data */ status = Chat_NameServiceDataReader_read_w_condition( nameServer, &nsList, &infoSeq, DDS_LENGTH_UNLIMITED, newUser); checkStatus(status, "Chat_NameServiceDataReader_read_w_condition"); for (j = 0; j < nsList._length; j++) { printf ("New user: %s\n", nsList._buffer[j].name); } status = Chat_NameServiceDataReader_return_loan(nameServer, &nsList, &infoSeq); checkStatus(status, "Chat_NameServiceDataReader_return_loan"); } else if (guard == leftUser) { /* Some liveliness has changed (either a DataWriter joined or a DataWriter left) */ status = DDS_DataReader_get_liveliness_changed_status(loadAdmin, &livChangStatus); checkStatus(status, "DDS_DataReader_get_liveliness_changed_status"); if (livChangStatus.alive_count < prevCount) { /* A user has left the ChatRoom, since a DataWriter lost its liveliness */ /* Take the effected users so tey will not appear in the list later on. */ status = Chat_NameServiceDataReader_take( nameServer, &nsList, &infoSeq, DDS_LENGTH_UNLIMITED, DDS_ANY_SAMPLE_STATE, DDS_ANY_VIEW_STATE, DDS_NOT_ALIVE_NO_WRITERS_INSTANCE_STATE); checkStatus(status, "Chat_NameServiceDataReader_take"); for (j = 0; j < nsList._length; j++) { /* re-apply query arguments */ sprintf(args._buffer[0], "%d", nsList._buffer[j].userID); status = DDS_QueryCondition_set_query_parameters(singleUser, &args); checkStatus(status, "DDS_QueryCondition_set_query_parameters"); /* Read this users history */ status = Chat_ChatMessageDataReader_take_w_condition( loadAdmin, &msgList, &infoSeq2, DDS_LENGTH_UNLIMITED, singleUser); checkStatus(status, "Chat_ChatMessageDataReader_take_w_condition"); /* Display the user and his history */ printf ( "Departed user %s has sent %d messages\n", nsList._buffer[j].name, msgList._length); status = Chat_ChatMessageDataReader_return_loan(loadAdmin, &msgList, &infoSeq2); checkStatus(status, "Chat_ChatMessageDataReader_return_loan"); } status = Chat_NameServiceDataReader_return_loan(nameServer, &nsList, &infoSeq); checkStatus(status, "Chat_NameServiceDataReader_return_loan"); } prevCount = livChangStatus.alive_count; } else if (guard == escape) { printf ("UserLoad has terminated.\n"); closed = 1; } else { assert(0); }; } /* for */ } /* while (!closed) */ /* Remove all Conditions from the WaitSet. */ status = DDS_WaitSet_detach_condition(userLoadWS, escape); checkStatus(status, "DDS_WaitSet_detach_condition (escape)"); status = DDS_WaitSet_detach_condition(userLoadWS, leftUser); checkStatus(status, "DDS_WaitSet_detach_condition (leftUser)"); status = DDS_WaitSet_detach_condition(userLoadWS, newUser); checkStatus(status, "DDS_WaitSet_detach_condition (newUser)"); /* Free all resources */ DDS_free(guardList); DDS_free(args._buffer); DDS_free(userLoadWS); DDS_free(escape); DDS_free(setting_topic_qos); DDS_free(reliable_topic_qos); DDS_free(nameServiceTypeName); DDS_free(chatMessageTypeName); DDS_free(nameServiceTS); DDS_free(chatMessageTS); status = DDS_DomainParticipant_delete_contained_entities(participant); checkStatus(status, "DDS_DomainParticipant_delete_contained_entities"); status = DDS_DomainParticipantFactory_delete_participant( DDS_TheParticipantFactory, participant); checkStatus(status, "DDS_DomainParticipantFactory_delete_participant"); return 0; }
int main (int argc, char *argv []) { int domain_id = 128; DDS_ReturnCode_t error; do_switches (argc, argv); #ifdef DDS_DEBUG DDS_Debug_start (); #endif DDS_set_generate_callback (calculate_member_id); sem_init(&_sync, 0, 0); part = DDS_DomainParticipantFactory_create_participant (domain_id, NULL, NULL, 0); if (!part) fatal ("DDS_DomainParticipantFactory_create_participant () failed!"); if (tsm_type == 0) { error = register_HelloWorldData_type (part); if (error) { DDS_DomainParticipantFactory_delete_participant (part); fatal ("DDS_DomainParticipant_register_type ('HelloWorldData') failed (%s)!", DDS_error (error)); } sm = DDS_INCONSISTENT_TOPIC_STATUS; topic = DDS_DomainParticipant_create_topic (part, "HelloWorld", "HelloWorldData", NULL, NULL, sm); if (!topic) { DDS_DomainParticipantFactory_delete_participant (part); fatal ("DDS_DomainParticipant_create_topic ('HelloWorld') failed!"); } topic_desc = DDS_DomainParticipant_lookup_topicdescription (part, "HelloWorld"); if (!topic_desc) { DDS_DomainParticipantFactory_delete_participant (part); fatal ("Unable to create topic description for 'HelloWorld'!"); } } else { _tsm_types[0].flags |= TSMFLAG_KEY; error = register_TestType_type (part); if (error) { DDS_DomainParticipantFactory_delete_participant (part); fatal ("DDS_DomainParticipant_register_type ('HelloWorldData') failed (%s)!", DDS_error (error)); } sm = DDS_INCONSISTENT_TOPIC_STATUS; topic = DDS_DomainParticipant_create_topic (part, _tsm_types->name, _tsm_types->name, NULL, NULL, sm); if (!topic) { DDS_DomainParticipantFactory_delete_participant (part); fatal ("DDS_DomainParticipant_create_topic ('%s') failed!", _tsm_types->name); } topic_desc = DDS_DomainParticipant_lookup_topicdescription (part, _tsm_types->name); if (!topic_desc) { DDS_DomainParticipantFactory_delete_participant (part); fatal ("Unable to create topic description for '%s'!", _tsm_types->name); } } if (test == 3) { /* interop test */ make_state_reader (); make_state_writer (key); } else { if (reader) make_state_reader (); if (writer) make_state_writer (key); } if (reader) remove_state_reader (); if (writer) remove_state_writer (); if (test == 3) { remove_state_reader (); remove_state_writer (); } error = DDS_DomainParticipant_delete_topic (part, topic); if (error) fatal ("DDS_DomainParticipant_delete_topic () failed (%s)!", DDS_error (error)); free_HelloWorldData_type (part); error = DDS_DomainParticipant_delete_contained_entities (part); if (error) fatal ("DDS_DomainParticipant_delete_contained_entities () failed (%s)!", DDS_error (error)); error = DDS_DomainParticipantFactory_delete_participant (part); if (error) fatal ("DDS_DomainParticipantFactory_delete_participant () failed (%s)!", DDS_error (error)); return (0); }
static void make_state_writer (int id) { DDS_DataWriterQos wr_qos; DDS_ReturnCode_t error; static DDS_InstanceHandle_t handle; MsgData_t data; printf ("Create Writer\r\n"); /* === create publisher === */ pub = DDS_DomainParticipant_create_publisher (part, NULL, NULL, 0); if (!pub) { fatal ("DDS_DomainParticipant_create_publisher () failed!"); DDS_DomainParticipantFactory_delete_participant (part); } /* Test get_qos() fynctionality. */ if ((error = DDS_Publisher_get_qos (pub, &pqos)) != DDS_RETCODE_OK) fatal ("DDS_Publisher_get_qos () failed (%s)!", DDS_error (error)); /* Setup writer QoS parameters. */ DDS_Publisher_get_default_datawriter_qos (pub, &wr_qos); /* === create the writer === */ wr_qos.history.kind = DDS_KEEP_LAST_HISTORY_QOS; wr_qos.history.depth = 1; wr_qos.reliability.kind = DDS_RELIABLE_RELIABILITY_QOS; wr_qos.durability.kind = DDS_TRANSIENT_LOCAL_DURABILITY_QOS; wr_qos.ownership.kind = DDS_EXCLUSIVE_OWNERSHIP_QOS; dw = DDS_Publisher_create_datawriter (pub, topic, &wr_qos, NULL, sm); if (!dw) { fatal ("Unable to create a writer \r\n"); DDS_DomainParticipantFactory_delete_participant (part); } /* === While true, add sample, remove sample === */ if (tsm_type == 0) { data.key = id; data.counter = 100 + id; strcpy (data.message, "Hi folks!"); if (test == 3) { printf ("Register instance\r\n"); DDS_DataWriter_register_instance (dw, &data); printf ("Write data\r\n"); if ((error = DDS_DataWriter_write (dw, &data, DDS_HANDLE_NIL))) printf ("Error writing data\r\n"); sleep (5); sem_wait (&_sync); sem_wait (&_sync); printf ("Unregister instance\r\n"); if ((error = DDS_DataWriter_unregister_instance(dw, &data, DDS_HANDLE_NIL))) printf ("Error unregistering instance\r\n"); sleep (5); sem_wait (&_sync); sem_wait (&_sync); return; } } else { if (test == 3) { _types1.i8 = key; printf ("Register instance\r\n"); DDS_DataWriter_register_instance (dw, &_types1); printf ("Write data\r\n"); if ((error = DDS_DataWriter_write (dw, &_types1, DDS_HANDLE_NIL))) printf ("Error writing data\r\n"); sleep (5); sem_wait (&_sync); sem_wait (&_sync); printf ("Unregister instance\r\n"); if ((error = DDS_DataWriter_unregister_instance(dw, &_types1, DDS_HANDLE_NIL))) printf ("Error unregistering instance\r\n"); sleep (5); sem_wait (&_sync); sem_wait (&_sync); return; } } if (test == 0) { printf ("Register instance\r\n"); DDS_DataWriter_register_instance (dw, &data); printf ("Write data\r\n"); if ((error = DDS_DataWriter_write (dw, &data, DDS_HANDLE_NIL))) printf ("Error writing data\r\n"); sleep (2); printf ("Unregister instance\r\n"); if ((error = DDS_DataWriter_unregister_instance(dw, &data, DDS_HANDLE_NIL))) printf ("Error unregistering instance\r\n"); sleep (2); if (reader) remove_state_reader (); } else if (test >= 1) { while (1) { printf ("Register instance\r\n"); handle = DDS_DataWriter_register_instance (dw, &data); printf ("Write data\r\n"); if ((error = DDS_DataWriter_write (dw, &data, handle))) printf ("Error writing data\r\n"); sleep (1); if (test == 1) { printf ("Unregister instance\r\n"); if ((error = DDS_DataWriter_unregister_instance(dw, &data, handle))) printf ("Error unregistering instance\r\n"); } else { printf ("Dispose instance\r\n"); if ((error = DDS_DataWriter_dispose (dw, &data, handle))) printf ("Error disposing instance\r\n"); } sleep (1); } } }
static void test_listener (void) { DDS_DomainParticipant p; DDS_Topic t; DDS_TopicDescription td; DDS_Subscriber sub; DDS_DataReader dr; DDS_DataReaderListener *lp; DDS_ReturnCode_t r; p = DDS_DomainParticipantFactory_create_participant (0, DDS_PARTICIPANT_QOS_DEFAULT, NULL, 0); fail_unless (p != NULL); r = register_HelloWorldData_type (p); fail_unless (r == DDS_RETCODE_OK); t = DDS_DomainParticipant_create_topic (p, "HelloWorld", TYPE_NAME, DDS_TOPIC_QOS_DEFAULT, NULL, 0); fail_unless (t != NULL); td = DDS_DomainParticipant_lookup_topicdescription (p, "HelloWorld"); fail_unless (td != NULL); sub = DDS_DomainParticipant_create_subscriber (p, DDS_SUBSCRIBER_QOS_DEFAULT, NULL, 0); fail_unless (sub != NULL); v_printf (" - Test reader listener.\r\n"); dr = DDS_Subscriber_create_datareader (sub, td, DDS_DATAREADER_QOS_DEFAULT, NULL, 0); fail_unless (dr != NULL); lp = DDS_DataReader_get_listener (dr); fail_unless (lp != NULL && lp->on_sample_rejected == NULL && lp->on_liveliness_changed == NULL && lp->on_requested_deadline_missed == NULL && lp->on_requested_incompatible_qos == NULL && lp->on_data_available == NULL && lp->on_subscription_matched == NULL && lp->on_sample_lost == NULL); v_printf (" - Test specific reader listener updates.\r\n"); r = DDS_DataReader_set_listener (dr, &r_listener, DDS_SAMPLE_REJECTED_STATUS | DDS_LIVELINESS_CHANGED_STATUS | DDS_REQUESTED_DEADLINE_MISSED_STATUS | DDS_REQUESTED_INCOMPATIBLE_QOS_STATUS | DDS_DATA_AVAILABLE_STATUS | DDS_SUBSCRIPTION_MATCHED_STATUS | DDS_SAMPLE_LOST_STATUS); fail_unless (r == DDS_RETCODE_OK); lp = DDS_DataReader_get_listener (dr); fail_unless (lp != NULL && lp->on_sample_rejected == sample_rejected && lp->on_liveliness_changed == liveliness_changed && lp->on_requested_deadline_missed == requested_deadline_missed && lp->on_requested_incompatible_qos == requested_inc_qos && lp->on_data_available == data_available && lp->on_subscription_matched == subscription_matched && lp->on_sample_lost == sample_lost && lp->cookie == (void *) 0x44556677); v_printf (" - Test default reader listener update.\r\n"); r = DDS_DataReader_set_listener (dr, NULL, DDS_REQUESTED_DEADLINE_MISSED_STATUS); fail_unless (r == DDS_RETCODE_OK); lp = DDS_DataReader_get_listener (dr); fail_unless (lp != NULL && lp->on_sample_rejected == NULL && lp->on_liveliness_changed == NULL && lp->on_requested_deadline_missed == NULL && lp->on_requested_incompatible_qos == NULL && lp->on_data_available == NULL && lp->on_subscription_matched == NULL && lp->on_sample_lost == NULL); r = DDS_Subscriber_delete_datareader (sub, dr); fail_unless (r == DDS_RETCODE_OK); r = DDS_DomainParticipant_delete_subscriber (p, sub); fail_unless (r == DDS_RETCODE_OK); r = DDS_DomainParticipant_delete_topic (p, t); fail_unless (r == DDS_RETCODE_OK); unregister_HelloWorldData_type (p); r = DDS_DomainParticipantFactory_delete_participant (p); fail_unless (r == DDS_RETCODE_OK); }
int main ( int argc, char *argv[]) { DDS_DomainParticipantFactory dpf; DDS_DomainParticipant dp; DDS_DomainId_t domain = DDS_DOMAIN_ID_DEFAULT; DDS_ReturnCode_t status; Chat_ChatMessageTypeSupport chatMessageTS; DDS_Topic chatMessageTopic; char *chatMessageTypeName; /* Create a DomainParticipantFactory and a DomainParticipant */ /* (using Default QoS settings). */ dpf = DDS_DomainParticipantFactory_get_instance(); if (!dpf) { printf("Creating ParticipantFactory failed!!\n"); exit(-1); } printf("Created ParticipantFactory.\n"); dp = DDS_DomainParticipantFactory_create_participant ( dpf, domain, DDS_PARTICIPANT_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); if (!dp) { printf("Creating Participant failed!!\n"); exit(-1); } printf("Created Participant.\n"); /* Register the required data type for ChatMessage. */ chatMessageTS = Chat_ChatMessageTypeSupport__alloc(); if (!chatMessageTS) { printf ("Allocating TypeSupport failed!!\n"); exit(-1); }; chatMessageTypeName = Chat_ChatMessageTypeSupport_get_type_name(chatMessageTS); status = Chat_ChatMessageTypeSupport_register_type( chatMessageTS, dp, chatMessageTypeName); if (status != DDS_RETCODE_OK) { printf("Registering data type failed. Status = %d\n", status); exit(-1); }; printf("Registered data type.\n"); /*Create the ChatMessage topic */ chatMessageTopic = DDS_DomainParticipant_create_topic( dp, "Chat_ChatMessage", chatMessageTypeName, DDS_TOPIC_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); if (!chatMessageTopic) { printf("Creating ChatMessage topic failed!!\n"); exit(-1); }; printf("Created ChatMessage topic.\n"); DDS_PublisherQos *pub_qos; DDS_DataWriterQos *dw_qos; DDS_Publisher chatPublisher; Chat_ChatMessageDataWriter talker; Chat_NameServiceDataWriter nameServer; char *partitionName = NULL; DDS_Topic nameServiceTopic; /* Adapt the default PublisherQos to write into the "ChatRoom" Partition. */ partitionName = "ChatRoom"; pub_qos = DDS_PublisherQos__alloc(); if (!pub_qos) { printf("Allocating PublisherQos failed!!\n"); exit(-1); } status = DDS_DomainParticipant_get_default_publisher_qos ( dp, pub_qos); if (status != DDS_RETCODE_OK) { printf("Getting default publisher qos failed!!\n"); exit(-1); } pub_qos->partition.name._length = 1; pub_qos->partition.name._maximum = 1; pub_qos->partition.name._buffer = DDS_StringSeq_allocbuf (1); if (!pub_qos->partition.name._buffer) { printf("Allocating partition name failed!!\n"); exit(-1); } pub_qos->partition.name._buffer[0] = DDS_string_alloc ( strlen(partitionName)); if (!pub_qos->partition.name._buffer[0]) { printf("Allocating partition name failed!!\n"); exit(-1); } strcpy (pub_qos->partition.name._buffer[0], partitionName); /* Create a Publisher for the chatter application. */ chatPublisher = DDS_DomainParticipant_create_publisher( dp, pub_qos, NULL, DDS_STATUS_MASK_NONE); if (!chatPublisher) { printf("Creating publisher failed!!\n"); exit(-1); } printf("Created publisher.\n"); /* Create a DataWriter for the ChatMessage Topic (using the appropriate QoS). */ talker = DDS_Publisher_create_datawriter( chatPublisher, chatMessageTopic, DDS_DATAWRITER_QOS_USE_TOPIC_QOS, NULL, DDS_STATUS_MASK_NONE); if (!talker) { printf("Creating datawriter failed!!\n"); exit(-1); } printf("Created datawriter.\n"); // Initialize message int ownID = 0; Chat_ChatMessage *msg; msg = Chat_ChatMessage__alloc(); //checkHandle(msg, "Chat_ChatMessage__alolc"); msg->userID = ownID; msg->index = 0; msg->content = DDS_string_alloc(MAX_MSG_LEN); //checkHandle(msg->content, "DDS_string_alloc"); snprintf(msg->content, MAX_MSG_LEN, "hello world"); // register a chat message DDS_InstanceHandle_t userHandle; userHandle = Chat_ChatMessageDataWriter_register_instance(talker, msg); Chat_NameService ns; ns.userID = ownID; ns.name = DDS_string_alloc(Chat_MAX_NAME+1); //checkHandle(ns.name, "DDS_string_alloc"); char *chatterName; if (chatterName) { strncpy(ns.name, chatterName, Chat_MAX_NAME + 1); } else { snprintf(ns.name, Chat_MAX_NAME+1, "Chatter %d", ownID); } // Write user information status = Chat_NameServiceDataWriter_write(nameServer, &ns, DDS_HANDLE_NIL); //checkStatus(status, "Chat_ChatMessageDataWriter_write"); // Write a message status = Chat_ChatMessageDataWriter_write(talker, msg, userHandle); // checkStatus(status, "Chat_ChatMessageDataWriter_write"); // pause sleep(1); int i = 0; for (i = 1; i < 6; ++i) { msg->index = i; snprintf(msg->content, MAX_MSG_LEN, "Message number: %d", msg->index); status = Chat_ChatMessageDataWriter_write(talker, msg, userHandle); // checkStatus(status, "Chat_ChatMessageDataWriter_write"); sleep(1); } /* Remove the DataWriters */ status = DDS_Publisher_delete_datawriter(chatPublisher, talker); if (status != DDS_RETCODE_OK) { printf("Deleting datawriter failed!!\n"); exit(-1); } printf("Deleted datawriter.\n"); /*status = DDS_Publisher_delete_datawriter( chatPublisher, nameServer); if (status != DDS_RETCODE_OK) { printf("Deleting datawriter (NameService) failed!!\n"); exit(-1); } printf("Deleted datawriter (NameService).\n");*/ /* Remove the Publisher. */ status = DDS_DomainParticipant_delete_publisher( dp, chatPublisher); if (status != DDS_RETCODE_OK) { printf("Deleting publisher failed!!\n"); exit(-1); } /* De-allocate the PublisherQoS holder. */ DDS_free(pub_qos); // Note that DDS_free recursively // de-allocates all indirections!! printf("Deleted publisher.\n"); /* Deleting the Topic. */ status = DDS_DomainParticipant_delete_topic( dp, chatMessageTopic); if (status != DDS_RETCODE_OK) { printf("Deleting topic failed. Status = %d\n", status); exit(-1); }; printf("Deleted ChatMessage topic.\n"); /* Deleting the DomainParticipant */ status = DDS_DomainParticipantFactory_delete_participant( dpf, dp); if (status != DDS_RETCODE_OK) { printf("Deleting participant failed. Status = %d\n", status); exit(-1); }; printf("Deleted Participant.\n"); /* Everything is fine, return normally. */ return 0; };
int main ( int argc, char *argv[]) { DDS_DomainId_t myDomain = DDS_OBJECT_NIL; DDS_DomainParticipantFactory dpf = DDS_OBJECT_NIL; DDS_DomainParticipant dp = DDS_OBJECT_NIL; DDS_Publisher p = DDS_OBJECT_NIL; DDS_Subscriber s = DDS_OBJECT_NIL; pingpong_PP_min_msgDataWriter PP_min_writer = DDS_OBJECT_NIL; pingpong_PP_seq_msgDataWriter PP_seq_writer = DDS_OBJECT_NIL; pingpong_PP_string_msgDataWriter PP_string_writer = DDS_OBJECT_NIL; pingpong_PP_fixed_msgDataWriter PP_fixed_writer = DDS_OBJECT_NIL; pingpong_PP_array_msgDataWriter PP_array_writer = DDS_OBJECT_NIL; pingpong_PP_bseq_msgDataWriter PP_bseq_writer = DDS_OBJECT_NIL; pingpong_PP_min_msgDataReader PP_min_reader = DDS_OBJECT_NIL; pingpong_PP_seq_msgDataReader PP_seq_reader = DDS_OBJECT_NIL; pingpong_PP_string_msgDataReader PP_string_reader = DDS_OBJECT_NIL; pingpong_PP_fixed_msgDataReader PP_fixed_reader = DDS_OBJECT_NIL; pingpong_PP_array_msgDataReader PP_array_reader = DDS_OBJECT_NIL; pingpong_PP_bseq_msgDataReader PP_bseq_reader = DDS_OBJECT_NIL; pingpong_PP_quit_msgDataReader PP_quit_reader = DDS_OBJECT_NIL; pingpong_PP_min_msgTypeSupport PP_min_dt; pingpong_PP_seq_msgTypeSupport PP_seq_dt; pingpong_PP_string_msgTypeSupport PP_string_dt; pingpong_PP_fixed_msgTypeSupport PP_fixed_dt; pingpong_PP_array_msgTypeSupport PP_array_dt; pingpong_PP_bseq_msgTypeSupport PP_bseq_dt; pingpong_PP_quit_msgTypeSupport PP_quit_dt; DDS_sequence_pingpong_PP_min_msg PP_min_dataList = { 0, 0, DDS_OBJECT_NIL, FALSE }; DDS_sequence_pingpong_PP_seq_msg PP_seq_dataList = { 0, 0, DDS_OBJECT_NIL, FALSE }; DDS_sequence_pingpong_PP_string_msg PP_string_dataList = { 0, 0, DDS_OBJECT_NIL, FALSE }; DDS_sequence_pingpong_PP_fixed_msg PP_fixed_dataList = { 0, 0, DDS_OBJECT_NIL, FALSE }; DDS_sequence_pingpong_PP_array_msg PP_array_dataList = { 0, 0, DDS_OBJECT_NIL, FALSE }; DDS_sequence_pingpong_PP_bseq_msg PP_bseq_dataList = { 0, 0, DDS_OBJECT_NIL, FALSE }; DDS_sequence_pingpong_PP_quit_msg PP_quit_dataList = { 0, 0, DDS_OBJECT_NIL, FALSE }; DDS_StatusCondition PP_min_sc; DDS_StatusCondition PP_seq_sc; DDS_StatusCondition PP_string_sc; DDS_StatusCondition PP_fixed_sc; DDS_StatusCondition PP_array_sc; DDS_StatusCondition PP_bseq_sc; DDS_StatusCondition PP_quit_sc; DDS_Topic PP_min_topic = DDS_OBJECT_NIL; DDS_Topic PP_seq_topic = DDS_OBJECT_NIL; DDS_Topic PP_string_topic = DDS_OBJECT_NIL; DDS_Topic PP_fixed_topic = DDS_OBJECT_NIL; DDS_Topic PP_array_topic = DDS_OBJECT_NIL; DDS_Topic PP_bseq_topic = DDS_OBJECT_NIL; DDS_Topic PP_quit_topic = DDS_OBJECT_NIL; DDS_ConditionSeq *conditionList; DDS_SampleInfoSeq infoList = { 0, 0, DDS_OBJECT_NIL, FALSE }; DDS_WaitSet w; DDS_DomainParticipantQos *dpQos; DDS_TopicQos *tQos; DDS_PublisherQos *pQos; DDS_DataWriterQos *dwQos; DDS_SubscriberQos *sQos; DDS_DataReaderQos *drQos; DDS_boolean terminate = FALSE; DDS_ReturnCode_t result; int i; int imax; int j; int jmax; printf ("Starting pong example\n"); fflush(stdout); /* * Evaluate cmdline arguments */ #ifdef INTEGRITY read_partition = "PongRead"; write_partition = "PongWrite"; #else if (argc != 1) { if (argc != 3) { printf ("Invalid.....\n Usage: %s [READ_PARTITION WRITE_PARTITION]\n", argv[0]); exit (1); } read_partition = argv[1]; write_partition = argv[2]; } #endif /* * Create WaitSet */ w = DDS_WaitSet__alloc (); /* * Initialize Qos variables */ dpQos = DDS_DomainParticipantQos__alloc(); tQos = DDS_TopicQos__alloc(); pQos = DDS_PublisherQos__alloc(); dwQos = DDS_DataWriterQos__alloc(); sQos = DDS_SubscriberQos__alloc(); drQos = DDS_DataReaderQos__alloc(); /* * Initialize condition list */ conditionList = NULL; /* * Create participant */ dpf = DDS_DomainParticipantFactory_get_instance (); dp = DDS_DomainParticipantFactory_create_participant (dpf, myDomain, DDS_PARTICIPANT_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); if (dp == DDS_OBJECT_NIL) { printf ("%s PONG: ERROR - Splice Daemon not running\n", argv[0]); exit(1); } /* * Create PONG publisher */ DDS_DomainParticipant_get_default_publisher_qos (dp, pQos); pQos->partition.name._length = 1; pQos->partition.name._maximum = 1; pQos->partition.name._buffer = DDS_StringSeq_allocbuf (1); pQos->partition.name._buffer[0] = DDS_string_alloc (strlen (write_partition) + 1); strcpy (pQos->partition.name._buffer[0], write_partition); p = DDS_DomainParticipant_create_publisher (dp, pQos, NULL, DDS_STATUS_MASK_NONE); DDS_free (pQos); /* * Create PING subscriber */ DDS_DomainParticipant_get_default_subscriber_qos (dp, sQos); sQos->partition.name._length = 1; sQos->partition.name._maximum = 1; sQos->partition.name._buffer = DDS_StringSeq_allocbuf (1); sQos->partition.name._buffer[0] = DDS_string_alloc (strlen (read_partition) + 1); strcpy (sQos->partition.name._buffer[0], read_partition); s = DDS_DomainParticipant_create_subscriber (dp, sQos, NULL, DDS_STATUS_MASK_NONE); DDS_free (sQos); /* * PP_min_msg */ /* Create Topic */ PP_min_dt = pingpong_PP_min_msgTypeSupport__alloc (); pingpong_PP_min_msgTypeSupport_register_type (PP_min_dt, dp, "pingpong::PP_min_msg"); PP_min_topic = DDS_DomainParticipant_create_topic (dp, "PP_min_topic", "pingpong::PP_min_msg", DDS_TOPIC_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); /* Create datawriter */ PP_min_writer = DDS_Publisher_create_datawriter (p, PP_min_topic, DDS_DATAWRITER_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); /* Create datareader */ PP_min_reader = DDS_Subscriber_create_datareader (s, PP_min_topic, DDS_DATAREADER_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); /* Add datareader statuscondition to waitset */ PP_min_sc = DDS_DataReader_get_statuscondition (PP_min_reader); DDS_StatusCondition_set_enabled_statuses (PP_min_sc, DDS_DATA_AVAILABLE_STATUS); result = DDS_WaitSet_attach_condition (w, PP_min_sc); /* * PP_seq_msg */ /* Create Topic */ PP_seq_dt = pingpong_PP_seq_msgTypeSupport__alloc (); pingpong_PP_seq_msgTypeSupport_register_type (PP_seq_dt, dp, "pingpong::PP_seq_msg"); PP_seq_topic = DDS_DomainParticipant_create_topic (dp, "PP_seq_topic", "pingpong::PP_seq_msg", DDS_TOPIC_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); /* Create datawriter */ PP_seq_writer = DDS_Publisher_create_datawriter (p, PP_seq_topic, DDS_DATAWRITER_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); /* Create datareader */ PP_seq_reader = DDS_Subscriber_create_datareader (s, PP_seq_topic, DDS_DATAREADER_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); /* Add datareader statuscondition to waitset */ PP_seq_sc = DDS_DataReader_get_statuscondition (PP_seq_reader); DDS_StatusCondition_set_enabled_statuses (PP_seq_sc, DDS_DATA_AVAILABLE_STATUS); result = DDS_WaitSet_attach_condition (w, PP_seq_sc); /* * PP_string_msg */ /* Create Topic */ PP_string_dt = pingpong_PP_string_msgTypeSupport__alloc (); pingpong_PP_string_msgTypeSupport_register_type (PP_string_dt, dp, "pingpong::PP_string_msg"); PP_string_topic = DDS_DomainParticipant_create_topic (dp, "PP_string_topic", "pingpong::PP_string_msg", DDS_TOPIC_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); /* Create datawriter */ PP_string_writer = DDS_Publisher_create_datawriter (p, PP_string_topic, DDS_DATAWRITER_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); /* Create datareader */ PP_string_reader = DDS_Subscriber_create_datareader (s, PP_string_topic, DDS_DATAREADER_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); /* Add datareader statuscondition to waitset */ PP_string_sc = DDS_DataReader_get_statuscondition (PP_string_reader); DDS_StatusCondition_set_enabled_statuses (PP_string_sc, DDS_DATA_AVAILABLE_STATUS); result = DDS_WaitSet_attach_condition (w, PP_string_sc); /* * PP_fixed_msg */ /* Create Topic */ PP_fixed_dt = pingpong_PP_fixed_msgTypeSupport__alloc (); pingpong_PP_fixed_msgTypeSupport_register_type (PP_fixed_dt, dp, "pingpong::PP_fixed_msg"); PP_fixed_topic = DDS_DomainParticipant_create_topic (dp, "PP_fixed_topic", "pingpong::PP_fixed_msg", DDS_TOPIC_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); /* Create datawriter */ PP_fixed_writer = DDS_Publisher_create_datawriter (p, PP_fixed_topic, DDS_DATAWRITER_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); /* Create datareader */ PP_fixed_reader = DDS_Subscriber_create_datareader (s, PP_fixed_topic, DDS_DATAREADER_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); /* Add datareader statuscondition to waitset */ PP_fixed_sc = DDS_DataReader_get_statuscondition (PP_fixed_reader); DDS_StatusCondition_set_enabled_statuses (PP_fixed_sc, DDS_DATA_AVAILABLE_STATUS); result = DDS_WaitSet_attach_condition (w, PP_fixed_sc); /* * PP_array_msg */ /* Create Topic */ PP_array_dt = pingpong_PP_array_msgTypeSupport__alloc (); pingpong_PP_array_msgTypeSupport_register_type (PP_array_dt, dp, "pingpong::PP_array_msg"); PP_array_topic = DDS_DomainParticipant_create_topic (dp, "PP_array_topic", "pingpong::PP_array_msg", DDS_TOPIC_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); /* Create datawriter */ PP_array_writer = DDS_Publisher_create_datawriter (p, PP_array_topic, DDS_DATAWRITER_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); /* Create datareader */ PP_array_reader = DDS_Subscriber_create_datareader (s, PP_array_topic, DDS_DATAREADER_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); /* Add datareader statuscondition to waitset */ PP_array_sc = DDS_DataReader_get_statuscondition (PP_array_reader); DDS_StatusCondition_set_enabled_statuses (PP_array_sc, DDS_DATA_AVAILABLE_STATUS); result = DDS_WaitSet_attach_condition (w, PP_array_sc); /* * PP_bseq_msg */ /* Create Topic */ PP_bseq_dt = pingpong_PP_bseq_msgTypeSupport__alloc (); pingpong_PP_bseq_msgTypeSupport_register_type (PP_bseq_dt, dp, "pingpong::PP_bseq_msg"); PP_bseq_topic = DDS_DomainParticipant_create_topic (dp, "PP_bseq_topic", "pingpong::PP_bseq_msg", DDS_TOPIC_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); /* Create datawriter */ PP_bseq_writer = DDS_Publisher_create_datawriter (p, PP_bseq_topic, DDS_DATAWRITER_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); /* Create datareader */ PP_bseq_reader = DDS_Subscriber_create_datareader (s, PP_bseq_topic, DDS_DATAREADER_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); /* Add datareader statuscondition to waitset */ PP_bseq_sc = DDS_DataReader_get_statuscondition (PP_bseq_reader); DDS_StatusCondition_set_enabled_statuses (PP_bseq_sc, DDS_DATA_AVAILABLE_STATUS); result = DDS_WaitSet_attach_condition (w, PP_bseq_sc); /* * PP_quit_msg */ /* Create Topic */ PP_quit_dt = pingpong_PP_quit_msgTypeSupport__alloc (); pingpong_PP_quit_msgTypeSupport_register_type (PP_quit_dt, dp, "pingpong::PP_quit_msg"); PP_quit_topic = DDS_DomainParticipant_create_topic (dp, "PP_quit_topic", "pingpong::PP_quit_msg", DDS_TOPIC_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); /* Create datareader */ PP_quit_reader = DDS_Subscriber_create_datareader (s, PP_quit_topic, DDS_DATAREADER_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); /* Add datareader statuscondition to waitset */ PP_quit_sc = DDS_DataReader_get_statuscondition (PP_quit_reader); DDS_StatusCondition_set_enabled_statuses (PP_quit_sc, DDS_DATA_AVAILABLE_STATUS); result = DDS_WaitSet_attach_condition (w, PP_quit_sc); while (!terminate) { DDS_Duration_t wait_timeout = DDS_DURATION_INFINITE; /* printf ("PONG: waiting for PING\n"); */ conditionList = DDS_ConditionSeq__alloc(); result = DDS_WaitSet_wait (w, conditionList, &wait_timeout); if (result == DDS_RETCODE_OK) { imax = conditionList->_length; for (i = 0; i < imax; i++) { if (conditionList->_buffer[i] == PP_min_sc) { /* printf ("PONG: PING_min arrived\n"); */ result = pingpong_PP_min_msgDataReader_take (PP_min_reader, &PP_min_dataList, &infoList, DDS_LENGTH_UNLIMITED, DDS_ANY_SAMPLE_STATE, DDS_ANY_VIEW_STATE, DDS_ANY_INSTANCE_STATE); jmax = PP_min_dataList._length; if (jmax != 0) { for (j = 0; j < jmax; j++) { if (infoList._buffer[j].valid_data) { result = pingpong_PP_min_msgDataWriter_write (PP_min_writer, &PP_min_dataList._buffer[j], DDS_HANDLE_NIL); } } result = pingpong_PP_min_msgDataReader_return_loan (PP_min_reader, &PP_min_dataList, &infoList); } else { printf ("PONG: PING_min triggered, but no data available\n"); } } else if (conditionList->_buffer[i] == PP_seq_sc) { /* printf ("PONG: PING_seq arrived\n"); */ result = pingpong_PP_seq_msgDataReader_take (PP_seq_reader, &PP_seq_dataList, &infoList, DDS_LENGTH_UNLIMITED, DDS_ANY_SAMPLE_STATE, DDS_ANY_VIEW_STATE, DDS_ANY_INSTANCE_STATE); jmax = PP_seq_dataList._length; if (jmax != 0) { for (j = 0; j < jmax; j++) { if (infoList._buffer[j].valid_data) { result = pingpong_PP_seq_msgDataWriter_write (PP_seq_writer, &PP_seq_dataList._buffer[j], DDS_HANDLE_NIL); } } result = pingpong_PP_seq_msgDataReader_return_loan (PP_seq_reader, &PP_seq_dataList, &infoList); } else { printf ("PONG: PING_seq triggered, but no data available\n"); } } else if (conditionList->_buffer[i] == PP_string_sc) { /* printf ("PONG: PING_string arrived\n"); */ result = pingpong_PP_string_msgDataReader_take (PP_string_reader, &PP_string_dataList, &infoList, DDS_LENGTH_UNLIMITED, DDS_ANY_SAMPLE_STATE, DDS_ANY_VIEW_STATE, DDS_ANY_INSTANCE_STATE); jmax = PP_string_dataList._length; if (jmax != 0) { for (j = 0; j < jmax; j++) { if (infoList._buffer[j].valid_data) { result = pingpong_PP_string_msgDataWriter_write (PP_string_writer, &PP_string_dataList._buffer[j], DDS_HANDLE_NIL); } } result = pingpong_PP_string_msgDataReader_return_loan (PP_string_reader, &PP_string_dataList, &infoList); } else { printf ("PONG: PING_string triggered, but no data available\n"); exit(1); } } else if (conditionList->_buffer[i] == PP_fixed_sc) { /* printf ("PONG: PING_fixed arrived\n"); */ result = pingpong_PP_fixed_msgDataReader_take (PP_fixed_reader, &PP_fixed_dataList, &infoList, DDS_LENGTH_UNLIMITED, DDS_ANY_SAMPLE_STATE, DDS_ANY_VIEW_STATE, DDS_ANY_INSTANCE_STATE); jmax = PP_fixed_dataList._length; if (jmax != 0) { for (j = 0; j < jmax; j++) { if (infoList._buffer[j].valid_data) { result = pingpong_PP_fixed_msgDataWriter_write (PP_fixed_writer, &PP_fixed_dataList._buffer[j], DDS_HANDLE_NIL); } } result = pingpong_PP_fixed_msgDataReader_return_loan (PP_fixed_reader, &PP_fixed_dataList, &infoList); } else { printf ("PONG: PING_fixed triggered, but no data available\n"); } } else if (conditionList->_buffer[i] == PP_array_sc) { /* printf ("PONG: PING_array arrived\n"); */ result = pingpong_PP_array_msgDataReader_take (PP_array_reader, &PP_array_dataList, &infoList, DDS_LENGTH_UNLIMITED, DDS_ANY_SAMPLE_STATE, DDS_ANY_VIEW_STATE, DDS_ANY_INSTANCE_STATE); jmax = PP_array_dataList._length; if (jmax != 0) { for (j = 0; j < jmax; j++) { if (infoList._buffer[j].valid_data) { result = pingpong_PP_array_msgDataWriter_write (PP_array_writer, &PP_array_dataList._buffer[j], DDS_HANDLE_NIL); } } result = pingpong_PP_array_msgDataReader_return_loan (PP_array_reader, &PP_array_dataList, &infoList); } else { printf ("PONG: PING_array triggered, but no data available\n"); } } else if (conditionList->_buffer[i] == PP_bseq_sc) { /* printf ("PONG: PING_bseq arrived\n"); */ result = pingpong_PP_bseq_msgDataReader_take (PP_bseq_reader, &PP_bseq_dataList, &infoList, DDS_LENGTH_UNLIMITED, DDS_ANY_SAMPLE_STATE, DDS_ANY_VIEW_STATE, DDS_ANY_INSTANCE_STATE); jmax = PP_bseq_dataList._length; if (jmax != 0) { for (j = 0; j < jmax; j++) { if (infoList._buffer[j].valid_data) { result = pingpong_PP_bseq_msgDataWriter_write (PP_bseq_writer, &PP_bseq_dataList._buffer[j], DDS_HANDLE_NIL); } } result = pingpong_PP_bseq_msgDataReader_return_loan (PP_bseq_reader, &PP_bseq_dataList, &infoList); } else { printf ("PONG: PING_bseq triggered, but no data available\n"); } } else if (conditionList->_buffer[i] == PP_quit_sc) { /* printf ("PONG: PING_quit arrived\n"); */ result = pingpong_PP_quit_msgDataReader_take (PP_quit_reader, &PP_quit_dataList, &infoList, DDS_LENGTH_UNLIMITED, DDS_ANY_SAMPLE_STATE, DDS_ANY_VIEW_STATE, DDS_ANY_INSTANCE_STATE); jmax = PP_quit_dataList._length; if (jmax != 0) { if (PP_quit_dataList._buffer[0].quit) { terminate = TRUE; } result = pingpong_PP_quit_msgDataReader_return_loan (PP_quit_reader, &PP_quit_dataList, &infoList); } else { printf ("PONG: PING_quit triggered, but no data available\n"); } } else { printf ("PONG: unknown condition triggered: %lx\n", (unsigned long)conditionList->_buffer[i]); } } } else { if (result == DDS_RETCODE_ALREADY_DELETED) { terminate = TRUE; } printf ("PONG: wait returned not ok: %d\n", result); } DDS_free(conditionList); } result = DDS_Subscriber_delete_datareader (s, PP_min_reader); result = DDS_Publisher_delete_datawriter (p, PP_min_writer); result = DDS_Subscriber_delete_datareader (s, PP_seq_reader); result = DDS_Publisher_delete_datawriter (p, PP_seq_writer); result = DDS_Subscriber_delete_datareader (s, PP_string_reader); result = DDS_Publisher_delete_datawriter (p, PP_string_writer); result = DDS_Subscriber_delete_datareader (s, PP_fixed_reader); result = DDS_Publisher_delete_datawriter (p, PP_fixed_writer); result = DDS_Subscriber_delete_datareader (s, PP_array_reader); result = DDS_Publisher_delete_datawriter (p, PP_array_writer); result = DDS_Subscriber_delete_datareader (s, PP_bseq_reader); result = DDS_Publisher_delete_datawriter (p, PP_bseq_writer); result = DDS_Subscriber_delete_datareader (s, PP_quit_reader); result = DDS_DomainParticipant_delete_subscriber (dp, s); result = DDS_DomainParticipant_delete_publisher (dp, p); result = DDS_DomainParticipant_delete_topic (dp, PP_min_topic); result = DDS_DomainParticipant_delete_topic (dp, PP_seq_topic); result = DDS_DomainParticipant_delete_topic (dp, PP_string_topic); result = DDS_DomainParticipant_delete_topic (dp, PP_fixed_topic); result = DDS_DomainParticipant_delete_topic (dp, PP_array_topic); result = DDS_DomainParticipant_delete_topic (dp, PP_bseq_topic); result = DDS_DomainParticipant_delete_topic (dp, PP_quit_topic); result = DDS_DomainParticipantFactory_delete_participant (dpf, dp); DDS_free (w); DDS_free (PP_min_dt); DDS_free (PP_seq_dt); DDS_free (PP_string_dt); DDS_free (PP_fixed_dt); DDS_free (PP_array_dt); DDS_free (PP_bseq_dt); DDS_free (PP_quit_dt); DDS_free (dpQos); DDS_free (tQos); DDS_free (dwQos); DDS_free (drQos); printf ("Completed pong example\n"); fflush(stdout); return 0; }
int main() { DDS_DomainParticipant * participant = NULL; DDS_Topic * topic = NULL; DDS_DataWriter * data_writer = NULL; DDS_StringDataWriter * string_writer = NULL; DDS_ReturnCode_t retcode; char sample[MAX_STRING_SIZE]; int main_result = 1; /* error by default */ /* --- Set Up --------------------------------------------------------- */ /* Uncomment the following lines to increase the verbosity of the log * messages output by RTI Connext: NDDS_Config_Logger_set_verbosity( NDDS_Config_Logger_get_instance(), NDDS_CONFIG_LOG_VERBOSITY_STATUS_ALL ); */ /* Create the domain participant on domain ID 0 */ participant = DDS_DomainParticipantFactory_create_participant( DDS_TheParticipantFactory, 0, /* Domain ID */ &DDS_PARTICIPANT_QOS_DEFAULT, /* QoS */ NULL, /* Listener */ DDS_STATUS_MASK_NONE); if (participant == NULL) { puts("Unable to create domain participant."); goto clean_exit; } /* Create the topic "Hello, World" for the String type */ topic = DDS_DomainParticipant_create_topic( participant, "Hello, World", /* Topic name*/ DDS_StringTypeSupport_get_type_name(), /* Type name */ &DDS_TOPIC_QOS_DEFAULT, /* Topic QoS */ NULL, /* Listener */ DDS_STATUS_MASK_NONE); if (topic == NULL) { puts("Unable to create topic."); goto clean_exit; } /* Create the data writer using the default publisher */ data_writer = DDS_DomainParticipant_create_datawriter( participant, topic, &DDS_DATAWRITER_QOS_DEFAULT, /* QoS */ NULL, /* Listener */ DDS_STATUS_MASK_NONE); if (data_writer == NULL) { puts("Unable to create data writer."); goto clean_exit; } /* Perform a safe type-cast from a generic data writer into a * specific data writer for the type "DDS::String" */ string_writer = DDS_StringDataWriter_narrow(data_writer); if (string_writer == NULL) { /* In this specific case, this will never fail */ puts("DDS_StringDataWriter_narrow failed."); goto clean_exit; } /* --- Write Data ----------------------------------------------------- */ puts("Ready to write data."); puts("When the subscriber is ready, you can start writing."); puts("Press CTRL+C to terminate or enter an empty line to do a clean shutdown."); puts(""); /* RTI provides APIs for detecting when data readers and data writers * join the network. You can also configure data durability so that data * readers can receive data that were written before they started. * However, for the sake of keeping this example as simple as possible, * it asks you to wait for both sides to start before continuing. */ for (;;) { printf("Please type a message> "); if (fgets(sample, MAX_STRING_SIZE-1, stdin) == NULL) { break; } /* Removes the newline from input string */ sample[strlen(sample)-1] = '\0'; retcode = DDS_StringDataWriter_write( string_writer, sample, &DDS_HANDLE_NIL); if (retcode != DDS_RETCODE_OK) { printf("Write failed: %d\n", retcode); } if (strlen(sample) == 0) { break; } } /* --- Clean Up ------------------------------------------------------- */ main_result = 0; clean_exit: puts("Exiting..."); if (participant != NULL) { retcode = DDS_DomainParticipant_delete_contained_entities( participant); if (retcode != DDS_RETCODE_OK) { puts("Deletion failed."); main_result = 1; } retcode = DDS_DomainParticipantFactory_delete_participant( DDS_TheParticipantFactory, participant); if (retcode != DDS_RETCODE_OK) { puts("Deletion failed."); main_result = 1; } } return main_result; }
int main ( int argc, char *argv[] ) { DDS_ConditionSeq *conditionList; DDS_WaitSet w; DDS_Condition exp_condition; pong_handler *active_handler; DDS_DomainParticipantQos *dpQos; DDS_TopicQos *tQos; DDS_PublisherQos *pQos; DDS_DataWriterQos *dwQos; DDS_SubscriberQos *sQos; DDS_DataReaderQos *drQos; time_t clock = time (NULL); DDS_Duration_t wait_timeout = {3,0}; DDS_ReturnCode_t result; DDS_boolean finish_flag = FALSE; DDS_boolean timeout_flag = FALSE; DDS_boolean terminate = FALSE; int imax = 1; int i; unsigned int block; init_clock(); /* * init timing statistics */ init_stats (&roundtrip, "round_trip"); init_stats (&write_access, "write_access"); init_stats (&read_access, "read_access"); /* * Evaluate cmdline arguments */ if (argc != 1) { if (argc != 6) { printf ("Invalid.....\n Usage: %s [blocks blocksize topic_id WRITE_PARTITION READ_PARTITION]\n", argv[0]); exit (1); } nof_blocks = atoi (argv[1]); nof_cycles = atoi (argv[2]); topic_id = argv[3][0]; write_partition = argv[4]; read_partition = argv[5]; } /* * Create WaitSet */ w = DDS_WaitSet__alloc (); /* * Initialize Qos variables */ dpQos = DDS_DomainParticipantQos__alloc(); tQos = DDS_TopicQos__alloc(); pQos = DDS_PublisherQos__alloc(); dwQos = DDS_DataWriterQos__alloc(); sQos = DDS_SubscriberQos__alloc(); drQos = DDS_DataReaderQos__alloc(); /* * Initialize condition list */ conditionList = NULL; /* * Create participant */ dpf = DDS_DomainParticipantFactory_get_instance (); dp = DDS_DomainParticipantFactory_create_participant (dpf, myDomain, DDS_PARTICIPANT_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); if (dp == DDS_HANDLE_NIL) { printf ("%s PING: ERROR - Splice Daemon not running", argv[0]); exit (1); } /* * Create PING publisher */ DDS_DomainParticipant_get_default_publisher_qos (dp, pQos); pQos->partition.name._length = 1; pQos->partition.name._maximum = 1; pQos->partition.name._buffer = DDS_StringSeq_allocbuf (1); pQos->partition.name._buffer[0] = DDS_string_alloc (strlen(write_partition) + 1); strcpy (pQos->partition.name._buffer[0], write_partition); p = DDS_DomainParticipant_create_publisher (dp, pQos, NULL, DDS_STATUS_MASK_NONE); DDS_free (pQos); /* * Create PONG subscriber */ DDS_DomainParticipant_get_default_subscriber_qos (dp, sQos); sQos->partition.name._length = 1; sQos->partition.name._maximum = 1; sQos->partition.name._buffer = DDS_StringSeq_allocbuf (1); sQos->partition.name._buffer[0] = DDS_string_alloc (strlen(read_partition) + 1); strcpy (sQos->partition.name._buffer[0], read_partition); s = DDS_DomainParticipant_create_subscriber (dp, sQos, NULL, DDS_STATUS_MASK_NONE); DDS_free (sQos); /* * PP_min_msg */ /* Create Topic */ PP_min_dt = pingpong_PP_min_msgTypeSupport__alloc (); pingpong_PP_min_msgTypeSupport_register_type (PP_min_dt, dp, "pingpong::PP_min_msg"); PP_min_topic = DDS_DomainParticipant_create_topic (dp, "PP_min_topic", "pingpong::PP_min_msg", DDS_TOPIC_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); /* Create datawriter */ PP_min_writer = DDS_Publisher_create_datawriter (p, PP_min_topic, DDS_DATAWRITER_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); /* Create datareader */ PP_min_reader = DDS_Subscriber_create_datareader (s, PP_min_topic, DDS_DATAREADER_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); /* Add datareader statuscondition to waitset */ PP_min_sc = DDS_DataReader_get_statuscondition (PP_min_reader); DDS_StatusCondition_set_enabled_statuses (PP_min_sc, DDS_DATA_AVAILABLE_STATUS); result = DDS_WaitSet_attach_condition (w, PP_min_sc); /* * PP_seq_msg */ /* Create Topic */ PP_seq_dt = pingpong_PP_seq_msgTypeSupport__alloc (); pingpong_PP_seq_msgTypeSupport_register_type (PP_seq_dt, dp, "pingpong::PP_seq_msg"); PP_seq_topic = DDS_DomainParticipant_create_topic (dp, "PP_seq_topic", "pingpong::PP_seq_msg", DDS_TOPIC_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); /* Create datawriter */ PP_seq_writer = DDS_Publisher_create_datawriter (p, PP_seq_topic, DDS_DATAWRITER_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); /* Create datareader */ PP_seq_reader = DDS_Subscriber_create_datareader (s, PP_seq_topic, DDS_DATAREADER_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); /* Add datareader statuscondition to waitset */ PP_seq_sc = DDS_DataReader_get_statuscondition (PP_seq_reader); DDS_StatusCondition_set_enabled_statuses (PP_seq_sc, DDS_DATA_AVAILABLE_STATUS); result = DDS_WaitSet_attach_condition (w, PP_seq_sc); /* * PP_string_msg */ /* Create Topic */ PP_string_dt = pingpong_PP_string_msgTypeSupport__alloc (); pingpong_PP_string_msgTypeSupport_register_type (PP_string_dt, dp, "pingpong::PP_string_msg"); PP_string_topic = DDS_DomainParticipant_create_topic (dp, "PP_string_topic", "pingpong::PP_string_msg", DDS_TOPIC_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); /* Create datawriter */ PP_string_writer = DDS_Publisher_create_datawriter (p, PP_string_topic, DDS_DATAWRITER_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); /* Create datareader */ PP_string_reader = DDS_Subscriber_create_datareader (s, PP_string_topic, DDS_DATAREADER_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); /* Add datareader statuscondition to waitset */ PP_string_sc = DDS_DataReader_get_statuscondition (PP_string_reader); DDS_StatusCondition_set_enabled_statuses (PP_string_sc, DDS_DATA_AVAILABLE_STATUS); result = DDS_WaitSet_attach_condition (w, PP_string_sc); /* * PP_fixed_msg */ /* Create Topic */ PP_fixed_dt = pingpong_PP_fixed_msgTypeSupport__alloc (); pingpong_PP_fixed_msgTypeSupport_register_type (PP_fixed_dt, dp, "pingpong::PP_fixed_msg"); PP_fixed_topic = DDS_DomainParticipant_create_topic (dp, "PP_fixed_topic", "pingpong::PP_fixed_msg", DDS_TOPIC_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); /* Create datawriter */ PP_fixed_writer = DDS_Publisher_create_datawriter (p, PP_fixed_topic, DDS_DATAWRITER_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); /* Create datareader */ PP_fixed_reader = DDS_Subscriber_create_datareader (s, PP_fixed_topic, DDS_DATAREADER_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); /* Add datareader statuscondition to waitset */ PP_fixed_sc = DDS_DataReader_get_statuscondition (PP_fixed_reader); DDS_StatusCondition_set_enabled_statuses (PP_fixed_sc, DDS_DATA_AVAILABLE_STATUS); result = DDS_WaitSet_attach_condition (w, PP_fixed_sc); /* * PP_array_msg */ /* Create Topic */ PP_array_dt = pingpong_PP_array_msgTypeSupport__alloc (); pingpong_PP_array_msgTypeSupport_register_type (PP_array_dt, dp, "pingpong::PP_array_msg"); PP_array_topic = DDS_DomainParticipant_create_topic (dp, "PP_array_topic", "pingpong::PP_array_msg", DDS_TOPIC_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); /* Create datawriter */ PP_array_writer = DDS_Publisher_create_datawriter (p, PP_array_topic, DDS_DATAWRITER_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); /* Create datareader */ PP_array_reader = DDS_Subscriber_create_datareader (s, PP_array_topic, DDS_DATAREADER_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); /* Add datareader statuscondition to waitset */ PP_array_sc = DDS_DataReader_get_statuscondition (PP_array_reader); DDS_StatusCondition_set_enabled_statuses (PP_array_sc, DDS_DATA_AVAILABLE_STATUS); result = DDS_WaitSet_attach_condition (w, PP_array_sc); /* * PP_quit_msg */ /* Create Topic */ PP_quit_dt = pingpong_PP_quit_msgTypeSupport__alloc (); pingpong_PP_quit_msgTypeSupport_register_type (PP_quit_dt, dp, "pingpong::PP_quit_msg"); PP_quit_topic = DDS_DomainParticipant_create_topic (dp, "PP_quit_topic", "pingpong::PP_quit_msg", DDS_TOPIC_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); /* Create datawriter */ PP_quit_writer = DDS_Publisher_create_datawriter (p, PP_quit_topic, DDS_DATAWRITER_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); for (block = 0; block < nof_blocks ; block++) { while (!finish_flag) { /* * Send Initial message */ timeout_flag = FALSE; switch(topic_id) { case 'm': { /* printf ("PING: sending initial ping_min\n"); */ pingpong_PP_min_msg *PPdata = pingpong_PP_min_msg__alloc (); exp_condition = PP_min_sc; active_handler = &PP_min_handler; PPdata->count = 0; PPdata->block = block; preWriteTime = timeGet (); result = pingpong_PP_min_msgDataWriter_write (PP_min_writer, PPdata, DDS_HANDLE_NIL); postWriteTime = timeGet (); DDS_free (PPdata); } break; case 'q': { /* printf ("PING: sending initial ping_seq\n"); */ pingpong_PP_seq_msg *PPdata = pingpong_PP_seq_msg__alloc (); exp_condition = PP_seq_sc; active_handler = &PP_seq_handler; PPdata->count = 0; PPdata->block = block; preWriteTime = timeGet (); result = pingpong_PP_seq_msgDataWriter_write (PP_seq_writer, PPdata, DDS_HANDLE_NIL); postWriteTime = timeGet (); DDS_free (PPdata); } break; case 's': { /* printf ("PING: sending initial ping_string\n"); */ pingpong_PP_string_msg *PPdata = pingpong_PP_string_msg__alloc (); exp_condition = PP_string_sc; active_handler = &PP_string_handler; PPdata->count = 0; PPdata->block = block; PPdata->a_string = DDS_string_alloc (8); strcpy (PPdata->a_string, "a_string"); preWriteTime = timeGet (); result = pingpong_PP_string_msgDataWriter_write (PP_string_writer, PPdata, DDS_HANDLE_NIL); postWriteTime = timeGet (); DDS_free (PPdata); } break; case 'f': { /* printf ("PING: sending initial ping_fixed\n"); */ pingpong_PP_fixed_msg *PPdata = pingpong_PP_fixed_msg__alloc (); exp_condition = PP_fixed_sc; active_handler = &PP_fixed_handler; PPdata->count = 0; PPdata->block = block; PPdata->a_bstring = DDS_string_alloc (9); strcpy (PPdata->a_bstring, "a_bstring"); preWriteTime = timeGet (); result = pingpong_PP_fixed_msgDataWriter_write (PP_fixed_writer, PPdata, DDS_HANDLE_NIL); postWriteTime = timeGet (); DDS_free (PPdata); } break; case 'a': { /* printf ("PING: sending initial ping_array\n"); */ pingpong_PP_array_msg *PPdata = pingpong_PP_array_msg__alloc (); exp_condition = PP_array_sc; active_handler = &PP_array_handler; PPdata->count = 0; PPdata->block = block; preWriteTime = timeGet (); result = pingpong_PP_array_msgDataWriter_write (PP_array_writer, PPdata, DDS_HANDLE_NIL); postWriteTime = timeGet (); DDS_free (PPdata); } break; case 't': { /* printf ("PING: sending initial ping_quit\n"); */ pingpong_PP_quit_msg *PPdata = pingpong_PP_quit_msg__alloc(); PPdata->quit = TRUE; terminate = TRUE; finish_flag = TRUE; preWriteTime = timeGet (); result = pingpong_PP_quit_msgDataWriter_write (PP_quit_writer, PPdata, DDS_HANDLE_NIL); postWriteTime = timeGet (); DDS_free (PPdata); } break; default: printf("Invalid topic-id\n"); exit(1); } if (!terminate) { roundTripTime = preWriteTime; add_stats (&write_access, 1E6 * timeToReal (timeSub (postWriteTime, preWriteTime))); /* * Wait for response, calculate timing, and send another data if not ready */ while (!(timeout_flag || finish_flag)) { conditionList = DDS_ConditionSeq__alloc(); result = DDS_WaitSet_wait (w, conditionList, &wait_timeout); if (conditionList) { imax = conditionList->_length; if (imax != 0) { for (i = 0; i < imax; i++) { if (conditionList->_buffer[i] == exp_condition) { finish_flag = active_handler (nof_cycles); } else { printf ("PING: unexpected condition triggered: %x\n", (unsigned int)conditionList->_buffer[i]); } } } else { printf ("PING: TIMEOUT - message lost\n"); timeout_flag = TRUE; } DDS_free(conditionList); } else { printf ("PING: TIMEOUT - message lost\n"); timeout_flag = TRUE; } } } } if (!terminate) { finish_flag = FALSE; if (block == 0) { printf ("# PING PONG measurements (in us) \n"); printf ("# Executed at: %s", ctime(&clock)); printf ("# Roundtrip time [us] Write-access time [us] Read-access time [us]\n"); printf ("# Block Count mean min max Count mean min max Count mean min max\n"); } printf ("%6d %10d %6.0f %6.0f %6.0f %10d %6.0f %6.0f %6.0f %10d %6.0f %6.0f %6.0f\n", block, roundtrip.count, roundtrip.average, roundtrip.min, roundtrip.max, write_access.count, write_access.average, write_access.min, write_access.max, read_access.count, read_access.average, read_access.min, read_access.max); fflush (NULL); init_stats (&write_access, "write_access"); init_stats (&read_access, "read_access"); init_stats (&roundtrip, "round_trip"); } } result = DDS_Subscriber_delete_datareader (s, PP_min_reader); result = DDS_Publisher_delete_datawriter (p, PP_min_writer); result = DDS_Subscriber_delete_datareader (s, PP_seq_reader); result = DDS_Publisher_delete_datawriter (p, PP_seq_writer); result = DDS_Subscriber_delete_datareader (s, PP_string_reader); result = DDS_Publisher_delete_datawriter (p, PP_string_writer); result = DDS_Subscriber_delete_datareader (s, PP_fixed_reader); result = DDS_Publisher_delete_datawriter (p, PP_fixed_writer); result = DDS_Subscriber_delete_datareader (s, PP_array_reader); result = DDS_Publisher_delete_datawriter (p, PP_array_writer); result = DDS_Publisher_delete_datawriter (p, PP_quit_writer); result = DDS_DomainParticipant_delete_subscriber (dp, s); result = DDS_DomainParticipant_delete_publisher (dp, p); result = DDS_DomainParticipant_delete_topic (dp, PP_min_topic); result = DDS_DomainParticipant_delete_topic (dp, PP_seq_topic); result = DDS_DomainParticipant_delete_topic (dp, PP_string_topic); result = DDS_DomainParticipant_delete_topic (dp, PP_fixed_topic); result = DDS_DomainParticipant_delete_topic (dp, PP_array_topic); result = DDS_DomainParticipant_delete_topic (dp, PP_quit_topic); result = DDS_DomainParticipantFactory_delete_participant (dpf, dp); DDS_free (w); DDS_free (PP_min_dt); DDS_free (PP_seq_dt); DDS_free (PP_string_dt); DDS_free (PP_fixed_dt); DDS_free (PP_array_dt); DDS_free (PP_quit_dt); DDS_free (dpQos); DDS_free (tQos); DDS_free (dwQos); DDS_free (drQos); return 0; }
int main(int argc, char* argv[]) { int startTime = mstime(); DDS_PoolConstraints reqs; DDS_DomainParticipant domainParticipant; DDS_Publisher publisher; DDS_Subscriber subscriber; DDS_ReturnCode_t retCode; char *configTopicName[nofConfigTopics]; DDS_Topic configTopic[nofConfigTopics]; DDS_Topic stateTopic[nofStateTopics]; DDS_Topic statisticTopic[nofStatisticTopics]; DDS_DataWriterQos dataWriterQos; DDS_DataWriter configDataWriter[nofConfigTopics]; DDS_DataWriter stateDataWriter[nofStateTopics]; DDS_DataWriter statisticDataWriter[nofStatisticTopics]; DDS_DataReaderQos dataReaderQos; DDS_DataReader configDataReader[nofConfigTopics]; acceptance_high_end_Config config; acceptance_high_end_State state; acceptance_high_end_Statistic statistic; DDS_InstanceHandle_t configInstance[nofConfigTopics][nofConfigInstances]; DDS_InstanceHandle_t stateInstance[nofStateTopics][nofStateInstances]; DDS_InstanceHandle_t statisticInstance[nofStatisticTopics][nofStatisticInstances]; int i = 0; int j = 0; int firstConfigTopic = (argc > 1) ? atoi(argv[1]) : 0; int firstStateTopic = (argc > 2) ? atoi(argv[2]) : 0; int firstStatisticTopic = (argc > 3) ? atoi(argv[3]) : 0; int stagedLoading = (argc > 4) ? atoi(argv[4]) : 0; printf("[0] Config topics start at %d...\r\n", firstConfigTopic); printf("[0] State topics start at %d...\r\n", firstStateTopic); printf("[0] Statistic topics start at %d...\r\n", firstStatisticTopic); printf("[0] Staged loading %s.\r\n", stagedLoading ? "on" : "off"); if (stagedLoading) { char file_name[24]; sprintf(file_name, "/tmp/acceptStageLoad%d", firstConfigTopic); struct stat buf; if (stat(file_name, &buf)) { printf ("[%d] Waiting for %s\r\n", mstime() - startTime, file_name); do { sleep(1); } while (stat(file_name, &buf)); printf ("[%d] Got %s!\r\n", mstime() - startTime, file_name); } } DDS_program_name (&argc, argv); DDS_entity_name ("Technicolor Limits Component"); DDS_get_default_pool_constraints(&reqs, ~0, 100); #ifdef MINIMAL_POOLS configure_minimal_pool_constraints (&reqs); #else configure_optimal_pool_constraints (&reqs); #endif DDS_set_pool_constraints(&reqs); #ifdef DDS_DEBUG DDS_Debug_start (); #endif /* Create domain participant... */ domainParticipant = DDS_DomainParticipantFactory_create_participant(0, NULL, NULL, 0); if (!domainParticipant) { fprintf(stderr, "Error creating domain participant.\r\n"); return -1; } printf("[%d] Created domain participant.\r\n", mstime() - startTime); sleep(1); /* Create publisher... */ publisher = DDS_DomainParticipant_create_publisher(domainParticipant, NULL, NULL, 0); if (!publisher) { fprintf(stderr, "Error creating publisher.\r\n"); return -1; } printf("[%d] Created publisher.\r\n", mstime() - startTime); sleep(1); /* Create subscriber... */ subscriber = DDS_DomainParticipant_create_subscriber(domainParticipant, NULL, NULL, 0); if (!subscriber) { fprintf(stderr, "Error creating subscriber.\r\n"); return -1; } printf("[%d] Created subscriber.\r\n", mstime() - startTime); sleep(1); /* Register types... */ retCode = acceptance_high_end_ConfigTypeSupport_register_type(domainParticipant, NULL); if (retCode != DDS_RETCODE_OK) { fprintf(stderr, "Error registering type (%s).\r\n", DDS_error(retCode)); return -1; } printf("[%d] Registered config type.\r\n", mstime() - startTime); retCode = acceptance_high_end_StateTypeSupport_register_type(domainParticipant, NULL); if (retCode != DDS_RETCODE_OK) { fprintf(stderr, "Error registering type (%s).\r\n", DDS_error(retCode)); return -1; } printf("[%d] Registered state type.\r\n", mstime() - startTime); retCode = acceptance_high_end_StatisticTypeSupport_register_type(domainParticipant, NULL); if (retCode != DDS_RETCODE_OK) { fprintf(stderr, "Error registering type (%s).\r\n", DDS_error(retCode)); return -1; } printf("[%d] Registered statistic type.\r\n", mstime() - startTime); sleep(1); /* Create topics... */ for (i = 0; i < nofConfigTopics; i++) { char topicName[32]; sprintf(topicName, "ConfigTopic%d", firstConfigTopic + i); configTopicName[i] = strdup (topicName); configTopic[i] = DDS_DomainParticipant_create_topic(domainParticipant, topicName, acceptance_high_end_ConfigTypeSupport_get_type_name(), NULL, NULL, 0); if (!configTopic[i]) { fprintf(stderr, "Error creating topic.\r\n"); return -1; } } printf("[%d] Created %d config topics.\r\n", mstime() - startTime, nofConfigTopics); for (i = 0; i < nofStateTopics; i++) { char topicName[32]; sprintf(topicName, "StateTopic%d", firstStateTopic + i); stateTopic[i] = DDS_DomainParticipant_create_topic(domainParticipant, topicName, acceptance_high_end_StateTypeSupport_get_type_name(), NULL, NULL, 0); if (!stateTopic[i]) { fprintf(stderr, "Error creating topic.\r\n"); return -1; } } printf("[%d] Created %d state topics.\r\n", mstime() - startTime, nofStateTopics); for (i = 0; i < nofStatisticTopics; i++) { char topicName[32]; sprintf(topicName, "StatisticTopic%d", firstStatisticTopic + i); statisticTopic[i] = DDS_DomainParticipant_create_topic(domainParticipant, topicName, acceptance_high_end_StatisticTypeSupport_get_type_name(), NULL, NULL, 0); if (!statisticTopic[i]) { fprintf(stderr, "Error creating topic.\r\n"); return -1; } } printf("[%d] Created %d statistic topics.\r\n", mstime() - startTime, nofStatisticTopics); sleep(1); /* Create data writers... */ DDS_Publisher_get_default_datawriter_qos(publisher, &dataWriterQos); dataWriterQos.reliability.kind = DDS_RELIABLE_RELIABILITY_QOS; dataWriterQos.durability.kind = DDS_TRANSIENT_LOCAL_DURABILITY_QOS; for (i = 0; i < nofConfigTopics; i++) { configDataWriter[i] = DDS_Publisher_create_datawriter(publisher, configTopic[i], &dataWriterQos, NULL, 0); if (!configDataWriter[i]) { fprintf(stderr, "Error creating data writer.\r\n"); return -1; } } printf("[%d] Created %d config data writers.\r\n", mstime() - startTime, nofConfigTopics); DDS_Publisher_get_default_datawriter_qos(publisher, &dataWriterQos); dataWriterQos.reliability.kind = DDS_RELIABLE_RELIABILITY_QOS; dataWriterQos.durability.kind = DDS_TRANSIENT_LOCAL_DURABILITY_QOS; for (i = 0; i < nofStateTopics; i++) { stateDataWriter[i] = DDS_Publisher_create_datawriter(publisher, stateTopic[i], &dataWriterQos, NULL, 0); if (!stateDataWriter[i]) { fprintf(stderr, "Error creating data writer.\r\n"); return -1; } } printf("[%d] Created %d state data writers.\r\n", mstime() - startTime, nofStateTopics); DDS_Publisher_get_default_datawriter_qos(publisher, &dataWriterQos); for (i = 0; i < nofStatisticTopics; i++) { statisticDataWriter[i] = DDS_Publisher_create_datawriter(publisher, statisticTopic[i], &dataWriterQos, NULL, 0); if (!statisticDataWriter[i]) { fprintf(stderr, "Error creating data writer.\r\n"); return -1; } } printf("[%d] Created %d statistic data writers.\r\n", mstime() - startTime, nofStatisticTopics); sleep(1); /* Create data readers... */ DDS_Subscriber_get_default_datareader_qos(subscriber, &dataReaderQos); dataReaderQos.reliability.kind = DDS_RELIABLE_RELIABILITY_QOS; dataReaderQos.durability.kind = DDS_TRANSIENT_LOCAL_DURABILITY_QOS; for (i = 0; i < nofConfigTopics; i++) { configDataReader[i] = DDS_Subscriber_create_datareader(subscriber, DDS_DomainParticipant_lookup_topicdescription(domainParticipant, configTopicName[i]), &dataReaderQos, NULL, 0); if (!configDataReader[i]) { fprintf(stderr, "Error creating data reader.\r\n"); return -1; } } printf("[%d] Created %d config data readers.\r\n", mstime() - startTime, nofConfigTopics); sleep(1); /* Register instances... */ for (i = 0; i < nofConfigTopics; i++) { for (j = 0; j < nofConfigInstances; j++) { config.key = j; configInstance[i][j] = DDS_DataWriter_register_instance(configDataWriter[i], &config); if (!configInstance[i][j]) { fprintf(stderr, "Error registering instance.\r\n"); break; } } } printf("[%d] Registered %d config instances.\r\n", mstime() - startTime, nofConfigTopics * nofConfigInstances); for (i = 0; i < nofStateTopics; i++) { for (j = 0; j < nofStateInstances; j++) { state.key = j; stateInstance[i][j] = DDS_DataWriter_register_instance(stateDataWriter[i], &state); if (!stateInstance[i][j]) { fprintf(stderr, "Error registering instance.\r\n"); break; } } } printf("[%d] Registered %d state instances.\r\n", mstime() - startTime, nofStatisticTopics * nofStatisticInstances); for (i = 0; i < nofStatisticTopics; i++) { for (j = 0; j < nofStatisticInstances; j++) { statistic.key = j; statisticInstance[i][j] = DDS_DataWriter_register_instance(statisticDataWriter[i], &statistic); if (!statisticInstance[i][j]) { fprintf(stderr, "Error registering instance.\r\n"); break; } } } printf("[%d] Registered %d statistic instances.\r\n", mstime() - startTime, nofStatisticTopics * nofStatisticInstances); sleep(1); /* Publish samples... */ for (i = 0; i < nofConfigTopics; i++) { for (j = 0; j < nofConfigInstances; j++) { config.key = j; retCode = DDS_DataWriter_write(configDataWriter[i], &config, configInstance[i][j]); if (retCode != DDS_RETCODE_OK) { fprintf(stderr, "Error publishing sample (%s).\r\n", DDS_error(retCode)); break; } } } printf("[%d] Published %d config samples.\r\n", mstime() - startTime, nofConfigTopics * nofConfigInstances); for (i = 0; i < nofStateTopics; i++) { for (j = 0; j < nofStateInstances; j++) { state.key = j; retCode = DDS_DataWriter_write(stateDataWriter[i], &state, stateInstance[i][j]); if (retCode != DDS_RETCODE_OK) { fprintf(stderr, "Error publishing sample (%s).\r\n", DDS_error(retCode)); break; } } } printf("[%d] Published %d state samples.\r\n", mstime() - startTime, nofStateTopics * nofStateInstances); for (i = 0; i < nofStatisticTopics; i++) { for (j = 0; j < nofStatisticInstances; j++) { statistic.key = j; retCode = DDS_DataWriter_write(statisticDataWriter[i], &statistic, statisticInstance[i][j]); if (retCode != DDS_RETCODE_OK) { fprintf(stderr, "Error publishing sample (%s).\r\n", DDS_error(retCode)); break; } } } printf("[%d] Published %d statistic samples.\r\n", mstime() - startTime, nofStatisticTopics * nofStatisticInstances); sleep(1); if (stagedLoading) { char file_name[24]; sprintf(file_name, "/tmp/acceptStageLoad%d", firstConfigTopic + nofConfigTopics); FILE *f = fopen(file_name, "w"); fclose(f); } // dbg_printf ("Zzzzzzz ... \r\n"); sleep(TEST_TIME); // dbg_printf ("... o?\r\n"); /* Delete contained entities... */ // printf (" -- deleting contained entities.\r\n"); retCode = DDS_DomainParticipant_delete_contained_entities(domainParticipant); if (retCode != DDS_RETCODE_OK) { fprintf(stderr, "Error deleting contained entities.\r\n"); return -1; } for (i = 0; i < nofConfigTopics; i++) free (configTopicName[i]); // printf (" -- contained entities deleted!\r\n"); // sleep(TEST_TIME); /* Delete domain participants... */ retCode = DDS_DomainParticipantFactory_delete_participant(domainParticipant); if (retCode != DDS_RETCODE_OK) { fprintf(stderr, "Error deleting domain participant.\r\n"); return -1; } printf ("[%d] comp completed successfully.\r\n", mstime() - startTime); return 0; }
static void test_aux (void) { DDS_DomainParticipant np, p; DDS_Subscriber sub; DDS_Topic t; DDS_TopicDescription td; DDS_DataReader dr, dr0, dr1; DDS_StatusCondition sc, sc2; DDS_StatusMask sm; DDS_InstanceHandle_t h, h2; DDS_DataReaderQos drq; DDS_ReturnCode_t r; v_printf (" - Test auxiliary subscriber functions.\r\n"); p = DDS_DomainParticipantFactory_create_participant (1, DDS_PARTICIPANT_QOS_DEFAULT, NULL, 0); fail_unless (p != NULL); sub = DDS_DomainParticipant_create_subscriber (p, DDS_SUBSCRIBER_QOS_DEFAULT, NULL, 0); fail_unless (sub != NULL); sc = DDS_Subscriber_get_statuscondition (sub); fail_unless (sc != NULL); sc2 = DDS_Entity_get_statuscondition (sub); fail_unless (sc2 != NULL); sm = DDS_Subscriber_get_status_changes (sub); fail_unless (sm == 0); sm = DDS_Entity_get_status_changes (sub); fail_unless (sm == 0); /*dbg_printf ("(mask=%u)", sm);*/ h = DDS_Subscriber_get_instance_handle (sub); fail_unless (h != 0); h2 = DDS_Entity_get_instance_handle (sub); fail_unless (h == h2); np = DDS_Subscriber_get_participant (sub); fail_unless (np == p); r = register_HelloWorldData_type (p); fail_unless (r == DDS_RETCODE_OK); t = DDS_DomainParticipant_create_topic (p, "HelloWorld", TYPE_NAME, DDS_TOPIC_QOS_DEFAULT, NULL, 0); fail_unless (t != NULL); td = DDS_DomainParticipant_lookup_topicdescription (p, "HelloWorld"); fail_unless (td != NULL); dr0 = DDS_Subscriber_create_datareader (sub, td, DDS_DATAREADER_QOS_DEFAULT, NULL, 0); fail_unless (dr0 != NULL); dr = DDS_Subscriber_lookup_datareader (sub, "HelloWorld"); fail_unless (dr == dr0); dr1 = DDS_Subscriber_create_datareader (sub, td, DDS_DATAREADER_QOS_DEFAULT, NULL, 0); fail_unless (dr1 != NULL); delay (); r = DDS_Subscriber_delete_contained_entities (sub); fail_unless (r == DDS_RETCODE_OK); v_printf (" - Test default child QoS of subscriber entities\r\n"); r = DDS_Subscriber_get_default_datareader_qos (sub, &drq); fail_unless (r == DDS_RETCODE_OK); drq.ownership.kind = DDS_EXCLUSIVE_OWNERSHIP_QOS; r = DDS_Subscriber_set_default_datareader_qos (sub, &drq); fail_unless (r == DDS_RETCODE_OK); dr1 = DDS_Subscriber_create_datareader (sub, td, DDS_DATAREADER_QOS_DEFAULT, NULL, 0); fail_unless (dr1 != NULL); delay (); v_printf (" - Test coherency (not implemented).\r\n"); r = DDS_Subscriber_begin_access (sub); fail_unless (r == DDS_RETCODE_UNSUPPORTED); r = DDS_Subscriber_end_access (sub); fail_unless (r == DDS_RETCODE_UNSUPPORTED); r = DDS_Subscriber_copy_from_topic_qos (sub, &drq, NULL); fail_unless (r == DDS_RETCODE_OK); r = DDS_Subscriber_notify_datareaders (sub); fail_unless (r == DDS_RETCODE_OK); r = DDS_DomainParticipant_delete_subscriber (p, sub); fail_unless (r == DDS_RETCODE_PRECONDITION_NOT_MET); r = DDS_Subscriber_delete_datareader (sub, dr1); fail_unless (r == DDS_RETCODE_OK); r = DDS_DomainParticipant_delete_subscriber (p, sub); fail_unless (r == DDS_RETCODE_OK); r = DDS_DomainParticipant_delete_topic (p, t); fail_unless (r == DDS_RETCODE_OK); unregister_HelloWorldData_type (p); r = DDS_DomainParticipantFactory_delete_participant (p); fail_unless (r == DDS_RETCODE_OK); }
static void test_listener (void) { DDS_DomainParticipant p; DDS_Subscriber sub; DDS_SubscriberListener *lp; DDS_ReturnCode_t r; p = DDS_DomainParticipantFactory_create_participant (1, DDS_PARTICIPANT_QOS_DEFAULT, NULL, 0); fail_unless (p != NULL); v_printf (" - Test subscriber listener.\r\n"); sub = DDS_DomainParticipant_create_subscriber (p, DDS_SUBSCRIBER_QOS_DEFAULT, NULL, 0); fail_unless (sub != NULL); lp = DDS_Subscriber_get_listener (sub); fail_unless (lp != NULL && lp->on_sample_rejected == NULL && lp->on_requested_incompatible_qos == NULL && lp->on_sample_lost == NULL && lp->on_subscription_matched == NULL && lp->on_data_available == NULL && lp->on_liveliness_changed == NULL && lp->on_data_on_readers == NULL && lp->on_requested_deadline_missed == NULL); r = DDS_Subscriber_set_listener (sub, &sub_listener, DDS_SAMPLE_REJECTED_STATUS | DDS_REQUESTED_INCOMPATIBLE_QOS_STATUS | DDS_SAMPLE_LOST_STATUS | DDS_SUBSCRIPTION_MATCHED_STATUS | DDS_DATA_AVAILABLE_STATUS | DDS_LIVELINESS_CHANGED_STATUS | DDS_DATA_ON_READERS_STATUS | DDS_REQUESTED_DEADLINE_MISSED_STATUS); fail_unless (r == DDS_RETCODE_OK); v_printf (" - Test specific subscriber listener updates.\r\n"); lp = DDS_Subscriber_get_listener (sub); fail_unless (lp != NULL && lp->on_sample_rejected == sample_rejected && lp->on_requested_incompatible_qos == requested_incompatible_qos && lp->on_sample_lost == sample_lost && lp->on_subscription_matched == subscription_matched && lp->on_data_available == data_available && lp->on_liveliness_changed == liveliness_changed && lp->on_data_on_readers == data_on_readers && lp->on_requested_deadline_missed == requested_deadline_missed); v_printf (" - Test default subscriber listener update.\r\n"); r = DDS_Subscriber_set_listener (sub, NULL, DDS_REQUESTED_DEADLINE_MISSED_STATUS); fail_unless (r == DDS_RETCODE_OK); lp = DDS_Subscriber_get_listener (sub); fail_unless (lp != NULL && lp->on_sample_rejected == NULL && lp->on_requested_incompatible_qos == NULL && lp->on_sample_lost == NULL && lp->on_subscription_matched == NULL && lp->on_data_available == NULL && lp->on_liveliness_changed == NULL && lp->on_data_on_readers == NULL && lp->on_requested_deadline_missed == NULL); r = DDS_DomainParticipant_delete_subscriber (p, sub); fail_unless (r == DDS_RETCODE_OK); r = DDS_DomainParticipantFactory_delete_participant (p); fail_unless (r == DDS_RETCODE_OK); }
static void test_qos (int enabled) { DDS_DomainParticipantFactoryQos qos; DDS_DomainParticipant p; DDS_Publisher pub; DDS_Subscriber sub; DDS_DataWriter dw; DDS_DataReader dr; DDS_Topic t; DDS_TopicDescription td; DDS_SubscriberQos psq, refsq; DDS_ReturnCode_t r; static char *buf [] = { "Hello", "World" }; static unsigned char data [] = { 0x77, 0x88, 0xaa, 0xbb, 0xcc }; unsigned char d2 [sizeof (data) + 1]; unsigned n; size_t i; int err; v_printf (" - Set factory QoS to %sabled.\r\n", (enabled) ? "en" : "dis"); r = DDS_DomainParticipantFactory_get_qos (&qos); fail_unless (r == DDS_RETCODE_OK); qos.entity_factory.autoenable_created_entities = enabled; r = DDS_DomainParticipantFactory_set_qos (&qos); fail_unless (r == DDS_RETCODE_OK); p = DDS_DomainParticipantFactory_create_participant (1, DDS_PARTICIPANT_QOS_DEFAULT, NULL, 0); fail_unless (p != NULL); r = register_HelloWorldData_type (p); fail_unless (r == DDS_RETCODE_OK); DDS_SubscriberQos__init (&refsq); for (i = 0; (size_t) i < sizeof (buf) / sizeof (char *); i++) { err = dds_seq_append (&refsq.partition.name, &buf [i]); fail_unless (err == 0); } err = dds_seq_from_array (&refsq.group_data, data, sizeof (data)); fail_unless (err == 0); v_printf (" - Create subscriber with specific QoS parameters.\r\n"); sub = DDS_DomainParticipant_create_subscriber (p, &refsq, NULL, 0); fail_unless (sub != NULL); memset (&psq, 0, sizeof (psq)); r = DDS_Subscriber_get_qos (sub, &psq); fail_unless (r == DDS_RETCODE_OK && DDS_SEQ_LENGTH (refsq.partition.name) == DDS_SEQ_LENGTH (psq.partition.name) && DDS_SEQ_LENGTH (refsq.group_data.value) == sizeof (data)); DDS_SEQ_FOREACH (refsq.partition.name, i) fail_unless (!strcmp (DDS_SEQ_ITEM (psq.partition.name, i), DDS_SEQ_ITEM (refsq.partition.name, i))); n = dds_seq_to_array (&psq.group_data, d2, sizeof (d2)); fail_unless (n == sizeof (data) && !memcmp (data, d2, sizeof (data))); DDS_SubscriberQos__clear (&psq); r = DDS_DomainParticipant_delete_subscriber (p, sub); fail_unless (r == DDS_RETCODE_OK); v_printf (" - Create topic/publisher/writer/subscriber/reader entities.\r\n"); t = DDS_DomainParticipant_create_topic (p, "HelloWorld", TYPE_NAME, DDS_TOPIC_QOS_DEFAULT, NULL, 0); fail_unless (t != NULL); td = DDS_DomainParticipant_lookup_topicdescription (p, "HelloWorld"); fail_unless (td != NULL); pub = DDS_DomainParticipant_create_publisher (p, DDS_PUBLISHER_QOS_DEFAULT, NULL, 0); fail_unless (pub != NULL); dw = DDS_Publisher_create_datawriter (pub, t, DDS_DATAWRITER_QOS_DEFAULT, NULL, 0); fail_unless (dw != NULL); sub = DDS_DomainParticipant_create_subscriber (p, DDS_SUBSCRIBER_QOS_DEFAULT, NULL, 0); fail_unless (sub != NULL); dr = DDS_Subscriber_create_datareader (sub, td, DDS_DATAREADER_QOS_DEFAULT, NULL, 0); fail_unless (dr != NULL); v_printf (" - Update subscriber QoS.\r\n"); r = DDS_Subscriber_get_qos (sub, &psq); fail_unless (r == DDS_RETCODE_OK); DDS_SubscriberQos__clear (&refsq); fail_unless (r == DDS_RETCODE_OK && !memcmp (&psq, &refsq, sizeof (refsq))); for (i = 0; (size_t) i < sizeof (buf) / sizeof (char *); i++) { err = dds_seq_append (&refsq.partition.name, &buf [i]); fail_unless (err == 0); } err = dds_seq_from_array (&refsq.group_data, data, sizeof (data)); fail_unless (err == 0); r = DDS_Subscriber_set_qos (sub, &refsq); fail_unless (r == DDS_RETCODE_OK); delay (); r = DDS_Subscriber_get_qos (sub, &psq); fail_unless (r == DDS_RETCODE_OK && DDS_SEQ_LENGTH (refsq.partition.name) == DDS_SEQ_LENGTH (psq.partition.name) && DDS_SEQ_LENGTH (psq.group_data.value) == sizeof (data)); DDS_SEQ_FOREACH (psq.partition.name, i) fail_unless (!strcmp (DDS_SEQ_ITEM (psq.partition.name, i), DDS_SEQ_ITEM (refsq.partition.name, i))); n = dds_seq_to_array (&psq.group_data, d2, sizeof (d2)); fail_unless (n == sizeof (data) && !memcmp (data, d2, sizeof (data))); DDS_SubscriberQos__clear (&refsq); DDS_SubscriberQos__clear (&psq); delay (); if (!enabled) { v_printf (" - Enable child entities.\r\n"); r = DDS_DomainParticipant_enable (p); fail_unless (r == DDS_RETCODE_OK); r = DDS_Topic_enable (t); fail_unless (r == DDS_RETCODE_OK); r = DDS_Publisher_enable (pub); fail_unless (r == DDS_RETCODE_OK); r = DDS_Subscriber_enable (sub); fail_unless (r == DDS_RETCODE_OK); r = DDS_DataWriter_enable (dw); fail_unless (r == DDS_RETCODE_OK); r = DDS_DataReader_enable (dr); fail_unless (r == DDS_RETCODE_OK); sleep (1); } v_printf (" - Delete child entities.\r\n"); r = DDS_Publisher_delete_datawriter (pub, dw); fail_unless (r == DDS_RETCODE_OK); r = DDS_Subscriber_delete_datareader (sub, dr); fail_unless (r == DDS_RETCODE_OK); r = DDS_DomainParticipant_delete_publisher (p, pub); fail_unless (r == DDS_RETCODE_OK); r = DDS_DomainParticipant_delete_subscriber (p, sub); fail_unless (r == DDS_RETCODE_OK); r = DDS_DomainParticipant_delete_topic (p, t); fail_unless (r == DDS_RETCODE_OK); unregister_HelloWorldData_type (p); r = DDS_DomainParticipantFactory_delete_participant (p); fail_unless (r == DDS_RETCODE_OK); }
int OSPL_MAIN (int argc, char ** argv) #endif { DDS_ConditionSeq *conditionList; DDS_WaitSet w; DDS_DomainParticipantQos *dpQos; DDS_TopicQos *tQos; DDS_PublisherQos *pQos; DDS_DataWriterQos *dwQos; DDS_SubscriberQos *sQos; DDS_DataReaderQos *drQos; DDS_Condition exp_condition = NULL; pong_handler *active_handler = NULL; DDS_Duration_t wait_timeout = {3,0}; DDS_boolean finish_flag = FALSE; DDS_boolean timeout_flag = FALSE; DDS_boolean terminate = FALSE; DDS_ReturnCode_t result; int imax = 1; int i; unsigned int block; printf ("Starting ping example\n"); fflush(stdout); /* * init timing statistics */ init_stats (&roundtrip, "round_trip"); init_stats (&write_access, "write_access"); init_stats (&read_access, "read_access"); /* * Evaluate cmdline arguments */ #ifdef INTEGRITY nof_blocks = 100; nof_cycles = 100; #if defined (PING1) topic_id = 'm'; #elif defined (PING2) topic_id = 'q'; #elif defined (PING3) topic_id = 's'; #elif defined (PING4) topic_id = 'f'; #elif defined (PING5) topic_id = 'b'; #elif defined (PING6) nof_blocks = 1; nof_cycles = 10; topic_id = 't'; #endif write_partition = "PongRead"; read_partition = "PongWrite"; #else if (argc != 1) { if (argc != 6) { printf ("Invalid.....\n Usage: %s [blocks blocksize topic_id WRITE_PARTITION READ_PARTITION]\n", argv[0]); exit (1); } nof_blocks = atoi (argv[1]); nof_cycles = atoi (argv[2]); topic_id = argv[3][0]; write_partition = argv[4]; read_partition = argv[5]; } #endif #ifdef _WIN32 init_clock(); #endif /* * Create WaitSet */ w = DDS_WaitSet__alloc (); /* * Initialize Qos variables */ dpQos = DDS_DomainParticipantQos__alloc(); tQos = DDS_TopicQos__alloc(); pQos = DDS_PublisherQos__alloc(); dwQos = DDS_DataWriterQos__alloc(); sQos = DDS_SubscriberQos__alloc(); drQos = DDS_DataReaderQos__alloc(); /* * Initialize condition list */ conditionList = NULL; /* * Create participant */ dpf = DDS_DomainParticipantFactory_get_instance (); dp = DDS_DomainParticipantFactory_create_participant (dpf, myDomain, DDS_PARTICIPANT_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); if (dp == DDS_HANDLE_NIL) { printf ("%s PING: ERROR - Splice Daemon not running", argv[0]); exit (1); } /* * Create PING publisher */ DDS_DomainParticipant_get_default_publisher_qos (dp, pQos); pQos->partition.name._length = 1; pQos->partition.name._maximum = 1; pQos->partition.name._buffer = DDS_StringSeq_allocbuf (1); pQos->partition.name._buffer[0] = DDS_string_dup (write_partition); p = DDS_DomainParticipant_create_publisher (dp, pQos, NULL, DDS_STATUS_MASK_NONE); DDS_free (pQos); /* * Create PONG subscriber */ DDS_DomainParticipant_get_default_subscriber_qos (dp, sQos); sQos->partition.name._length = 1; sQos->partition.name._maximum = 1; sQos->partition.name._buffer = DDS_StringSeq_allocbuf (1); sQos->partition.name._buffer[0] = DDS_string_dup (read_partition); s = DDS_DomainParticipant_create_subscriber (dp, sQos, NULL, DDS_STATUS_MASK_NONE); DDS_free (sQos); /* * PP_min_msg */ /* Create Topic */ PP_min_dt = pingpong_PP_min_msgTypeSupport__alloc (); pingpong_PP_min_msgTypeSupport_register_type (PP_min_dt, dp, "pingpong::PP_min_msg"); PP_min_topic = DDS_DomainParticipant_create_topic (dp, "PP_min_topic", "pingpong::PP_min_msg", DDS_TOPIC_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); DDS_Publisher_get_default_datawriter_qos(p, dwQos); dwQos->reliability.kind = DDS_BEST_EFFORT_RELIABILITY_QOS; dwQos->history.kind = DDS_KEEP_ALL_HISTORY_QOS; /* Create datawriter */ PP_min_writer = DDS_Publisher_create_datawriter (p, PP_min_topic, dwQos, NULL, DDS_STATUS_MASK_NONE); /* Create datareader */ PP_min_reader = DDS_Subscriber_create_datareader (s, PP_min_topic, DDS_DATAREADER_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); /* Add datareader statuscondition to waitset */ PP_min_sc = DDS_DataReader_get_statuscondition (PP_min_reader); DDS_StatusCondition_set_enabled_statuses (PP_min_sc, DDS_DATA_AVAILABLE_STATUS); DDS_WaitSet_attach_condition (w, PP_min_sc); /* * PP_seq_msg */ /* Create Topic */ PP_seq_dt = pingpong_PP_seq_msgTypeSupport__alloc (); pingpong_PP_seq_msgTypeSupport_register_type (PP_seq_dt, dp, "pingpong::PP_seq_msg"); PP_seq_topic = DDS_DomainParticipant_create_topic (dp, "PP_seq_topic", "pingpong::PP_seq_msg", DDS_TOPIC_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); /* Create datawriter */ PP_seq_writer = DDS_Publisher_create_datawriter (p, PP_seq_topic, dwQos, NULL, DDS_STATUS_MASK_NONE); /* Create datareader */ PP_seq_reader = DDS_Subscriber_create_datareader (s, PP_seq_topic, DDS_DATAREADER_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); /* Add datareader statuscondition to waitset */ PP_seq_sc = DDS_DataReader_get_statuscondition (PP_seq_reader); DDS_StatusCondition_set_enabled_statuses (PP_seq_sc, DDS_DATA_AVAILABLE_STATUS); DDS_WaitSet_attach_condition (w, PP_seq_sc); /* * PP_string_msg */ /* Create Topic */ PP_string_dt = pingpong_PP_string_msgTypeSupport__alloc (); pingpong_PP_string_msgTypeSupport_register_type (PP_string_dt, dp, "pingpong::PP_string_msg"); PP_string_topic = DDS_DomainParticipant_create_topic (dp, "PP_string_topic", "pingpong::PP_string_msg", DDS_TOPIC_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); /* Create datawriter */ PP_string_writer = DDS_Publisher_create_datawriter (p, PP_string_topic, dwQos, NULL, DDS_STATUS_MASK_NONE); /* Create datareader */ PP_string_reader = DDS_Subscriber_create_datareader (s, PP_string_topic, DDS_DATAREADER_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); /* Add datareader statuscondition to waitset */ PP_string_sc = DDS_DataReader_get_statuscondition (PP_string_reader); DDS_StatusCondition_set_enabled_statuses (PP_string_sc, DDS_DATA_AVAILABLE_STATUS); DDS_WaitSet_attach_condition (w, PP_string_sc); /* * PP_fixed_msg */ /* Create Topic */ PP_fixed_dt = pingpong_PP_fixed_msgTypeSupport__alloc (); pingpong_PP_fixed_msgTypeSupport_register_type (PP_fixed_dt, dp, "pingpong::PP_fixed_msg"); PP_fixed_topic = DDS_DomainParticipant_create_topic (dp, "PP_fixed_topic", "pingpong::PP_fixed_msg", DDS_TOPIC_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); /* Create datawriter */ PP_fixed_writer = DDS_Publisher_create_datawriter (p, PP_fixed_topic, dwQos, NULL, DDS_STATUS_MASK_NONE); /* Create datareader */ PP_fixed_reader = DDS_Subscriber_create_datareader (s, PP_fixed_topic, DDS_DATAREADER_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); /* Add datareader statuscondition to waitset */ PP_fixed_sc = DDS_DataReader_get_statuscondition (PP_fixed_reader); DDS_StatusCondition_set_enabled_statuses (PP_fixed_sc, DDS_DATA_AVAILABLE_STATUS); DDS_WaitSet_attach_condition (w, PP_fixed_sc); /* * PP_array_msg */ /* Create Topic */ PP_array_dt = pingpong_PP_array_msgTypeSupport__alloc (); pingpong_PP_array_msgTypeSupport_register_type (PP_array_dt, dp, "pingpong::PP_array_msg"); PP_array_topic = DDS_DomainParticipant_create_topic (dp, "PP_array_topic", "pingpong::PP_array_msg", DDS_TOPIC_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); /* Create datawriter */ PP_array_writer = DDS_Publisher_create_datawriter (p, PP_array_topic, dwQos, NULL, DDS_STATUS_MASK_NONE); /* Create datareader */ PP_array_reader = DDS_Subscriber_create_datareader (s, PP_array_topic, DDS_DATAREADER_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); /* Add datareader statuscondition to waitset */ PP_array_sc = DDS_DataReader_get_statuscondition (PP_array_reader); DDS_StatusCondition_set_enabled_statuses (PP_array_sc, DDS_DATA_AVAILABLE_STATUS); DDS_WaitSet_attach_condition (w, PP_array_sc); /* * PP_bseq_msg */ /* Create Topic */ PP_bseq_dt = pingpong_PP_bseq_msgTypeSupport__alloc (); pingpong_PP_bseq_msgTypeSupport_register_type (PP_bseq_dt, dp, "pingpong::PP_bseq_msg"); PP_bseq_topic = DDS_DomainParticipant_create_topic (dp, "PP_bseq_topic", "pingpong::PP_bseq_msg", DDS_TOPIC_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); /* Create datawriter */ PP_bseq_writer = DDS_Publisher_create_datawriter (p, PP_bseq_topic, dwQos, NULL, DDS_STATUS_MASK_NONE); /* Create datareader */ PP_bseq_reader = DDS_Subscriber_create_datareader (s, PP_bseq_topic, DDS_DATAREADER_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); /* Add datareader statuscondition to waitset */ PP_bseq_sc = DDS_DataReader_get_statuscondition (PP_bseq_reader); DDS_StatusCondition_set_enabled_statuses (PP_bseq_sc, DDS_DATA_AVAILABLE_STATUS); DDS_WaitSet_attach_condition (w, PP_bseq_sc); /* * PP_quit_msg */ /* Create Topic */ PP_quit_dt = pingpong_PP_quit_msgTypeSupport__alloc (); pingpong_PP_quit_msgTypeSupport_register_type (PP_quit_dt, dp, "pingpong::PP_quit_msg"); PP_quit_topic = DDS_DomainParticipant_create_topic (dp, "PP_quit_topic", "pingpong::PP_quit_msg", DDS_TOPIC_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); /* Create datawriter */ PP_quit_writer = DDS_Publisher_create_datawriter (p, PP_quit_topic, dwQos, NULL, DDS_STATUS_MASK_NONE); /* Fr: workarround for ticket dds1712 */ conditionList = DDS_ConditionSeq__alloc(); assert(conditionList); DDS_WaitSet_wait (w, conditionList, &wait_timeout); DDS_free(conditionList); for (block = 0; block < nof_blocks && !terminate ; block++) { while (!finish_flag) { /* * Send Initial message */ timeout_flag = FALSE; switch(topic_id) { case 'm': { /* printf ("PING: sending initial ping_min\n"); */ pingpong_PP_min_msg *PPdata = pingpong_PP_min_msg__alloc (); exp_condition = PP_min_sc; active_handler = &PP_min_handler; PPdata->count = 0; PPdata->block = block; preWriteTime = timeGet (); pingpong_PP_min_msgDataWriter_write (PP_min_writer, PPdata, DDS_HANDLE_NIL); postWriteTime = timeGet (); DDS_free (PPdata); } break; case 'q': { /* printf ("PING: sending initial ping_seq\n"); */ pingpong_PP_seq_msg *PPdata = pingpong_PP_seq_msg__alloc (); exp_condition = PP_seq_sc; active_handler = &PP_seq_handler; PPdata->count = 0; PPdata->block = block; { int i = 0; PPdata->payload._buffer = pingpong_seq_char_allocbuf(SEQ_PAYLOAD_SIZE); PPdata->payload._length = SEQ_PAYLOAD_SIZE; PPdata->payload._maximum = SEQ_PAYLOAD_SIZE; for (i=0; i<SEQ_PAYLOAD_SIZE; i++) { PPdata->payload._buffer[i] = (char)i; } } preWriteTime = timeGet (); pingpong_PP_seq_msgDataWriter_write (PP_seq_writer, PPdata, DDS_HANDLE_NIL); postWriteTime = timeGet (); DDS_free (PPdata); } break; case 's': { /* printf ("PING: sending initial ping_string\n"); */ pingpong_PP_string_msg *PPdata = pingpong_PP_string_msg__alloc (); exp_condition = PP_string_sc; active_handler = &PP_string_handler; PPdata->count = 0; PPdata->block = block; PPdata->a_string = DDS_string_dup ("a_string"); preWriteTime = timeGet (); pingpong_PP_string_msgDataWriter_write (PP_string_writer, PPdata, DDS_HANDLE_NIL); postWriteTime = timeGet (); DDS_free (PPdata); } break; case 'f': { /* printf ("PING: sending initial ping_fixed\n"); */ pingpong_PP_fixed_msg *PPdata = pingpong_PP_fixed_msg__alloc (); exp_condition = PP_fixed_sc; active_handler = &PP_fixed_handler; PPdata->count = 0; PPdata->block = block; PPdata->a_bstring = DDS_string_dup ("a_bstring"); preWriteTime = timeGet (); pingpong_PP_fixed_msgDataWriter_write (PP_fixed_writer, PPdata, DDS_HANDLE_NIL); postWriteTime = timeGet (); DDS_free (PPdata); } break; case 'a': { /* printf ("PING: sending initial ping_array\n"); */ pingpong_PP_array_msg *PPdata = pingpong_PP_array_msg__alloc (); exp_condition = PP_array_sc; active_handler = &PP_array_handler; PPdata->count = 0; PPdata->block = block; preWriteTime = timeGet (); pingpong_PP_array_msgDataWriter_write (PP_array_writer, PPdata, DDS_HANDLE_NIL); postWriteTime = timeGet (); DDS_free (PPdata); } break; case 'b': { /* printf ("PING: sending initial ping_bseq_msg\n"); */ pingpong_PP_bseq_msg *PPdata = pingpong_PP_bseq_msg__alloc (); exp_condition = PP_bseq_sc; active_handler = &PP_bseq_handler; PPdata->count = 0; PPdata->block = block; preWriteTime = timeGet (); pingpong_PP_bseq_msgDataWriter_write (PP_bseq_writer, PPdata, DDS_HANDLE_NIL); postWriteTime = timeGet (); DDS_free (PPdata); } break; case 't': { /* printf ("PING: sending initial ping_quit\n"); */ pingpong_PP_quit_msg *PPdata = pingpong_PP_quit_msg__alloc(); PPdata->quit = TRUE; terminate = TRUE; finish_flag = TRUE; sleep(1); preWriteTime = timeGet (); pingpong_PP_quit_msgDataWriter_write (PP_quit_writer, PPdata, DDS_HANDLE_NIL); postWriteTime = timeGet (); sleep(1); DDS_free (PPdata); } break; default: printf("Invalid topic-id\n"); exit(1); } if (!terminate) { roundTripTime = preWriteTime; add_stats (&write_access, 1E6 * timeToReal (timeSub (postWriteTime, preWriteTime))); /* * Wait for response, calculate timing, and send another data if not ready */ while (!(timeout_flag || finish_flag)) { conditionList = DDS_ConditionSeq__alloc(); result = DDS_WaitSet_wait (w, conditionList, &wait_timeout); if(result == DDS_RETCODE_OK || result == DDS_RETCODE_NO_DATA || result == DDS_RETCODE_TIMEOUT) { if (conditionList) { imax = conditionList->_length; if (imax != 0) { for (i = 0; i < imax; i++) { if (conditionList->_buffer[i] == exp_condition) { finish_flag = active_handler (nof_cycles); } else { printf ("PING: unexpected condition triggered: %lx\n", (unsigned long)conditionList->_buffer[i]); } } } else { printf ("PING: TIMEOUT - message lost\n"); timeout_flag = TRUE; } DDS_free(conditionList); } else { printf ("PING: TIMEOUT - message lost\n"); timeout_flag = TRUE; } } else { printf ("PING: Waitset wait failed (code %d), terminating.\n", result); finish_flag = TRUE; terminate = TRUE; } } } } if (!terminate) { finish_flag = FALSE; if (block == 0) { printf ("# PING PONG measurements (in us) \n"); printf ("# Roundtrip time [us] Write-access time [us] Read-access time [us]\n"); printf ("# Block Count mean min max Count mean min max Count mean min max\n"); } printf ("%6d %10d %6.0f %6.0f %6.0f %10d %6.0f %6.0f %6.0f %10d %6.0f %6.0f %6.0f\n", block, roundtrip.count, roundtrip.average, roundtrip.min, roundtrip.max, write_access.count, write_access.average, write_access.min, write_access.max, read_access.count, read_access.average, read_access.min, read_access.max); fflush (stdout); init_stats (&write_access, "write_access"); init_stats (&read_access, "read_access"); init_stats (&roundtrip, "round_trip"); } } DDS_Subscriber_delete_datareader (s, PP_min_reader); DDS_Publisher_delete_datawriter (p, PP_min_writer); DDS_Subscriber_delete_datareader (s, PP_seq_reader); DDS_Publisher_delete_datawriter (p, PP_seq_writer); DDS_Subscriber_delete_datareader (s, PP_string_reader); DDS_Publisher_delete_datawriter (p, PP_string_writer); DDS_Subscriber_delete_datareader (s, PP_fixed_reader); DDS_Publisher_delete_datawriter (p, PP_fixed_writer); DDS_Subscriber_delete_datareader (s, PP_array_reader); DDS_Publisher_delete_datawriter (p, PP_array_writer); DDS_Subscriber_delete_datareader (s, PP_bseq_reader); DDS_Publisher_delete_datawriter (p, PP_bseq_writer); DDS_Publisher_delete_datawriter (p, PP_quit_writer); DDS_DomainParticipant_delete_subscriber (dp, s); DDS_DomainParticipant_delete_publisher (dp, p); DDS_DomainParticipant_delete_topic (dp, PP_min_topic); DDS_DomainParticipant_delete_topic (dp, PP_seq_topic); DDS_DomainParticipant_delete_topic (dp, PP_string_topic); DDS_DomainParticipant_delete_topic (dp, PP_fixed_topic); DDS_DomainParticipant_delete_topic (dp, PP_array_topic); DDS_DomainParticipant_delete_topic (dp, PP_bseq_topic); DDS_DomainParticipant_delete_topic (dp, PP_quit_topic); DDS_DomainParticipantFactory_delete_participant (dpf, dp); DDS_free (w); DDS_free (PP_min_dt); DDS_free (PP_seq_dt); DDS_free (PP_string_dt); DDS_free (PP_fixed_dt); DDS_free (PP_array_dt); DDS_free (PP_bseq_dt); DDS_free (PP_quit_dt); DDS_free (dpQos); DDS_free (tQos); DDS_free (dwQos); DDS_free (drQos); printf ("Completed ping example\n"); fflush(stdout); return 0; }
static void stub_fini(void) { DDS_DomainParticipant_delete_contained_entities(_dp); DDS_DomainParticipantFactory_delete_participant(_dp); }
int main_subscriber (int argc, const char **argv) { DDS_DataWriterQos wr_qos; DDS_DataReaderQos rd_qos; DDS_ReturnCode_t error; sprintf (user_name, ".pid.%u", getpid ()); DDS_entity_name ("Technicolor Chatroom"); #ifdef DDS_SECURITY if (cert_path || key_path || engine_id) enable_security (); #endif part = DDS_DomainParticipantFactory_create_participant (domain_id, NULL, NULL, 0); if (!part) { printf ("Can't create participant!\r\n"); exit (1); } if (verbose) printf ("DDS Domain Participant created.\r\n"); ts = Vector3_type_new (); if (!ts) { printf ("Can't create vector3 message type!\r\n"); exit (1); } error = DDS_DynamicTypeSupport_register_type (ts, part, "simple_msgs::dds_::Vector3_"); if (error) { printf ("Can't register vector3 message type.\r\n"); exit (1); } if (verbose) printf ("DDS Topic type ('%s') registered.\r\n", "simple_msgs::dds_::Vector3_"); topic = DDS_DomainParticipant_create_topic (part, "imu", "simple_msgs::dds_::Vector3_", NULL, NULL, 0); if (!topic) { printf ("Can't register vector3 message type.\r\n"); exit (1); } if (verbose) printf ("DDS Vector3 Topic created.\r\n"); td = DDS_DomainParticipant_lookup_topicdescription (part, "imu"); if (!td) { printf ("Can't get topicdescription.\r\n"); exit (1); } pub = DDS_DomainParticipant_create_publisher (part, NULL, NULL, 0); if (!pub) { printf ("DDS_DomainParticipant_create_publisher () failed!\r\n"); exit (1); } DDS_Publisher_get_default_datawriter_qos (pub, &wr_qos); #ifdef TRANSIENT_LOCAL wr_qos.durability.kind = DDS_TRANSIENT_LOCAL_DURABILITY_QOS; #endif #ifdef RELIABLE wr_qos.reliability.kind = DDS_RELIABLE_RELIABILITY_QOS; #endif #ifdef KEEP_ALL wr_qos.history.kind = DDS_KEEP_ALL_HISTORY_QOS; wr_qos.history.depth = DDS_LENGTH_UNLIMITED; wr_qos.resource_limits.max_samples_per_instance = HISTORY; wr_qos.resource_limits.max_instances = HISTORY * 10; wr_qos.resource_limits.max_samples = HISTORY * 4; #else wr_qos.history.kind = DDS_KEEP_LAST_HISTORY_QOS; wr_qos.history.depth = HISTORY; #endif /* Create a Data Writer. */ dw = DDS_Publisher_create_datawriter (pub, topic, &wr_qos, NULL, 0); if (!dw) { printf ("Unable to create vector3 message writer.\r\n"); exit (1); } if (verbose) printf ("DDS Vector3 message writer created.\r\n"); sub = DDS_DomainParticipant_create_subscriber (part, NULL, NULL, 0); if (!sub) { printf ("DDS_DomainParticipant_create_subscriber () returned an error!\r\n"); exit (1); } if (verbose) printf ("DDS Subscriber created.\r\n"); DDS_Subscriber_get_default_datareader_qos (sub, &rd_qos); #ifdef TRANSIENT_LOCAL rd_qos.durability.kind = DDS_TRANSIENT_LOCAL_DURABILITY_QOS; #endif #ifdef RELIABLE rd_qos.reliability.kind = DDS_RELIABLE_RELIABILITY_QOS; #endif #ifdef KEEP_ALL rd_qos.history.kind = DDS_KEEP_ALL_HISTORY_QOS; rd_qos.history.depth = DDS_LENGTH_UNLIMITED; rd_qos.resource_limits.max_samples_per_instance = HISTORY; rd_qos.resource_limits.max_instances = HISTORY * 10; rd_qos.resource_limits.max_samples = HISTORY * 4; #else rd_qos.history.kind = DDS_KEEP_LAST_HISTORY_QOS; rd_qos.history.depth = HISTORY; #endif dr = DDS_Subscriber_create_datareader (sub, td, &rd_qos, #ifndef WAITSETS &msg_listener, DDS_DATA_AVAILABLE_STATUS); #else NULL, 0); #endif if (!dr) { printf ("DDS_DomainParticipant_create_datareader () returned an error!\r\n"); exit (1); } if (verbose) printf ("DDS Vector message reader created.\r\n"); #ifdef WAITSETS start_imu_reader (dr); #endif // publisher thread //thread_create (rt2, dds_send_imu, dr); // DDS Debug shell thread do_dds_shell (dw); #ifdef WAITSETS stop_imu_reader (dr); #endif DDS_Publisher_delete_datawriter (pub, dw); usleep (200000); error = DDS_DomainParticipant_delete_contained_entities (part); if (verbose) printf ("DDS Entities deleted (error = %u).\r\n", error); Vector3_type_free (ts); if (verbose) printf ("Vector3 Type deleted.\r\n"); error = DDS_DomainParticipantFactory_delete_participant (part); if (verbose) printf ("DDS Participant deleted (error = %u).\r\n", error); #ifdef DDS_SECURITY if (cert_path || key_path || engine_id) cleanup_security (); #endif return (0); }
int dds_chat_main(int argc, char *argv[]) #endif { DDS_DataWriterQos wr_qos; DDS_DataReaderQos rd_qos; DDS_ReturnCode_t error; struct in_addr addr; /* Configure the network */ /* Set up our host address */ addr.s_addr = HTONL(CONFIG_EXAMPLES_UDP_IPADDR); netlib_sethostaddr("eth0", &addr); /* Set up the default router address */ addr.s_addr = HTONL(CONFIG_EXAMPLES_UDP_DRIPADDR); netlib_setdraddr("eth0", &addr); /* Setup the subnet mask */ addr.s_addr = HTONL(CONFIG_EXAMPLES_UDP_NETMASK); netlib_setnetmask("eth0", &addr); /* Start the application */ printf("Network configured, starting DDS chat:\n"); sprintf (user_name, ".pid.%u", getpid ()); do_switches (argc, argv); if (verbose > 1) DDS_Log_stdio (1); DDS_entity_name ("ROS 2.0 embedded"); #ifdef DDS_SECURITY if (cert_path || key_path || engine_id) enable_security (); #endif part = DDS_DomainParticipantFactory_create_participant (domain_id, NULL, NULL, 0); if (!part) { printf ("Can't create participant!\r\n"); exit (1); } if (verbose) printf ("DDS Domain Participant created.\r\n"); ts = ChatMsg_type_new (); if (!ts) { printf ("Can't create chat message type!\r\n"); exit (1); } error = DDS_DynamicTypeSupport_register_type (ts, part, "ChatMsg"); if (error) { printf ("Can't register chat message type.\r\n"); exit (1); } if (verbose) printf ("DDS Topic type ('%s') registered.\r\n", "ChatMsg"); topic = DDS_DomainParticipant_create_topic (part, "Chat", "ChatMsg", NULL, NULL, 0); if (!topic) { printf ("Can't register chat message type.\r\n"); exit (1); } if (verbose) printf ("DDS ChatMsg Topic created.\r\n"); td = DDS_DomainParticipant_lookup_topicdescription (part, "Chat"); if (!td) { printf ("Can't get topicdescription.\r\n"); exit (1); } pub = DDS_DomainParticipant_create_publisher (part, NULL, NULL, 0); if (!pub) { printf ("DDS_DomainParticipant_create_publisher () failed!\r\n"); exit (1); } DDS_Publisher_get_default_datawriter_qos (pub, &wr_qos); #ifdef TRANSIENT_LOCAL wr_qos.durability.kind = DDS_TRANSIENT_LOCAL_DURABILITY_QOS; #endif #ifdef RELIABLE wr_qos.reliability.kind = DDS_RELIABLE_RELIABILITY_QOS; #endif #ifdef KEEP_ALL wr_qos.history.kind = DDS_KEEP_ALL_HISTORY_QOS; wr_qos.history.depth = DDS_LENGTH_UNLIMITED; wr_qos.resource_limits.max_samples_per_instance = HISTORY; wr_qos.resource_limits.max_instances = HISTORY * 10; wr_qos.resource_limits.max_samples = HISTORY * 4; #else wr_qos.history.kind = DDS_KEEP_LAST_HISTORY_QOS; wr_qos.history.depth = HISTORY; #endif /* Create a Data Writer. */ dw = DDS_Publisher_create_datawriter (pub, topic, &wr_qos, NULL, 0); if (!dw) { printf ("Unable to create chat message writer.\r\n"); exit (1); } if (verbose) printf ("DDS Chat message writer created.\r\n"); sub = DDS_DomainParticipant_create_subscriber (part, NULL, NULL, 0); if (!sub) { printf ("DDS_DomainParticipant_create_subscriber () returned an error!\r\n"); exit (1); } if (verbose) printf ("DDS Subscriber created.\r\n"); DDS_Subscriber_get_default_datareader_qos (sub, &rd_qos); #ifdef TRANSIENT_LOCAL rd_qos.durability.kind = DDS_TRANSIENT_LOCAL_DURABILITY_QOS; #endif #ifdef RELIABLE rd_qos.reliability.kind = DDS_RELIABLE_RELIABILITY_QOS; #endif #ifdef KEEP_ALL rd_qos.history.kind = DDS_KEEP_ALL_HISTORY_QOS; rd_qos.history.depth = DDS_LENGTH_UNLIMITED; rd_qos.resource_limits.max_samples_per_instance = HISTORY; rd_qos.resource_limits.max_instances = HISTORY * 10; rd_qos.resource_limits.max_samples = HISTORY * 4; #else rd_qos.history.kind = DDS_KEEP_LAST_HISTORY_QOS; rd_qos.history.depth = HISTORY; #endif dr = DDS_Subscriber_create_datareader (sub, td, &rd_qos, #ifndef WAITSETS &msg_listener, DDS_DATA_AVAILABLE_STATUS); #else NULL, 0); #endif if (!dr) { printf ("DDS_DomainParticipant_create_datareader () returned an error!\r\n"); exit (1); } if (verbose) printf ("DDS Chat message reader created.\r\n"); #ifdef WAITSETS start_chat_reader (dr); #endif do_chat (dw); #ifdef WAITSETS stop_chat_reader (dr); #endif DDS_Publisher_delete_datawriter (pub, dw); usleep (200000); error = DDS_DomainParticipant_delete_contained_entities (part); if (verbose) printf ("DDS Entities deleted (error = %u).\r\n", error); ChatMsg_type_free (ts); if (verbose) printf ("Chat Type deleted.\r\n"); error = DDS_DomainParticipantFactory_delete_participant (part); if (verbose) printf ("DDS Participant deleted (error = %u).\r\n", error); #ifdef DDS_SECURITY if (cert_path || key_path || engine_id) cleanup_security (); #endif return (0); }
void deleteParticipant() { g_status = DDS_DomainParticipantFactory_delete_participant(g_domainParticipantFactory, g_domainParticipant); checkStatus(g_status, "DDS_DomainParticipantFactory_delete_participant"); }
int main ( int argc, char *argv[]) { /* Generic DDS entities */ DDS_DomainParticipantFactory dpf; DDS_DomainParticipant participant; DDS_Topic chatMessageTopic; DDS_Topic nameServiceTopic; DDS_MultiTopic namedMessageTopic; DDS_Subscriber chatSubscriber; /* Type-specific DDS entities */ Chat_ChatMessageTypeSupport chatMessageTS; Chat_NameServiceTypeSupport nameServiceTS; Chat_NamedMessageTypeSupport namedMessageTS; Chat_NamedMessageDataReader chatAdmin; DDS_sequence_Chat_NamedMessage *msgSeq; DDS_SampleInfoSeq *infoSeq; /* QosPolicy holders */ DDS_TopicQos *reliable_topic_qos; DDS_TopicQos *setting_topic_qos; DDS_SubscriberQos *sub_qos; DDS_StringSeq *parameterList; /* DDS Identifiers */ DDS_DomainId_t domain = NULL; DDS_ReturnCode_t status; /* Others */ DDS_unsigned_long i; DDS_boolean terminated = FALSE; char * partitionName; char * chatMessageTypeName = NULL; char * nameServiceTypeName = NULL; char * namedMessageTypeName = NULL; /* Options: MessageBoard [ownID] */ /* Messages having owner ownID will be ignored */ parameterList = DDS_StringSeq__alloc(); checkHandle(parameterList, "DDS_StringSeq__alloc"); parameterList->_length = 1; parameterList->_maximum = 1; parameterList->_buffer = DDS_StringSeq_allocbuf(1); checkHandle(parameterList->_buffer, "DDS_StringSeq_allocbuf"); if (argc > 1) { parameterList->_buffer[0] = DDS_string_alloc ( strlen(argv[1]) ); checkHandle(parameterList->_buffer[0], "DDS_string_alloc"); strcpy (parameterList->_buffer[0], argv[1]); } else { parameterList->_buffer[0] = DDS_string_alloc(1); checkHandle(parameterList->_buffer[0], "DDS_string_alloc"); strcpy (parameterList->_buffer[0], "0"); } /* Create a DomainParticipantFactory and a DomainParticipant (using Default QoS settings. */ dpf = DDS_DomainParticipantFactory_get_instance (); checkHandle(dpf, "DDS_DomainParticipantFactory_get_instance"); participant = DDS_DomainParticipantFactory_create_participant ( dpf, domain, DDS_PARTICIPANT_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); checkHandle(participant, "DDS_DomainParticipantFactory_create_participant"); /* Register the required datatype for ChatMessage. */ chatMessageTS = Chat_ChatMessageTypeSupport__alloc(); checkHandle(chatMessageTS, "Chat_ChatMessageTypeSupport__alloc"); chatMessageTypeName = Chat_ChatMessageTypeSupport_get_type_name(chatMessageTS); status = Chat_ChatMessageTypeSupport_register_type( chatMessageTS, participant, chatMessageTypeName); checkStatus(status, "Chat_ChatMessageTypeSupport_register_type"); /* Register the required datatype for NameService. */ nameServiceTS = Chat_NameServiceTypeSupport__alloc(); checkHandle(nameServiceTS, "Chat_NameServiceTypeSupport__alloc"); nameServiceTypeName = Chat_NameServiceTypeSupport_get_type_name(nameServiceTS); status = Chat_NameServiceTypeSupport_register_type( nameServiceTS, participant, nameServiceTypeName); checkStatus(status, "Chat_NameServiceTypeSupport_register_type"); /* Register the required datatype for NamedMessage. */ namedMessageTS = Chat_NamedMessageTypeSupport__alloc(); checkHandle(namedMessageTS, "Chat_NamedMessageTypeSupport__alloc"); namedMessageTypeName = Chat_NamedMessageTypeSupport_get_type_name(namedMessageTS); status = Chat_NamedMessageTypeSupport_register_type( namedMessageTS, participant, namedMessageTypeName); checkStatus(status, "Chat_NamedMessageTypeSupport_register_type"); /* Set the ReliabilityQosPolicy to RELIABLE. */ reliable_topic_qos = DDS_TopicQos__alloc(); checkHandle(reliable_topic_qos, "DDS_TopicQos__alloc"); status = DDS_DomainParticipant_get_default_topic_qos(participant, reliable_topic_qos); checkStatus(status, "DDS_DomainParticipant_get_default_topic_qos"); reliable_topic_qos->reliability.kind = DDS_RELIABLE_RELIABILITY_QOS; /* Make the tailored QoS the new default. */ status = DDS_DomainParticipant_set_default_topic_qos(participant, reliable_topic_qos); checkStatus(status, "DDS_DomainParticipant_set_default_topic_qos"); /* Use the changed policy when defining the ChatMessage topic */ chatMessageTopic = DDS_DomainParticipant_create_topic( participant, "Chat_ChatMessage", chatMessageTypeName, reliable_topic_qos, NULL, DDS_STATUS_MASK_NONE); checkHandle(chatMessageTopic, "DDS_DomainParticipant_create_topic (ChatMessage)"); /* Set the DurabilityQosPolicy to TRANSIENT. */ setting_topic_qos = DDS_TopicQos__alloc(); checkHandle(setting_topic_qos, "DDS_TopicQos__alloc"); status = DDS_DomainParticipant_get_default_topic_qos(participant, setting_topic_qos); checkStatus(status, "DDS_DomainParticipant_get_default_topic_qos"); setting_topic_qos->durability.kind = DDS_TRANSIENT_DURABILITY_QOS; /* Create the NameService Topic. */ nameServiceTopic = DDS_DomainParticipant_create_topic( participant, "Chat_NameService", nameServiceTypeName, setting_topic_qos, NULL, DDS_STATUS_MASK_NONE); checkHandle(nameServiceTopic, "DDS_DomainParticipant_create_topic"); /* Create a multitopic that substitutes the userID with its corresponding userName. */ namedMessageTopic = DDS_DomainParticipant_create_simulated_multitopic( participant, "Chat_NamedMessage", namedMessageTypeName, "SELECT userID, name AS userName, index, content " "FROM Chat_NameService NATURAL JOIN Chat_ChatMessage WHERE userID <> %0", parameterList); checkHandle(namedMessageTopic, "DDS_DomainParticipant_simulate_multitopic"); /* Adapt the default SubscriberQos to read from the "ChatRoom" Partition. */ partitionName = "ChatRoom"; sub_qos = DDS_SubscriberQos__alloc(); checkHandle(sub_qos, "DDS_SubscriberQos__alloc"); status = DDS_DomainParticipant_get_default_subscriber_qos (participant, sub_qos); checkStatus(status, "DDS_DomainParticipant_get_default_subscriber_qos"); sub_qos->partition.name._length = 1; sub_qos->partition.name._maximum = 1; sub_qos->partition.name._buffer = DDS_StringSeq_allocbuf (1); checkHandle(sub_qos->partition.name._buffer, "DDS_StringSeq_allocbuf"); sub_qos->partition.name._buffer[0] = DDS_string_alloc ( strlen(partitionName) ); checkHandle(sub_qos->partition.name._buffer[0], "DDS_string_alloc"); strcpy (sub_qos->partition.name._buffer[0], partitionName); /* Create a Subscriber for the MessageBoard application. */ chatSubscriber = DDS_DomainParticipant_create_subscriber(participant, sub_qos, NULL, DDS_STATUS_MASK_NONE); checkHandle(chatSubscriber, "DDS_DomainParticipant_create_subscriber"); /* Create a DataReader for the NamedMessage Topic (using the appropriate QoS). */ chatAdmin = DDS_Subscriber_create_datareader( chatSubscriber, namedMessageTopic, DDS_DATAREADER_QOS_USE_TOPIC_QOS, NULL, DDS_STATUS_MASK_NONE); checkHandle(chatAdmin, "DDS_Subscriber_create_datareader"); /* Print a message that the MessageBoard has opened. */ printf("MessageBoard has opened: send a ChatMessage with userID = -1 to close it....\n\n"); /* Allocate the sequence holders for the DataReader */ msgSeq = DDS_sequence_Chat_NamedMessage__alloc(); checkHandle(msgSeq, "DDS_sequence_Chat_NamedMessage__alloc"); infoSeq = DDS_SampleInfoSeq__alloc(); checkHandle(infoSeq, "DDS_SampleInfoSeq__alloc"); while (!terminated) { /* Note: using read does not remove the samples from unregistered instances from the DataReader. This means that the DataRase would use more and more resources. That's why we use take here instead. */ status = Chat_NamedMessageDataReader_take( chatAdmin, msgSeq, infoSeq, DDS_LENGTH_UNLIMITED, DDS_ANY_SAMPLE_STATE, DDS_ANY_VIEW_STATE, DDS_ALIVE_INSTANCE_STATE ); checkStatus(status, "Chat_NamedMessageDataReader_take"); for (i = 0; i < msgSeq->_length; i++) { Chat_NamedMessage *msg = &(msgSeq->_buffer[i]); if (msg->userID == TERMINATION_MESSAGE) { printf("Termination message received: exiting...\n"); terminated = TRUE; } else { printf ("%s: %s\n", msg->userName, msg->content); } } status = Chat_NamedMessageDataReader_return_loan(chatAdmin, msgSeq, infoSeq); checkStatus(status, "Chat_ChatMessageDataReader_return_loan"); /* Sleep for some amount of time, as not to consume too much CPU cycles. */ Sleep(100); } /* Remove the DataReader */ status = DDS_Subscriber_delete_datareader(chatSubscriber, chatAdmin); checkStatus(status, "DDS_Subscriber_delete_datareader"); /* Remove the Subscriber. */ status = DDS_DomainParticipant_delete_subscriber(participant, chatSubscriber); checkStatus(status, "DDS_DomainParticipant_delete_subscriber"); /* Remove the Topics. */ status = DDS_DomainParticipant_delete_simulated_multitopic(participant, namedMessageTopic); checkStatus(status, "DDS_DomainParticipant_delete_simulated_multitopic"); status = DDS_DomainParticipant_delete_topic(participant, nameServiceTopic); checkStatus(status, "DDS_DomainParticipant_delete_topic (nameServiceTopic)"); status = DDS_DomainParticipant_delete_topic(participant, chatMessageTopic); checkStatus(status, "DDS_DomainParticipant_delete_topic (chatMessageTopic)"); /* De-allocate the QoS policies. */ DDS_free(reliable_topic_qos); DDS_free(setting_topic_qos); DDS_free(sub_qos); // Note that DDS_free recursively de-allocates all indirections as well!! /* De-allocate the type-names and TypeSupport objects. */ DDS_free(namedMessageTypeName); DDS_free(nameServiceTypeName); DDS_free(chatMessageTypeName); DDS_free(namedMessageTS); DDS_free(nameServiceTS); DDS_free(chatMessageTS); /* Remove the DomainParticipant. */ status = DDS_DomainParticipantFactory_delete_participant(dpf, participant); checkStatus(status, "DDS_DomainParticipantFactory_delete_participant"); return 0; }
int OSPL_MAIN(int argc, const char *argv[]) { FILE *testDataFile; char testDataLine[128]; #ifdef _WIN32 char* oldSearchPath; char* newSearchPath; #endif DDS_DomainParticipantFactory domainParticipantFactory; DDS_DomainParticipant domainParticipant = DDS_OBJECT_NIL; os_result result = os_resultSuccess; /** A local configuration file is used : ospllog4cplugin.xml * and a DomainParticpant is created with this configuration */ os_setenv("OSPL_URI", "file://ospllog4cplugin.xml"); #ifdef _WIN32 /** * Iff the patform is windows, the plugin lib directory is added onto the * PATH so it can be loaded */ oldSearchPath = os_getenv(OS_LIB_LOAD_PATH_VAR); if (oldSearchPath == NULL) { oldSearchPath = ""; } newSearchPath = os_malloc(sizeof(".." "lib") + 2 + strlen(oldSearchPath)); sprintf(newSearchPath, "%s%c%s%c%s", "..", OS_FILESEPCHAR, "lib", OS_PATHSEPCHAR, oldSearchPath); os_setenv(OS_LIB_LOAD_PATH_VAR, newSearchPath); os_free(newSearchPath); #endif /** * A single process DomainParticipant is created. */ domainParticipantFactory = DDS_DomainParticipantFactory_get_instance(); if (domainParticipantFactory == NULL) { printf("Error: can't get the domain participant factory.\n"); return -1; } domainParticipant = DDS_DomainParticipantFactory_create_participant(domainParticipantFactory, DDS_DOMAIN_ID_DEFAULT, DDS_PARTICIPANT_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); if (domainParticipant == NULL) { printf("Error: can't create the domain participant. Please check the configuration & the contents of any error logs.\n"); return -1; } /** After a DomainParticipant has been created the log plug-in will have * been initialised and will be in use. Some test data is now loaded and * written as report messages. */ testDataFile = fopen("testdata.txt", "r"); if (testDataFile != NULL) { int i = 0; while (i < 1000 && result == os_resultSuccess) { if (fgets(testDataLine, sizeof(testDataLine), testDataFile) != NULL) { i++; testDataLine[strlen(testDataLine) - 1] = '\0'; OS_REPORT_3 ((os_reportType) (i % (OS_REPAIRED - OS_DEBUG + 1)), "OpenSplice log4c plug-in example", i, "Test data line %d: %s\t\t%s", i, testDataLine, os_reportTypeText[i % (OS_REPAIRED - OS_DEBUG + 1)] ); } else if (i == 0) { OS_REPORT(OS_FATAL, "OpenSplice log4c plug-in example", 0, "Data cannot be read from testsdata.txt."); result = os_resultFail; } else { fseek(testDataFile, 0, SEEK_SET); } } fclose(testDataFile); } DDS_DomainParticipantFactory_delete_participant(domainParticipantFactory, domainParticipant); return result; }
int main (int argc, const char *argv []) { DDS_DomainParticipant part; unsigned sw, sr, dw, dr, i; int error; DDS_entity_name ("Technicolor Interop test"); printf ("Test 1: dynamic type first, then static.\r\n"); printf ("----------------------------------------\r\n"); /* Create a domain participant. */ part = DDS_DomainParticipantFactory_create_participant ( domain_id, NULL, NULL, 0); if (!part) fatal ("DDS_DomainParticipantFactory_create_participant () failed!"); printf ("DDS Domain Participant created.\r\n"); /* Register the dynamic shape topic type. */ register_dynamic_type (part); printf ("DDS dynamic Topic type registered.\r\n"); /* Register the static topic type. */ register_static_type (part); printf ("DDS static Topic type registered.\r\n"); dw = dynamic_writer_create ("Square"); dr = dynamic_reader_create ("Square"); sw = static_writer_create ("Square"); sr = static_reader_create ("Square"); for (i = 0; i < 10; i++) { dynamic_writer_write (dw, "Red", i * 9 + 5, i * 11 + 5); static_writer_write (sw, "Yellow", i * 10, i * 12); usleep (100000); } dynamic_writer_delete (dw); dynamic_reader_delete (dr); static_writer_delete (sw); static_reader_delete (sr); unregister_dynamic_type (); unregister_static_type (); error = DDS_DomainParticipant_delete_contained_entities (part); if (error) fatal ("DDS_DomainParticipant_delete_contained_entities () failed (%s)!", DDS_error (error)); printf ("DDS Entities deleted\r\n"); error = DDS_DomainParticipantFactory_delete_participant (part); if (error) fatal ("DDS_DomainParticipantFactory_delete_participant () failed (%s)!", DDS_error (error)); printf ("DDS Participant deleted\r\n\r\n"); printf ("Test 2: static type first, then dynamic.\r\n"); printf ("----------------------------------------\r\n"); /* Create a domain participant. */ part = DDS_DomainParticipantFactory_create_participant ( domain_id, NULL, NULL, 0); if (!part) fatal ("DDS_DomainParticipantFactory_create_participant () failed!"); printf ("DDS Domain Participant created.\r\n"); /* Register the static topic type. */ register_static_type (part); printf ("DDS static Topic type registered.\r\n"); /* Register the dynamic shape topic type. */ register_dynamic_type (part); printf ("DDS dynamic Topic type registered.\r\n"); sw = static_writer_create ("Circle"); sr = static_reader_create ("Circle"); dw = dynamic_writer_create ("Circle"); dr = dynamic_reader_create ("Circle"); for (i = 0; i < 10; i++) { static_writer_write (sw, "Green", i * 11, i * 13); dynamic_writer_write (dw, "Magenta", i * 10 + 5, i * 12 + 5); usleep (100000); } static_writer_delete (sw); static_reader_delete (sr); dynamic_writer_delete (dw); dynamic_reader_delete (dr); unregister_static_type (); unregister_dynamic_type (); error = DDS_DomainParticipant_delete_contained_entities (part); if (error) fatal ("DDS_DomainParticipant_delete_contained_entities () failed (%s)!", DDS_error (error)); printf ("DDS Entities deleted\r\n"); error = DDS_DomainParticipantFactory_delete_participant (part); if (error) fatal ("DDS_DomainParticipantFactory_delete_participant () failed (%s)!", DDS_error (error)); printf ("DDS Participant deleted\r\n\r\n"); return (0); }
static void test_qos (int enabled) { DDS_DomainParticipantFactoryQos qos; DDS_DomainParticipant p; DDS_Publisher pub; DDS_Subscriber sub; DDS_DataWriter dw; DDS_DataReader dr; DDS_Topic t; DDS_TopicDescription td; DDS_DataReaderQos rq, refrq; DDS_ReturnCode_t r; static unsigned char data [] = { 0x77, 0x88, 0xaa, 0xbb, 0xcc, 0xdd }; unsigned char d2 [sizeof (data) + 1]; unsigned n; int err; v_printf (" - Set factory QoS to %sabled.\r\n", (enabled) ? "en" : "dis"); r = DDS_DomainParticipantFactory_get_qos (&qos); fail_unless (r == DDS_RETCODE_OK); qos.entity_factory.autoenable_created_entities = enabled; r = DDS_DomainParticipantFactory_set_qos (&qos); fail_unless (r == DDS_RETCODE_OK); p = DDS_DomainParticipantFactory_create_participant (0, DDS_PARTICIPANT_QOS_DEFAULT, NULL, 0); fail_unless (p != NULL); r = register_HelloWorldData_type (p); fail_unless (r == DDS_RETCODE_OK); t = DDS_DomainParticipant_create_topic (p, "HelloWorld", TYPE_NAME, DDS_TOPIC_QOS_DEFAULT, NULL, 0); fail_unless (t != NULL); td = DDS_DomainParticipant_lookup_topicdescription (p, "HelloWorld"); fail_unless (td != NULL); sub = DDS_DomainParticipant_create_subscriber (p, NULL, NULL, 0); fail_unless (sub != NULL); DDS_DataReaderQos__init (&refrq); err = dds_seq_from_array (&refrq.user_data, data, sizeof (data)); fail_unless (err == 0); v_printf (" - Create datareader with specific QoS parameters.\r\n"); dr = DDS_Subscriber_create_datareader (sub, td, &refrq, NULL, 0); fail_unless (dr != NULL); memset (&rq, 0, sizeof (rq)); r = DDS_DataReader_get_qos (dr, &rq); n = dds_seq_to_array (&rq.user_data, d2, sizeof (d2)); fail_unless (r == DDS_RETCODE_OK && DDS_SEQ_LENGTH (refrq.user_data.value) == sizeof (data)); n = dds_seq_to_array (&rq.user_data, d2, sizeof (d2)); fail_unless (n == sizeof (data) && !memcmp (data, d2, sizeof (data))); DDS_DataReaderQos__clear (&rq); r = DDS_Subscriber_delete_datareader (sub, dr); fail_unless (r == DDS_RETCODE_OK); v_printf (" - Create datareader with default QoS parameters.\r\n"); dr = DDS_Subscriber_create_datareader (sub, td, DDS_DATAREADER_QOS_DEFAULT, NULL, 0); fail_unless (dr != NULL); pub = DDS_DomainParticipant_create_publisher (p, DDS_PUBLISHER_QOS_DEFAULT, NULL, 0); fail_unless (sub != NULL); dw = DDS_Publisher_create_datawriter (pub, t, DDS_DATAWRITER_QOS_DEFAULT, NULL, 0); fail_unless (dw != NULL); v_printf (" - Update datareader QoS parameters.\r\n"); r = DDS_DataReader_get_qos (dr, &rq); fail_unless (r == DDS_RETCODE_OK); DDS_DataReaderQos__clear (&refrq); fail_unless (r == DDS_RETCODE_OK && !memcmp (&rq, &refrq, sizeof (refrq))); err = dds_seq_from_array (&refrq.user_data, data, sizeof (data)); fail_unless (err == 0); r = DDS_DataReader_set_qos (dr, &refrq); fail_unless (r == DDS_RETCODE_OK); delay (); r = DDS_DataReader_get_qos (dr, &rq); fail_unless (r == DDS_RETCODE_OK && DDS_SEQ_LENGTH (rq.user_data.value) == sizeof (data)); n = dds_seq_to_array (&rq.user_data, d2, sizeof (d2)); fail_unless (n == sizeof (data) && !memcmp (data, d2, sizeof (data))); DDS_DataReaderQos__clear (&refrq); DDS_DataReaderQos__clear (&rq); delay (); if (!enabled) { v_printf (" - Enable all entities.\r\n"); r = DDS_DomainParticipant_enable (p); fail_unless (r == DDS_RETCODE_OK); r = DDS_Topic_enable (t); fail_unless (r == DDS_RETCODE_OK); r = DDS_Publisher_enable (pub); fail_unless (r == DDS_RETCODE_OK); r = DDS_Subscriber_enable (sub); fail_unless (r == DDS_RETCODE_OK); r = DDS_DataWriter_enable (dw); fail_unless (r == DDS_RETCODE_OK); r = DDS_DataReader_enable (dr); fail_unless (r == DDS_RETCODE_OK); sleep (1); } r = DDS_Publisher_delete_datawriter (pub, dw); fail_unless (r == DDS_RETCODE_OK); r = DDS_Subscriber_delete_datareader (sub, dr); fail_unless (r == DDS_RETCODE_OK); r = DDS_DomainParticipant_delete_publisher (p, pub); fail_unless (r == DDS_RETCODE_OK); r = DDS_DomainParticipant_delete_subscriber (p, sub); fail_unless (r == DDS_RETCODE_OK); r = DDS_DomainParticipant_delete_topic (p, t); fail_unless (r == DDS_RETCODE_OK); unregister_HelloWorldData_type (p); r = DDS_DomainParticipantFactory_delete_participant (p); fail_unless (r == DDS_RETCODE_OK); }
int main (int argc, char ** argv) #endif { /* Generic DDS entities */ DDS_DomainParticipantFactory dpf; DDS_DomainParticipant participant; DDS_Topic chatMessageTopic; DDS_Topic nameServiceTopic; DDS_Publisher chatPublisher; /* QosPolicy holders */ DDS_TopicQos *reliable_topic_qos; DDS_TopicQos *setting_topic_qos; DDS_PublisherQos *pub_qos; DDS_DataWriterQos *dw_qos; /* DDS Identifiers */ DDS_DomainId_t domain = NULL; DDS_InstanceHandle_t userHandle; DDS_ReturnCode_t status; /* Type-specific DDS entities */ Chat_ChatMessageTypeSupport chatMessageTS; Chat_NameServiceTypeSupport nameServiceTS; Chat_ChatMessageDataWriter talker; Chat_NameServiceDataWriter nameServer; /* Sample definitions */ Chat_ChatMessage *msg; /* Example on Heap */ Chat_NameService ns; /* Example on Stack */ /* Others */ int ownID = 1; int i; char *chatMessageTypeName = NULL; char *nameServiceTypeName = NULL; char *chatterName = NULL; char *partitionName = NULL; #ifdef INTEGRITY #ifdef CHATTER_QUIT ownID = -1; #else ownID = 1; #endif chatterName = "dds_user"; #else /* Options: Chatter [ownID [name]] */ if (argc > 1) { sscanf(argv[1], "%d", &ownID); if (argc > 2) { chatterName = argv[2]; } } #endif /* Create a DomainParticipantFactory and a DomainParticipant (using Default QoS settings). */ dpf = DDS_DomainParticipantFactory_get_instance (); checkHandle(dpf, "DDS_DomainParticipantFactory_get_instance"); participant = DDS_DomainParticipantFactory_create_participant ( dpf, domain, DDS_PARTICIPANT_QOS_DEFAULT, NULL, DDS_STATUS_MASK_NONE); checkHandle(participant, "DDS_DomainParticipantFactory_create_participant"); /* Register the required datatype for ChatMessage. */ chatMessageTS = Chat_ChatMessageTypeSupport__alloc(); checkHandle(chatMessageTS, "Chat_ChatMessageTypeSupport__alloc"); chatMessageTypeName = Chat_ChatMessageTypeSupport_get_type_name(chatMessageTS); status = Chat_ChatMessageTypeSupport_register_type( chatMessageTS, participant, chatMessageTypeName); checkStatus(status, "Chat_ChatMessageTypeSupport_register_type"); /* Register the required datatype for NameService. */ nameServiceTS = Chat_NameServiceTypeSupport__alloc(); checkHandle(nameServiceTS, "Chat_NameServiceTypeSupport__alloc"); nameServiceTypeName = Chat_NameServiceTypeSupport_get_type_name(nameServiceTS); status = Chat_NameServiceTypeSupport_register_type( nameServiceTS, participant, nameServiceTypeName); checkStatus(status, "Chat_NameServiceTypeSupport_register_type"); /* Set the ReliabilityQosPolicy to RELIABLE. */ reliable_topic_qos = DDS_TopicQos__alloc(); checkHandle(reliable_topic_qos, "DDS_TopicQos__alloc"); status = DDS_DomainParticipant_get_default_topic_qos(participant, reliable_topic_qos); checkStatus(status, "DDS_DomainParticipant_get_default_topic_qos"); reliable_topic_qos->reliability.kind = DDS_RELIABLE_RELIABILITY_QOS; /* Make the tailored QoS the new default. */ status = DDS_DomainParticipant_set_default_topic_qos(participant, reliable_topic_qos); checkStatus(status, "DDS_DomainParticipant_set_default_topic_qos"); /* Use the changed policy when defining the ChatMessage topic */ chatMessageTopic = DDS_DomainParticipant_create_topic( participant, "Chat_ChatMessage", chatMessageTypeName, reliable_topic_qos, NULL, DDS_STATUS_MASK_NONE); checkHandle(chatMessageTopic, "DDS_DomainParticipant_create_topic (ChatMessage)"); /* Set the DurabilityQosPolicy to TRANSIENT. */ setting_topic_qos = DDS_TopicQos__alloc(); checkHandle(setting_topic_qos, "DDS_TopicQos__alloc"); status = DDS_DomainParticipant_get_default_topic_qos(participant, setting_topic_qos); checkStatus(status, "DDS_DomainParticipant_get_default_topic_qos"); setting_topic_qos->durability.kind = DDS_TRANSIENT_DURABILITY_QOS; /* Create the NameService Topic. */ nameServiceTopic = DDS_DomainParticipant_create_topic( participant, "Chat_NameService", nameServiceTypeName, setting_topic_qos, NULL, DDS_STATUS_MASK_NONE); checkHandle(nameServiceTopic, "DDS_DomainParticipant_create_topic"); /* Adapt the default PublisherQos to write into the "ChatRoom" Partition. */ partitionName = "ChatRoom"; pub_qos = DDS_PublisherQos__alloc(); checkHandle(pub_qos, "DDS_PublisherQos__alloc"); status = DDS_DomainParticipant_get_default_publisher_qos (participant, pub_qos); checkStatus(status, "DDS_DomainParticipant_get_default_publisher_qos"); pub_qos->partition.name._length = 1; pub_qos->partition.name._maximum = 1; pub_qos->partition.name._buffer = DDS_StringSeq_allocbuf (1); checkHandle(pub_qos->partition.name._buffer, "DDS_StringSeq_allocbuf"); pub_qos->partition.name._buffer[0] = DDS_string_alloc ( strlen(partitionName) ); checkHandle(pub_qos->partition.name._buffer[0], "DDS_string_alloc"); strcpy (pub_qos->partition.name._buffer[0], partitionName); /* Create a Publisher for the chatter application. */ chatPublisher = DDS_DomainParticipant_create_publisher(participant, pub_qos, NULL, DDS_STATUS_MASK_NONE); checkHandle(chatPublisher, "DDS_DomainParticipant_create_publisher"); /* Create a DataWriter for the ChatMessage Topic (using the appropriate QoS). */ talker = DDS_Publisher_create_datawriter( chatPublisher, chatMessageTopic, DDS_DATAWRITER_QOS_USE_TOPIC_QOS, NULL, DDS_STATUS_MASK_NONE); checkHandle(talker, "DDS_Publisher_create_datawriter (chatMessage)"); /* Create a DataWriter for the NameService Topic (using the appropriate QoS). */ dw_qos = DDS_DataWriterQos__alloc(); checkHandle(dw_qos, "DDS_DataWriterQos__alloc"); status = DDS_Publisher_get_default_datawriter_qos (chatPublisher, dw_qos); checkStatus(status, "DDS_Publisher_get_default_datawriter_qos"); status = DDS_Publisher_copy_from_topic_qos(chatPublisher, dw_qos, setting_topic_qos); checkStatus(status, "DDS_Publisher_copy_from_topic_qos"); dw_qos->writer_data_lifecycle.autodispose_unregistered_instances = FALSE; nameServer = DDS_Publisher_create_datawriter( chatPublisher, nameServiceTopic, dw_qos, NULL, DDS_STATUS_MASK_NONE); checkHandle(nameServer, "DDS_Publisher_create_datawriter (NameService)"); /* Initialize the NameServer attributes located on stack. */ ns.userID = ownID; ns.name = DDS_string_alloc(Chat_MAX_NAME+1); checkHandle(ns.name, "DDS_string_alloc"); if (chatterName) { strncpy (ns.name, chatterName, Chat_MAX_NAME + 1); } else { snprintf(ns.name, Chat_MAX_NAME+1, "Chatter %d", ownID); } /* Write the user-information into the system (registering the instance implicitly). */ status = Chat_NameServiceDataWriter_write(nameServer, &ns, DDS_HANDLE_NIL); checkStatus(status, "Chat_ChatMessageDataWriter_write"); /* Initialize the chat messages on Heap. */ msg = Chat_ChatMessage__alloc(); checkHandle(msg, "Chat_ChatMessage__alloc"); msg->userID = ownID; msg->index = 0; msg->content = DDS_string_alloc(MAX_MSG_LEN); checkHandle(msg->content, "DDS_string_alloc"); if (ownID == TERMINATION_MESSAGE) { snprintf (msg->content, MAX_MSG_LEN, "Termination message."); } else { snprintf (msg->content, MAX_MSG_LEN, "Hi there, I will send you %d more messages.", NUM_MSG); } printf("Writing message: %s\n", msg->content); /* Register a chat message for this user (pre-allocating resources for it!!) */ userHandle = Chat_ChatMessageDataWriter_register_instance(talker, msg); /* Write a message using the pre-generated instance handle. */ status = Chat_ChatMessageDataWriter_write(talker, msg, userHandle); checkStatus(status, "Chat_ChatMessageDataWriter_write"); sleep (1); /* do not run so fast! */ /* Write any number of messages, re-using the existing string-buffer: no leak!!. */ for (i = 1; i <= NUM_MSG && ownID != TERMINATION_MESSAGE; i++) { msg->index = i; snprintf ( msg->content, MAX_MSG_LEN, "Message no. %d", msg->index); printf("Writing message: %s\n", msg->content); status = Chat_ChatMessageDataWriter_write(talker, msg, userHandle); checkStatus(status, "Chat_ChatMessageDataWriter_write"); sleep (1); /* do not run so fast! */ } /* Leave the room by disposing and unregistering the message instance. */ status = Chat_ChatMessageDataWriter_dispose(talker, msg, userHandle); checkStatus(status, "Chat_ChatMessageDataWriter_dispose"); status = Chat_ChatMessageDataWriter_unregister_instance(talker, msg, userHandle); checkStatus(status, "Chat_ChatMessageDataWriter_unregister_instance"); /* Also unregister our name. */ status = Chat_NameServiceDataWriter_unregister_instance(nameServer, &ns, DDS_HANDLE_NIL); checkStatus(status, "Chat_NameServiceDataWriter_unregister_instance"); /* Release the data-samples. */ DDS_free(ns.name); /* ns allocated on stack: explicit de-allocation of indirections!! */ DDS_free(msg); /* msg allocated on heap: implicit de-allocation of indirections!! */ /* Remove the DataWriters */ status = DDS_Publisher_delete_datawriter(chatPublisher, talker); checkStatus(status, "DDS_Publisher_delete_datawriter (talker)"); status = DDS_Publisher_delete_datawriter(chatPublisher, nameServer); checkStatus(status, "DDS_Publisher_delete_datawriter (nameServer)"); /* Remove the Publisher. */ status = DDS_DomainParticipant_delete_publisher(participant, chatPublisher); checkStatus(status, "DDS_DomainParticipant_delete_publisher"); /* Remove the Topics. */ status = DDS_DomainParticipant_delete_topic(participant, nameServiceTopic); checkStatus(status, "DDS_DomainParticipant_delete_topic (nameServiceTopic)"); status = DDS_DomainParticipant_delete_topic(participant, chatMessageTopic); checkStatus(status, "DDS_DomainParticipant_delete_topic (chatMessageTopic)"); /* De-allocate the QoS policies. */ DDS_free(reliable_topic_qos); DDS_free(setting_topic_qos); DDS_free(pub_qos); /* Note that DDS_free recursively de-allocates all indirections as well!! */ /* De-allocate the type-names and TypeSupport objects. */ DDS_free(nameServiceTypeName); DDS_free(chatMessageTypeName); DDS_free(nameServiceTS); DDS_free(chatMessageTS); /* Remove the DomainParticipant. */ status = DDS_DomainParticipantFactory_delete_participant(dpf, participant); checkStatus(status, "DDS_DomainParticipantFactory_delete_participant"); printf("Completed chatter example.\n"); fflush(stdout); return 0; }
static void test_aux (void) { DDS_DomainParticipant p; DDS_Topic t; DDS_TopicDescription td; DDS_Subscriber sub, nsub; DDS_DataReader dr; DDS_StatusCondition sc, sc2; DDS_StatusMask sm; DDS_InstanceHandle_t h, h2; DDS_Duration_t w; DDS_LivelinessChangedStatus lcs; DDS_RequestedDeadlineMissedStatus dms; DDS_RequestedIncompatibleQosStatus iqs; DDS_SampleLostStatus sls; DDS_SampleRejectedStatus srs; DDS_SubscriptionMatchedStatus sms; DDS_InstanceHandleSeq handles; DDS_ReturnCode_t r; p = DDS_DomainParticipantFactory_create_participant (0, DDS_PARTICIPANT_QOS_DEFAULT, NULL, 0); fail_unless (p != NULL); r = register_HelloWorldData_type (p); fail_unless (r == DDS_RETCODE_OK); t = DDS_DomainParticipant_create_topic (p, "HelloWorld", TYPE_NAME, DDS_TOPIC_QOS_DEFAULT, NULL, 0); fail_unless (t != NULL); td = DDS_DomainParticipant_lookup_topicdescription (p, "HelloWorld"); fail_unless (td != NULL); sub = DDS_DomainParticipant_create_subscriber (p, DDS_SUBSCRIBER_QOS_DEFAULT, NULL, 0); fail_unless (sub != NULL); v_printf (" - Test reader auxiliary functions.\r\n"); dr = DDS_Subscriber_create_datareader (sub, td, DDS_DATAREADER_QOS_DEFAULT, NULL, 0); fail_unless (dr != NULL); sc = DDS_DataReader_get_statuscondition (dr); fail_unless (sc != NULL); sc2 = DDS_Entity_get_statuscondition (dr); fail_unless (sc2 == sc); sm = DDS_DataReader_get_status_changes (dr); fail_unless (sm == 0); sm = DDS_Entity_get_status_changes (dr); fail_unless (sm == 0); h = DDS_Entity_get_instance_handle (dr); fail_unless (h != 0); h2 = DDS_DataReader_get_instance_handle (dr); fail_unless (h == h2); r = DDS_DataReader_get_liveliness_changed_status (dr, &lcs); fail_unless (r == DDS_RETCODE_OK); r = DDS_DataReader_get_requested_deadline_missed_status (dr, &dms); fail_unless (r == DDS_RETCODE_OK); r = DDS_DataReader_get_requested_incompatible_qos_status (dr, &iqs); fail_unless (r == DDS_RETCODE_OK); r = DDS_DataReader_get_sample_lost_status (dr, &sls); fail_unless (r == DDS_RETCODE_OK); r = DDS_DataReader_get_sample_rejected_status (dr, &srs); fail_unless (r == DDS_RETCODE_OK); r = DDS_DataReader_get_subscription_matched_status (dr, &sms); fail_unless (r == DDS_RETCODE_OK); td = DDS_DataReader_get_topicdescription (dr); fail_unless ((DDS_Topic) td == t); nsub = DDS_DataReader_get_subscriber (dr); fail_unless (nsub == sub); w.sec = 2; w.nanosec = 0; r = DDS_DataReader_wait_for_historical_data (dr, &w); fail_unless (r == DDS_RETCODE_OK); DDS_InstanceHandleSeq__init (&handles); r = DDS_DataReader_get_matched_publications (dr, &handles); fail_unless (r == DDS_RETCODE_OK); DDS_InstanceHandleSeq__clear (&handles); r = DDS_Subscriber_delete_datareader (sub, dr); fail_unless (r == DDS_RETCODE_OK); r = DDS_DomainParticipant_delete_subscriber (p, sub); fail_unless (r == DDS_RETCODE_OK); r = DDS_DomainParticipant_delete_topic (p, t); fail_unless (r == DDS_RETCODE_OK); unregister_HelloWorldData_type (p); r = DDS_DomainParticipantFactory_delete_participant (p); fail_unless (r == DDS_RETCODE_OK); }
int main(int argc, char* argv[]) { int startTime = mstime(); DDS_PoolConstraints reqs; DDS_DomainParticipant domainParticipant; DDS_Publisher publisher; DDS_Subscriber subscriber; DDS_ReturnCode_t retCode; char *configTopicName[nofConfigTopics]; char *stateTopicName[nofStateTopics]; char *statisticTopicName[nofStatisticTopics]; DDS_Topic configTopic[nofConfigTopics]; DDS_Topic stateTopic[nofStateTopics]; DDS_Topic statisticTopic[nofStatisticTopics]; DDS_DataWriterQos dataWriterQos; DDS_DataWriter configDataWriter[nofConfigTopics]; DDS_DataReaderQos dataReaderQos; DDS_DataReader configDataReader[nofConfigTopics]; DDS_DataReader stateDataReader[nofStateTopics]; DDS_DataReader statisticDataReader[nofStatisticTopics]; #if 0 acceptance_high_end_Config config; acceptance_high_end_State state; acceptance_high_end_Statistic statistic; DDS_InstanceHandle_t configInstance[nofConfigTopics][nofConfigInstances]; DDS_InstanceHandle_t stateInstance[nofStateTopics][nofStateInstances]; DDS_InstanceHandle_t statisticInstance[nofStatisticTopics][nofStatisticInstances]; #endif int i = 0; /*int j = 0;*/ int firstConfigTopic = (argc > 1) ? atoi(argv[1]) : 0; int firstStateTopic = (argc > 2) ? atoi(argv[2]) : 0; int firstStatisticTopic = (argc > 3) ? atoi(argv[3]) : 0; int stagedLoading = (argc > 4) ? atoi(argv[4]) : 0; printf("[0] Config topics start at %d...\r\n", firstConfigTopic); printf("[0] State topics start at %d...\r\n", firstStateTopic); printf("[0] Statistic topics start at %d...\r\n", firstStatisticTopic); printf("[0] Staged loading %s.\r\n", stagedLoading ? "on" : "off"); DDS_program_name (&argc, argv); DDS_entity_name ("Technicolor Limits Manager"); DDS_get_default_pool_constraints(&reqs, ~0, 100); #ifdef MINIMAL_POOLS configure_minimal_pool_constraints (&reqs); #else configure_optimal_pool_constraints (&reqs); #endif DDS_set_pool_constraints (&reqs); #ifdef DDS_DEBUG DDS_Debug_start (); #endif #ifdef TRACE_DATA rtps_dtrace_set (DRTRC_TRACE_ALL); #endif /* Create domain participant... */ domainParticipant = DDS_DomainParticipantFactory_create_participant(0, NULL, NULL, 0); if (!domainParticipant) { fprintf(stderr, "Error creating domain participant.\r\n"); return -1; } printf("[%d] Created domain participant.\r\n", mstime() - startTime); // sleep(1); /* Create publisher... */ publisher = DDS_DomainParticipant_create_publisher(domainParticipant, NULL, NULL, 0); if (!publisher) { fprintf(stderr, "Error creating publisher.\r\n"); return -1; } printf("[%d] Created publisher.\r\n", mstime() - startTime); // sleep(1); /* Create subscriber... */ subscriber = DDS_DomainParticipant_create_subscriber(domainParticipant, NULL, NULL, 0); if (!subscriber) { fprintf(stderr, "Error creating subscriber.\r\n"); return -1; } printf("[%d] Created subscriber.\r\n", mstime() - startTime); // sleep(1); /* Register types... */ retCode = acceptance_high_end_ConfigTypeSupport_register_type(domainParticipant, NULL); if (retCode != DDS_RETCODE_OK) { fprintf(stderr, "Error registering type (%s).\r\n", DDS_error(retCode)); return -1; } printf("[%d] Registered config type.\r\n", mstime() - startTime); retCode = acceptance_high_end_StateTypeSupport_register_type(domainParticipant, NULL); if (retCode != DDS_RETCODE_OK) { fprintf(stderr, "Error registering type (%s).\r\n", DDS_error(retCode)); return -1; } printf("[%d] Registered state type.\r\n", mstime() - startTime); retCode = acceptance_high_end_StatisticTypeSupport_register_type(domainParticipant, NULL); if (retCode != DDS_RETCODE_OK) { fprintf(stderr, "Error registering type (%s).\r\n", DDS_error(retCode)); return -1; } printf("[%d] Registered statistic type.\r\n", mstime() - startTime); // sleep(1); /* Create topics... */ for (i = 0; i < nofConfigTopics; i++) { char topicName[32]; sprintf(topicName, "ConfigTopic%d", firstConfigTopic + i); configTopicName[i] = topicName; configTopic[i] = DDS_DomainParticipant_create_topic(domainParticipant, topicName, acceptance_high_end_ConfigTypeSupport_get_type_name(), NULL, NULL, 0); if (!configTopic[i]) { fprintf(stderr, "Error creating topic.\r\n"); return -1; } } printf("[%d] Created %d config topics.\r\n", mstime() - startTime, nofConfigTopics); for (i = 0; i < nofStateTopics; i++) { char topicName[32]; sprintf(topicName, "StateTopic%d", firstStateTopic + i); stateTopicName[i] = topicName; stateTopic[i] = DDS_DomainParticipant_create_topic(domainParticipant, topicName, acceptance_high_end_StateTypeSupport_get_type_name(), NULL, NULL, 0); if (!stateTopic[i]) { fprintf(stderr, "Error creating topic.\r\n"); return -1; } } printf("[%d] Created %d state topics.\r\n", mstime() - startTime, nofStateTopics); for (i = 0; i < nofStatisticTopics; i++) { char topicName[32]; sprintf(topicName, "StatisticTopic%d", firstStatisticTopic + i); statisticTopicName[i] = topicName; statisticTopic[i] = DDS_DomainParticipant_create_topic(domainParticipant, topicName, acceptance_high_end_StatisticTypeSupport_get_type_name(), NULL, NULL, 0); if (!statisticTopic[i]) { fprintf(stderr, "Error creating topic.\r\n"); return -1; } } printf("[%d] Created %d statistic topics.\r\n", mstime() - startTime, nofStatisticTopics); // sleep(1); /* Create data writers... */ DDS_Publisher_get_default_datawriter_qos(publisher, &dataWriterQos); dataWriterQos.reliability.kind = DDS_RELIABLE_RELIABILITY_QOS; dataWriterQos.durability.kind = DDS_TRANSIENT_LOCAL_DURABILITY_QOS; for (i = 0; i < nofConfigTopics; i++) { configDataWriter[i] = DDS_Publisher_create_datawriter(publisher, configTopic[i], &dataWriterQos, NULL, 0); if (!configDataWriter[i]) { fprintf(stderr, "Error creating data writer.\r\n"); return -1; } } printf("[%d] Created %d config data writers.\r\n", mstime() - startTime, nofConfigTopics); // sleep(1); /* Create data readers... */ DDS_Subscriber_get_default_datareader_qos(subscriber, &dataReaderQos); dataReaderQos.reliability.kind = DDS_RELIABLE_RELIABILITY_QOS; dataReaderQos.durability.kind = DDS_TRANSIENT_LOCAL_DURABILITY_QOS; for (i = 0; i < nofConfigTopics; i++) { configDataReader[i] = DDS_Subscriber_create_datareader(subscriber, DDS_DomainParticipant_lookup_topicdescription(domainParticipant, configTopicName[i]), &dataReaderQos, &configDataReaderListener, DDS_DATA_AVAILABLE_STATUS); if (!configDataReader[i]) { fprintf(stderr, "Error creating data reader.\r\n"); return -1; } } printf("[%d] Created %d config data readers.\r\n", mstime() - startTime, nofConfigTopics); DDS_Subscriber_get_default_datareader_qos(subscriber, &dataReaderQos); dataReaderQos.reliability.kind = DDS_RELIABLE_RELIABILITY_QOS; dataReaderQos.durability.kind = DDS_TRANSIENT_LOCAL_DURABILITY_QOS; for (i = 0; i < nofStateTopics; i++) { stateDataReader[i] = DDS_Subscriber_create_datareader(subscriber, DDS_DomainParticipant_lookup_topicdescription(domainParticipant, stateTopicName[i]), &dataReaderQos, &stateDataReaderListener, DDS_DATA_AVAILABLE_STATUS); if (!stateDataReader[i]) { fprintf(stderr, "Error creating data reader.\r\n"); return -1; } } printf("[%d] Created %d state data readers.\r\n", mstime() - startTime, nofStateTopics); DDS_Subscriber_get_default_datareader_qos(subscriber, &dataReaderQos); for (i = 0; i < nofStatisticTopics; i++) { statisticDataReader[i] = DDS_Subscriber_create_datareader(subscriber, DDS_DomainParticipant_lookup_topicdescription(domainParticipant, statisticTopicName[i]), &dataReaderQos, &statisticDataReaderListener, DDS_DATA_AVAILABLE_STATUS); if (!statisticDataReader[i]) { fprintf(stderr, "Error creating data reader.\r\n"); return -1; } } printf("[%d] Created %d statistic data readers.\r\n", mstime() - startTime, nofStatisticTopics); // sleep(1); /* Lookup instances... */ /*for (i = 0; i < nofConfigTopics; i++) { for (j = 0; j < nofConfigInstances; j++) { config.key = j; configInstance[i][j] = acceptance_high_end_ConfigDataReader_lookup_instance(configDataReader[i], &config); if (!configInstance[i][j]) { fprintf(stderr, "Error looking up instance.\r\n"); break; } } } printf("[%d] Looked up %d config instances.\r\n", mstime() - startTime, nofConfigTopics * nofConfigInstances); for (i = 0; i < nofStateTopics; i++) { for (j = 0; j < nofStateInstances; j++) { state.key = j; stateInstance[i][j] = acceptance_high_end_StateDataReader_lookup_instance(stateDataReader[i], &state); if (!stateInstance[i][j]) { fprintf(stderr, "Error looking up instance.\r\n"); break; } } } printf("[%d] Looked up %d state instances.\r\n", mstime() - startTime, nofStatisticTopics * nofStatisticInstances); for (i = 0; i < nofStatisticTopics; i++) { for (j = 0; j < nofStatisticInstances; j++) { statistic.key = j; statisticInstance[i][j] = acceptance_high_end_StatisticDataReader_lookup_instance(statisticDataReader[i], &statistic); if (!statisticInstance[i][j]) { fprintf(stderr, "Error looking up instance.\r\n"); break; } } } printf("[%d] Looked up %d statistic instances.\r\n", mstime() - startTime, nofStatisticTopics * nofStatisticInstances);*/ // sleep(1); if (stagedLoading) { char file_name[24]; sprintf(file_name, "/tmp/acceptStageLoad0"); FILE *f = fopen(file_name, "w"); fclose(f); } int waitTime = mstime(); int _nofConfigSamples = 0; int _nofStateSamples = 0; int _nofStatisticSamples = 0; while ((mstime() - waitTime) < (TEST_TIME * 1000)) { if ((nofConfigSamples > _nofConfigSamples) || (nofStateSamples > _nofStateSamples) || (nofStatisticSamples > _nofStatisticSamples)) { printf("[%d] Received %d config samples.\r\n", mstime() - startTime, nofConfigSamples); printf("[%d] Received %d state samples.\r\n", mstime() - startTime, nofStateSamples); printf("[%d] Received %d statistic samples.\r\n", mstime() - startTime, nofStatisticSamples); _nofConfigSamples = nofConfigSamples; _nofStateSamples = nofStateSamples; _nofStatisticSamples = nofStatisticSamples; } sleep(1); } /* Delete contained entities... */ // printf (" -- Deleting contained entities.\r\n"); retCode = DDS_DomainParticipant_delete_contained_entities(domainParticipant); if (retCode != DDS_RETCODE_OK) { fprintf(stderr, "Error deleting contained entities.\r\n"); return -1; } // printf ("contained entities deleted!\r\n"); /* Delete domain participants... */ retCode = DDS_DomainParticipantFactory_delete_participant(domainParticipant); if (retCode != DDS_RETCODE_OK) { fprintf(stderr, "Error deleting domain participant.\r\n"); return -1; } printf ("[%d] mgmt completed successfully.\r\n", mstime() - startTime); return 0; }