void test_setup(const DomainParticipant_var& dp, const MessageTypeSupport_var& ts, const Publisher_var& pub, const Subscriber_var& sub, const char* topicName, DataWriter_var& dw, DataReader_var& dr) { Topic_var topic = dp->create_topic(topicName, ts->get_type_name(), TOPIC_QOS_DEFAULT, 0, DEFAULT_STATUS_MASK); DataWriterQos dw_qos; pub->get_default_datawriter_qos(dw_qos); dw_qos.history.kind = KEEP_ALL_HISTORY_QOS; dw = pub->create_datawriter(topic, dw_qos, 0, DEFAULT_STATUS_MASK); DataReaderQos dr_qos; sub->get_default_datareader_qos(dr_qos); dr_qos.history.kind = KEEP_ALL_HISTORY_QOS; dr = sub->create_datareader(topic, dr_qos, 0, DEFAULT_STATUS_MASK); StatusCondition_var dw_sc = dw->get_statuscondition(); dw_sc->set_enabled_statuses(PUBLICATION_MATCHED_STATUS); WaitSet_var ws = new WaitSet; ws->attach_condition(dw_sc); Duration_t infinite = {DURATION_INFINITE_SEC, DURATION_INFINITE_NSEC}; ConditionSeq active; ws->wait(active, infinite); ws->detach_condition(dw_sc); }
int run_test(int argc, ACE_TCHAR *argv[]) { DomainParticipantFactory_var dpf = TheParticipantFactoryWithArgs(argc, argv); DomainParticipant_var dp = dpf->create_participant(23, PARTICIPANT_QOS_DEFAULT, 0, DEFAULT_STATUS_MASK); MessageTypeSupport_var ts = new MessageTypeSupportImpl; ts->register_type(dp, ""); Publisher_var pub = dp->create_publisher(PUBLISHER_QOS_DEFAULT, 0, DEFAULT_STATUS_MASK); TransportImpl_rch pub_tport = TheTransportFactory->create_transport_impl(1, AUTO_CONFIG); PublisherImpl* pub_impl = dynamic_cast<PublisherImpl*>(pub.in()); pub_impl->attach_transport(pub_tport.in()); Subscriber_var sub = dp->create_subscriber(SUBSCRIBER_QOS_DEFAULT, 0, DEFAULT_STATUS_MASK); TransportImpl_rch sub_tport = TheTransportFactory->create_transport_impl(2, AUTO_CONFIG); SubscriberImpl* sub_impl = dynamic_cast<SubscriberImpl*>(sub.in()); sub_impl->attach_transport(sub_tport.in()); bool passed = run_sorting_test(dp, ts, pub, sub); passed &= run_filtering_test(dp, ts, pub, sub); dp->delete_contained_entities(); dpf->delete_participant(dp); return passed ? 0 : 1; }
void recreate_data_writer_and_topic(DataWriter_var& dw, const DataReader_var& dr) { DataWriterQos dw_qos; dw->get_qos(dw_qos); Topic_var topic = dw->get_topic(); TopicQos topic_qos; topic->get_qos(topic_qos); CORBA::String_var topic_name = topic->get_name(), type_name = topic->get_type_name(); Publisher_var pub = dw->get_publisher(); DomainParticipant_var dp = pub->get_participant(); pub->delete_datawriter(dw); dw = 0; dp->delete_topic(topic); topic = 0; // Wait until the data reader is not associated with the writer. wait_match (dr, 0); topic = dp->create_topic(topic_name, type_name, topic_qos, 0, 0); if (!topic) { ACE_DEBUG((LM_ERROR, "ERROR: %P failed to re-create topic\n")); return; } dw = pub->create_datawriter(topic, dw_qos, 0, 0); if (!dw) { ACE_DEBUG((LM_ERROR, "ERROR: %P failed to re-create data writer\n")); } }
int ACE_TMAIN(int argc, ACE_TCHAR *argv[]) { try { CORBA::ORB_var orb = CORBA::ORB_init (argc, argv); if (parse_args (argc, argv) != 0) return 1; CORBA::Object_var poa_object = orb->resolve_initial_references("RootPOA"); if (CORBA::is_nil (poa_object.in ())) ACE_ERROR_RETURN ((LM_ERROR, " (%P|%t) Unable to initialize the POA.\n"), 1); PortableServer::POA_var root_poa = PortableServer::POA::_narrow ( poa_object.in ()); PortableServer::POAManager_var poa_manager = root_poa->the_POAManager(); Subscriber_impl subscriber(orb.in ()); PortableServer::ObjectId_var id = root_poa->activate_object (&subscriber); CORBA::Object_var object = root_poa->id_to_reference (id.in ()); Subscriber_var subscriber_var = Subscriber::_narrow (object.in ()); object = orb->string_to_object(ior); Publisher_var publisher = Publisher::_narrow(object.in()); publisher->subscribe(subscriber_var.in()); poa_manager->activate(); ThreadPool pool (orb.in ()); if (pool.activate(THR_NEW_LWP | THR_JOINABLE, 5) != 0) ACE_ERROR_RETURN ((LM_ERROR, "Cannot activate client threads\n"), 1); pool.thr_mgr ()->wait (); ACE_DEBUG ((LM_DEBUG, "event loop finished\n")); } catch (const CORBA::Exception& ex) { ex._tao_print_exception ("Exception caught:"); return 1; } return 0; }
Writer(const Publisher_var& pub, const char* topic_name, const DomainParticipant_var& other_participant) : ts_(new typename ::OpenDDS::DCPS::DDSTraits<MessageType>::TypeSupportTypeImpl()) { DomainParticipant_var dp = pub->get_participant(); check(ts_->register_type(dp, "")); check(ts_->register_type(other_participant, "")); CORBA::String_var type_name = ts_->get_type_name(); Topic_var topic = dp->create_topic(topic_name, type_name, TOPIC_QOS_DEFAULT, 0, DEFAULT_STATUS_MASK); Topic_var topic2 = other_participant->create_topic(topic_name, type_name, TOPIC_QOS_DEFAULT, 0, DEFAULT_STATUS_MASK); dw_ = pub->create_datawriter(topic, DATAWRITER_QOS_DEFAULT, 0, DEFAULT_STATUS_MASK); }
DataWriter_var create_data_writer(const DomainParticipant_var& dp2) { TypeSupport_var ts = new TestMsgTypeSupportImpl; if (ts->register_type(dp2, "") != RETCODE_OK) { ACE_DEBUG((LM_ERROR, "ERROR: %P failed to register type support\n")); return 0; } TopicQos topic_qos; dp2->get_default_topic_qos(topic_qos); set_qos(topic_qos.topic_data.value, TestConfig::TOPIC_DATA()); CORBA::String_var type_name = ts->get_type_name(); Topic_var topic = dp2->create_topic("Movie Discussion List", type_name, topic_qos, 0, DEFAULT_STATUS_MASK); if (!topic) { ACE_DEBUG((LM_ERROR, "ERROR: %P failed to create topic\n")); return 0; } Publisher_var pub = dp2->create_publisher(PUBLISHER_QOS_DEFAULT, 0, DEFAULT_STATUS_MASK); if (!pub) { ACE_DEBUG((LM_ERROR, "ERROR: %P failed to create publisher\n")); return 0; } DataWriterQos dw_qos; pub->get_default_datawriter_qos(dw_qos); set_qos(dw_qos.user_data.value, TestConfig::DATA_WRITER_USER_DATA()); DataWriter_var dw = pub->create_datawriter(topic, dw_qos, 0, DEFAULT_STATUS_MASK); if (!dw) { ACE_DEBUG((LM_ERROR, "ERROR: %P failed to create data writer\n")); return 0; } return dw; }
int run_test(int argc, ACE_TCHAR *argv[]) { using namespace DDS; using namespace OpenDDS::DCPS; WaitSet_var ws = new WaitSet; DomainParticipantFactory_var dpf = TheParticipantFactoryWithArgs(argc, argv); DomainParticipant_var dp = dpf->create_participant(23, PARTICIPANT_QOS_DEFAULT, 0, ::OpenDDS::DCPS::DEFAULT_STATUS_MASK); Messenger::MessageTypeSupport_var ts = new Messenger::MessageTypeSupportImpl; ts->register_type(dp, ts->get_type_name()); Topic_var topic = dp->create_topic("MyTopic", ts->get_type_name(), TOPIC_QOS_DEFAULT, 0, ::OpenDDS::DCPS::DEFAULT_STATUS_MASK); Publisher_var pub = dp->create_publisher(PUBLISHER_QOS_DEFAULT, 0, ::OpenDDS::DCPS::DEFAULT_STATUS_MASK); TransportImpl_rch pub_tport = TheTransportFactory->create_transport_impl(1, AUTO_CONFIG); PublisherImpl* pub_impl = dynamic_cast<PublisherImpl*> (pub.in()); pub_impl->attach_transport(pub_tport.in()); DataWriter_var dw = pub->create_datawriter(topic, DATAWRITER_QOS_DEFAULT, 0, ::OpenDDS::DCPS::DEFAULT_STATUS_MASK); StatusCondition_var cond = dw->get_statuscondition(); cond->set_enabled_statuses(OFFERED_INCOMPATIBLE_QOS_STATUS); ws->attach_condition(cond); Subscriber_var sub = dp->create_subscriber(SUBSCRIBER_QOS_DEFAULT, 0, ::OpenDDS::DCPS::DEFAULT_STATUS_MASK); TransportImpl_rch sub_tport = TheTransportFactory->create_transport_impl(2, AUTO_CONFIG); SubscriberImpl* sub_impl = dynamic_cast<SubscriberImpl*> (sub.in()); sub_impl->attach_transport(sub_tport.in()); DataReaderQos dr_qos; sub->get_default_datareader_qos(dr_qos); dr_qos.durability.kind = PERSISTENT_DURABILITY_QOS; Waiter w(ws); w.activate(); DataReader_var dr = sub->create_datareader(topic, dr_qos, 0, ::OpenDDS::DCPS::DEFAULT_STATUS_MASK); w.wait(); bool passed = (w.result() == RETCODE_OK); ws->detach_condition(cond); dp->delete_contained_entities(); dpf->delete_participant(dp); return passed ? 0 : 1; }
int run_test_instance(DDS::DomainParticipant_ptr dp) { using namespace DDS; using namespace OpenDDS::DCPS; using namespace Messenger; WaitSet_var ws = new WaitSet; MessageTypeSupport_var ts = new MessageTypeSupportImpl; ts->register_type(dp, ""); CORBA::String_var type_name = ts->get_type_name(); Topic_var topic = dp->create_topic("MyTopic", type_name, TOPIC_QOS_DEFAULT, 0, ::OpenDDS::DCPS::DEFAULT_STATUS_MASK); Publisher_var pub = dp->create_publisher(PUBLISHER_QOS_DEFAULT, 0, ::OpenDDS::DCPS::DEFAULT_STATUS_MASK); DataWriter_var dw = pub->create_datawriter(topic, DATAWRITER_QOS_DEFAULT, 0, ::OpenDDS::DCPS::DEFAULT_STATUS_MASK); Subscriber_var sub = dp->create_subscriber(SUBSCRIBER_QOS_DEFAULT, 0, ::OpenDDS::DCPS::DEFAULT_STATUS_MASK); DataReader_var dr = sub->create_datareader(topic, DATAREADER_QOS_DEFAULT, 0, ::OpenDDS::DCPS::DEFAULT_STATUS_MASK); StatusCondition_var dw_sc = dw->get_statuscondition(); dw_sc->set_enabled_statuses(PUBLICATION_MATCHED_STATUS); ws->attach_condition(dw_sc); Duration_t infinite = {DURATION_INFINITE_SEC, DURATION_INFINITE_NSEC}; ConditionSeq active; ReturnCode_t ret = ws->wait(active, infinite); if (ret != RETCODE_OK) return ret; ret = ws->detach_condition(dw_sc); if (ret != RETCODE_OK) return ret; MessageDataWriter_var mdw = MessageDataWriter::_narrow(dw); Message msg = {0}; for (int i(0); i < 12; ++i) { ++msg.subject_id; ret = mdw->write(msg, HANDLE_NIL); if (ret != RETCODE_OK) return ret; } ReadCondition_var dr_rc = dr->create_readcondition(NOT_READ_SAMPLE_STATE, NEW_VIEW_STATE, ALIVE_INSTANCE_STATE); ReadCondition_var dr_rc2 = dr->create_readcondition(ANY_SAMPLE_STATE, ANY_VIEW_STATE, NOT_ALIVE_DISPOSED_INSTANCE_STATE); ws->attach_condition(dr_rc); ws->attach_condition(dr_rc2); MessageDataReader_var mdr = MessageDataReader::_narrow(dr); bool passed = true, done = false; while (!done) { ret = ws->wait(active, infinite); if (ret != RETCODE_OK) { passed = false; break; } cout << "wait returned" << endl; for (CORBA::ULong i(0); i < active.length(); ++i) { if (active[i] == dr_rc) { // To test both take_w_condition and // take_next_instance_w_condition, we'll limit the "take" to 3 // samples and then use take_next_instance_w_condition. MessageSeq data; SampleInfoSeq info; ret = mdr->take_w_condition(data, info, 3, dr_rc); if (ret == RETCODE_NO_DATA) break; if (ret != RETCODE_OK) { cout << "ERROR: take_w_condition returned " << ret << endl; passed = false; done = true; } InstanceHandle_t handle = HANDLE_NIL; received_data(data, mdw, msg); handle = info[info.length() - 1].instance_handle; if (handle == HANDLE_NIL) { cout << "ERROR: instance handle is nil" << endl; passed = false; done = true; break; } cout << "testing take_instance_w_condition" << endl; while (true) { ret = mdr->take_instance_w_condition(data, info, 1, handle, dr_rc); if (ret == RETCODE_NO_DATA) break; if (ret != RETCODE_OK) { cout << "ERROR: take_instance_w_condition returned " << ret << endl; passed = false; done = true; break; } received_data(data, mdw, msg); } } else if (active[i] == dr_rc2) { cout << "an instance has been disposed, exiting" << endl; done = true; } } } ws->detach_condition(dr_rc); ws->detach_condition(dr_rc2); dp->delete_contained_entities(); return passed ? 0 : 1; }
int OSPL_MAIN ( int argc, char *argv[]) { /* Generic DDS entities */ DomainParticipantFactory_var dpf; DomainParticipant_var participant; Topic_var chatMessageTopic; Publisher_var chatPublisher; DataWriter_ptr parentWriter; /* QosPolicy holders */ TopicQos reliable_topic_qos; PublisherQos pub_qos; DataWriterQos dw_qos; /* DDS Identifiers */ DomainId_t domain = 0; InstanceHandle_t userHandle; ReturnCode_t status; /* Type-specific DDS entities */ ChatMessageTypeSupport_var chatMessageTS; ChatMessageDataWriter_var talker; /* Sample definitions */ ChatMessage *msg; /* Example on Heap */ /* Others */ int ownID = 1; int i; const char *partitionName = "ChatRoom1"; char *chatMessageTypeName = NULL; char buf[MAX_MSG_LEN]; #ifdef INTEGRITY #ifdef CHATTER_QUIT ownID = -1; #else ownID = 1; #endif #else /* Options: Chatter [ownID] */ if (argc > 1) { ownID = atoi(argv[1]); } #endif /* Create a DomainParticipantFactory and a DomainParticipant (using Default QoS settings. */ dpf = DomainParticipantFactory::get_instance (); checkHandle(dpf.in(), "DDS::DomainParticipantFactory::get_instance"); participant = dpf->create_participant(domain, PARTICIPANT_QOS_DEFAULT, NULL, STATUS_MASK_NONE); checkHandle(participant.in(), "DDS::DomainParticipantFactory::create_participant"); /* Register the required datatype for ChatMessage. */ chatMessageTS = new ChatMessageTypeSupport(); checkHandle(chatMessageTS.in(), "new ChatMessageTypeSupport"); chatMessageTypeName = chatMessageTS->get_type_name(); status = chatMessageTS->register_type( participant.in(), chatMessageTypeName); checkStatus(status, "NetworkPartitionsData::ChatMessageTypeSupport::register_type"); /* Set the ReliabilityQosPolicy to RELIABLE. */ status = participant->get_default_topic_qos(reliable_topic_qos); checkStatus(status, "DDS::DomainParticipant::get_default_topic_qos"); reliable_topic_qos.reliability.kind = RELIABLE_RELIABILITY_QOS; /* Make the tailored QoS the new default. */ status = participant->set_default_topic_qos(reliable_topic_qos); checkStatus(status, "DDS::DomainParticipant::set_default_topic_qos"); /* Use the changed policy when defining the ChatMessage topic */ chatMessageTopic = participant->create_topic( "Chat_ChatMessage", chatMessageTypeName, reliable_topic_qos, NULL, STATUS_MASK_NONE); checkHandle(chatMessageTopic.in(), "DDS::DomainParticipant::create_topic (ChatMessage)"); /* Adapt the default PublisherQos to write into the "ChatRoom1" Partition. */ status = participant->get_default_publisher_qos (pub_qos); checkStatus(status, "DDS::DomainParticipant::get_default_publisher_qos"); pub_qos.partition.name.length(1); pub_qos.partition.name[0] = partitionName; /* Create a Publisher for the chatter application. */ chatPublisher = participant->create_publisher(pub_qos, NULL, STATUS_MASK_NONE); checkHandle(chatPublisher.in(), "DDS::DomainParticipant::create_publisher"); /* Create a DataWriter for the ChatMessage Topic (using the appropriate QoS). */ parentWriter = chatPublisher->create_datawriter( chatMessageTopic.in(), DATAWRITER_QOS_USE_TOPIC_QOS, NULL, STATUS_MASK_NONE); checkHandle(parentWriter, "DDS::Publisher::create_datawriter (chatMessage)"); /* Narrow the abstract parent into its typed representative. */ talker = ChatMessageDataWriter::_narrow(parentWriter); checkHandle(talker.in(), "NetworkPartitionsData::ChatMessageDataWriter::_narrow"); /* Initialize the chat messages on Heap. */ msg = new ChatMessage(); checkHandle(msg, "new ChatMessage"); msg->userID = ownID; msg->index = 0; if (ownID == TERMINATION_MESSAGE) { snprintf(buf, MAX_MSG_LEN, "Termination message."); } else { snprintf(buf, MAX_MSG_LEN, "Hi there, I will send you %d more messages.", NUM_MSG); } msg->content = string_dup(buf); cout << "Writing message: \"" << msg->content << "\"" << endl; /* Register a chat message for this user (pre-allocating resources for it!!) */ userHandle = talker->register_instance(*msg); /* Write a message using the pre-generated instance handle. */ status = talker->write(*msg, userHandle); checkStatus(status, "NetworkPartitionsData::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(buf, MAX_MSG_LEN, "Message no. %d", i); msg->content = string_dup(buf); cout << "Writing message: \"" << msg->content << "\"" << endl; status = talker->write(*msg, userHandle); checkStatus(status, "NetworkPartitionsData::ChatMessageDataWriter::write"); sleep (1); /* do not run so fast! */ } /* Leave the room by disposing and unregistering the message instance. */ status = talker->dispose(*msg, userHandle); checkStatus(status, "NetworkPartitionsData::ChatMessageDataWriter::dispose"); status = talker->unregister_instance(*msg, userHandle); checkStatus(status, "NetworkPartitionsData::ChatMessageDataWriter::unregister_instance"); /* Release the data-samples. */ delete msg; // msg allocated on heap: explicit de-allocation required!! /* Remove the DataWriters */ status = chatPublisher->delete_datawriter( talker.in() ); checkStatus(status, "DDS::Publisher::delete_datawriter (talker)"); /* Remove the Publisher. */ status = participant->delete_publisher( chatPublisher.in() ); checkStatus(status, "DDS::DomainParticipant::delete_publisher"); status = participant->delete_topic( chatMessageTopic.in() ); checkStatus(status, "DDS::DomainParticipant::delete_topic (chatMessageTopic)"); /* Remove the type-names. */ string_free(chatMessageTypeName); /* Remove the DomainParticipant. */ status = dpf->delete_participant( participant.in() ); checkStatus(status, "DDS::DomainParticipantFactory::delete_participant"); cout << "Completed Chatter example" << endl; return 0; }