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;
}
