Writer::Writer(::DDS::DomainParticipant_ptr dp, ::DDS::Topic_ptr topic, int history_depth, int max_samples_per_instance) : dp_(::DDS::DomainParticipant::_duplicate (dp)) { // Create the publisher pub_ = dp->create_publisher(PUBLISHER_QOS_DEFAULT, ::DDS::PublisherListener::_nil(), ::OpenDDS::DCPS::DEFAULT_STATUS_MASK); if (CORBA::is_nil (pub_.in ())) { ACE_ERROR ((LM_ERROR, ACE_TEXT("(%P|%t) create_publisher failed.\n"))); throw TestException() ; } // Create the datawriter ::DDS::DataWriterQos dw_qos; pub_->get_default_datawriter_qos (dw_qos); dw_qos.history.depth = history_depth ; dw_qos.resource_limits.max_samples_per_instance = max_samples_per_instance ; dw_qos.liveliness.lease_duration.sec = static_cast<CORBA::Long> (max_blocking_time.sec ()); dw_qos.liveliness.lease_duration.nanosec = 0 ; dw_ = pub_->create_datawriter(topic, dw_qos, ::DDS::DataWriterListener::_nil(), ::OpenDDS::DCPS::DEFAULT_STATUS_MASK); if (CORBA::is_nil (dw_.in ())) { ACE_ERROR ((LM_ERROR, ACE_TEXT("(%P|%t) create_datawriter failed.\n"))); throw TestException() ; } ::Xyz::FooDataWriter_var foo_dw = ::Xyz::FooDataWriter::_narrow( dw_.in ()); if (CORBA::is_nil (foo_dw.in ())) { ACE_ERROR ((LM_ERROR, ACE_TEXT("(%P|%t) ::Xyz::FooDataWriter::_narrow failed.\n"))); throw TestException() ; } fast_dw_ = dynamic_cast< ::Xyz::FooDataWriterImpl*> (foo_dw.in ()); }
void DDS_Base_Connector_T<CCM_TYPE>::init_publisher ( ::DDS::DomainParticipant_ptr participant, ::DDS::Publisher_ptr & publisher) { DDS4CCM_TRACE ("DDS_Base_Connector_T::init_publisher"); if (::CORBA::is_nil (publisher)) { #if (CIAO_DDS4CCM_NDDS==1) if (this->qos_profile_.in () != 0) { publisher = participant->create_publisher_with_profile ( this->qos_profile_.in (), ::DDS::PublisherListener::_nil (), 0); } else #endif { ::DDS::PublisherQos pqos; DDS::ReturnCode_t const retcode = participant->get_default_publisher_qos (pqos); if (retcode != DDS::RETCODE_OK) { DDS4CCM_ERROR (DDS4CCM_LOG_LEVEL_ERROR, (LM_ERROR, DDS4CCM_INFO "DDS_Base_Connector_T::init_publisher - " "Error: Unable to retrieve get_default_publisher_qos: <%C>\n", ::CIAO::DDS4CCM::translate_retcode (retcode))); throw ::CCM_DDS::InternalError (retcode, 0); } if (this->qos_profile_.in () != 0 && this->qos_xml_) { DDS::ReturnCode_t const retcode_pub_qos = this->qos_xml_->get_publisher_qos ( pqos, this->qos_profile_.in ()); if (retcode_pub_qos != DDS::RETCODE_OK) { DDS4CCM_ERROR (DDS4CCM_LOG_LEVEL_ERROR, (LM_ERROR, DDS4CCM_INFO "DDS_Base_Connector_T::init_publisher - " "Error: Unable to retrieve publisher QOS from XML: <%C>\n", ::CIAO::DDS4CCM::translate_retcode (retcode_pub_qos))); throw ::CCM_DDS::InternalError (retcode_pub_qos, 0); } } #if defined GEN_OSTREAM_OPS if (DDS4CCM_debug_level >= DDS4CCM_LOG_LEVEL_DDS_STATUS) { std::stringstream output; output << pqos; std::string message = output.str(); DDS4CCM_DEBUG (DDS4CCM_LOG_LEVEL_DDS_STATUS, (LM_INFO, DDS4CCM_INFO ACE_TEXT ("DDS_Base_Connector_T::init_publisher - ") ACE_TEXT ("Using publisher QOS <%C>\n"), message.c_str())); } #endif publisher = participant->create_publisher (pqos, ::DDS::PublisherListener::_nil (), 0); } if (!::CORBA::is_nil (publisher)) { DDS4CCM_DEBUG (DDS4CCM_LOG_LEVEL_ACTION, (LM_TRACE, DDS4CCM_INFO "DDS_Base_Connector_T::init_publisher - " "Created publisher " DDS_ENTITY_FORMAT_SPECIFIER " using participant " DDS_ENTITY_FORMAT_SPECIFIER "\n", DDS_ENTITY_LOG (publisher), DDS_ENTITY_LOG (participant))); } else { DDS4CCM_ERROR (DDS4CCM_LOG_LEVEL_DDS_NIL_RETURN, (LM_ERROR, DDS4CCM_INFO "DDS_Base_Connector_T::init_publisher - " "Error: DDS returned a nil publisher.\n")); throw ::CCM_DDS::InternalError (::DDS::RETCODE_ERROR, 0); } } }
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; }
::DDS::Publisher_ptr create_publisher (::DDS::DomainParticipant_ptr participant, int attach_to_udp, int attach_to_multicast, int attach_to_rtps, int attach_to_shmem) { ::DDS::Publisher_var pub; try { // Create the default publisher pub = participant->create_publisher(PUBLISHER_QOS_DEFAULT, ::DDS::PublisherListener::_nil(), ::OpenDDS::DCPS::DEFAULT_STATUS_MASK); if (CORBA::is_nil (pub.in ())) { ACE_ERROR ((LM_ERROR, ACE_TEXT("(%P|%t) create_publisher failed.\n"))); return ::DDS::Publisher::_nil (); } // Attach the publisher to the transport. if (attach_to_udp) { ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) attach to udp \n"))); TheTransportRegistry->bind_config("udp", pub.in()); } else if (attach_to_multicast) { ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) attach to multicast \n"))); TheTransportRegistry->bind_config("multicast", pub.in()); } else if (attach_to_rtps) { ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) attach to RTPS\n"))); TheTransportRegistry->bind_config("rtps", pub); } else if (attach_to_shmem) { ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) attach to shmem\n"))); TheTransportRegistry->bind_config("shmem", pub); } else { ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) attach to tcp \n"))); TheTransportRegistry->bind_config("tcp", pub.in()); } } catch (const TestException&) { ACE_ERROR ((LM_ERROR, ACE_TEXT("(%P|%t) TestException caught in create_publisher(). "))); return ::DDS::Publisher::_nil () ; } catch (const CORBA::Exception& ex) { ex._tao_print_exception ("Exception caught in create_publisher()."); return ::DDS::Publisher::_nil () ; } catch (const OpenDDS::DCPS::Transport::MiscProblem &) { ACE_ERROR((LM_ERROR, ACE_TEXT("(%P|%t) Transport::MiscProblem exception caught during processing.\n") )); return ::DDS::Publisher::_nil () ; } return pub._retn (); }
void Publication::enable( ::DDS::DomainParticipant_ptr participant, ::DDS::Topic_ptr topic ) { if( this->enabled_) { if( this->verbose_) { ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) Publication::enable() - publication %C: ") ACE_TEXT("already enabled, declining to process.\n"), this->name_.c_str() )); } return; } // Create the publisher. publisher_ = participant->create_publisher( this->profile_->publisherQos, ::DDS::PublisherListener::_nil(), ::OpenDDS::DCPS::DEFAULT_STATUS_MASK ); if( CORBA::is_nil( publisher_.in())) { ACE_ERROR((LM_ERROR, ACE_TEXT("(%P|%t) Publication::enable() - publication %C: ") ACE_TEXT("failed to create publisher.\n"), this->name_.c_str() )); throw BadPublisherException(); } OpenDDS::DCPS::TransportConfig_rch transport = TheTransportRegistry->get_config(this->profile_->transportConfig); if (transport.is_nil() || transport->instances_.empty()) { ACE_ERROR((LM_ERROR, ACE_TEXT("(%P|%t) Publication::enable() - publication %C: ") ACE_TEXT("failed to get_config() OR got empty config with name %C.\n"), this->name_.c_str(), this->profile_->transportConfig.c_str() )); throw BadTransportException(); } if (this->verbose_) { OpenDDS::DCPS::MulticastInst* mcconfig = dynamic_cast<OpenDDS::DCPS::MulticastInst*>( transport->instances_[0].in() ); bool isMcast = false; bool isReliable = false; if (mcconfig != 0) { isMcast = true; isReliable = mcconfig->reliable_; } ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) Publication::enable() - publication %C: ") ACE_TEXT("%C %C transport with config %C.\n"), this->name_.c_str(), (!isMcast? "obtained": (isReliable? "obtained reliable": "obtained best effort" )), transport->instances_[0]->transport_type_.c_str(), this->profile_->transportConfig.c_str() )); } // Attach the transport TheTransportRegistry->bind_config(transport, publisher_); if (this->verbose_) { ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) Publication::enable() - publication %C: ") ACE_TEXT("attached transport with config %C to publisher.\n"), this->name_.c_str(), this->profile_->transportConfig.c_str() )); } // Derive the writer Qos values. ::DDS::TopicQos topicQos; topic->get_qos( topicQos); ::DDS::DataWriterQos writerQos; publisher_->get_default_datawriter_qos( writerQos); publisher_->copy_from_topic_qos( writerQos, topicQos); this->profile_->copyToWriterQos( writerQos); // Create the writer. DDS::DataWriter_var writer = publisher_->create_datawriter( topic, writerQos, ::DDS::DataWriterListener::_nil(), ::OpenDDS::DCPS::DEFAULT_STATUS_MASK ); if( CORBA::is_nil( writer.in())) { ACE_ERROR((LM_ERROR, ACE_TEXT("(%P|%t) Publication::enable() - publication %C: ") ACE_TEXT("failed to create writer.\n"), this->name_.c_str() )); throw BadWriterException(); } else if( this->verbose_) { ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) Publication::enable() - publication %C: ") ACE_TEXT("created writer.\n"), this->name_.c_str() )); } this->writer_ = Test::DataDataWriter::_narrow( writer.in()); if( CORBA::is_nil( this->writer_.in())) { ACE_ERROR((LM_ERROR, ACE_TEXT("(%P|%t) Publication::enable() - publication %C: ") ACE_TEXT("failed to narrow writer for Test::Data type.\n"), this->name_.c_str() )); throw BadWriterException(); } else if( this->verbose_) { ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) Publication::enable() - publication %C: ") ACE_TEXT("narrowed writer for Test::Data type.\n"), this->name_.c_str() )); } // We can finally indicate successful completion. this->enabled_ = true; }