Reader::Reader(::DDS::DomainParticipant_ptr dp,
int history_depth,
int max_samples_per_instance)
: max_samples_per_instance_(max_samples_per_instance),
dp_(::DDS::DomainParticipant::_duplicate (dp))
{
sub_ = dp->create_subscriber(SUBSCRIBER_QOS_DEFAULT,
::DDS::SubscriberListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (sub_.in ()))
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT("(%P|%t) create_subscriber failed.\n")));
throw TestException() ;
}
::DDS::TopicDescription_var description =
dp->lookup_topicdescription(MY_TOPIC);
if (CORBA::is_nil (description.in ()))
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT("(%P|%t) lookup_topicdescription failed.\n")));
throw TestException() ;
}
::DDS::DataReaderQos dr_qos;
sub_->get_default_datareader_qos (dr_qos);
dr_qos.history.depth = history_depth ;
dr_qos.resource_limits.max_samples_per_instance =
max_samples_per_instance ;
dr_qos.liveliness.lease_duration.sec =
static_cast<CORBA::Long> (max_blocking_time.sec ());
dr_qos.liveliness.lease_duration.nanosec = 0 ;
::DDS::DataReaderListener_var drl (new DataReaderListenerImpl);
::DDS::DataReader_var dr = sub_->create_datareader(description.in (),
dr_qos,
// ::DDS::DataReaderListener::_nil()
drl.in (),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (dr.in ()))
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT("(%P|%t) create_datareader failed.\n")));
throw TestException() ;
}
}
DDS::DataReader_ptr
create_data_reader(DDS::DomainParticipant_ptr participant,
DDS::Subscriber_ptr subscriber,
const char* type_name,
const char* topic_name,
const DDS::DataReaderQos& dr_qos,
DDS::DataReaderListener_ptr drl)
{
DDS::Topic_var topic =
participant->create_topic(topic_name,
type_name,
TOPIC_QOS_DEFAULT,
DDS::TopicListener::_nil(),
OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil(topic)) {
ACE_DEBUG((LM_DEBUG, "create_data_reader(): Failed to create topic, name = %s\n", topic_name));
}
DDS::DataReader_var reader =
subscriber->create_datareader(topic.in(),
dr_qos,
drl,
OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil(reader)) {
ACE_DEBUG((LM_DEBUG, "create_data_reader(): Failed to create data reader\n"));
}
return reader._retn();
}
void
DDS_Base_Connector_T<CCM_TYPE>::remove_subscriber (
::DDS::DomainParticipant_ptr participant,
::DDS::Subscriber_ptr subscriber)
{
DDS4CCM_TRACE ("DDS_Base_Connector_T::remove_subscriber");
DDS4CCM_DEBUG (DDS4CCM_LOG_LEVEL_ACTION_STARTING, (LM_TRACE, DDS4CCM_INFO
"DDS_Base_Connector_T::remove_subscriber - "
"Going to delete subscriber "
DDS_ENTITY_FORMAT_SPECIFIER
" from participant"
DDS_ENTITY_FORMAT_SPECIFIER
"\n",
DDS_ENTITY_LOG (subscriber),
DDS_ENTITY_LOG (participant)));
DDS::ReturnCode_t const retval =
participant->delete_subscriber (subscriber);
if (retval != ::DDS::RETCODE_OK)
{
DDS4CCM_ERROR (DDS4CCM_LOG_LEVEL_ERROR, (LM_ERROR, DDS4CCM_INFO
"DDS_Base_Connector_T::remove_subscriber - "
"Unable to delete subscriber: <%C>\n",
::CIAO::DDS4CCM::translate_retcode (retval)));
throw ::CORBA::INTERNAL ();
}
else
{
DDS4CCM_DEBUG (DDS4CCM_LOG_LEVEL_DDS_STATUS, (LM_INFO, DDS4CCM_INFO
"DDS_Base_Connector_T::remove_subscriber - "
"Deleted subscriber\n"));
}
}
DDS::DataWriter_ptr
MonitorFactoryImpl::create_data_writer(DDS::DomainParticipant_ptr participant,
DDS::Publisher_ptr publisher,
const char* type_name,
const char* topic_name,
const DDS::DataWriterQos& dw_qos)
{
DDS::Topic_var topic =
participant->create_topic(topic_name,
type_name,
TOPIC_QOS_DEFAULT,
DDS::TopicListener::_nil(),
OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil(topic)) {
ACE_DEBUG((LM_DEBUG, "MonitorFactoryImpl::create_data_writer(): Failed to create topic, name = %s\n", topic_name));
}
DDS::DataWriter_var writer =
publisher->create_datawriter(topic.in(),
dw_qos,
DDS::DataWriterListener::_nil(),
OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil(writer)) {
ACE_DEBUG((LM_DEBUG, "MonitorFactoryImpl::create_data_writer(): Failed to create data writer\n"));
}
return writer._retn();
}
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>::remove_topic (
::DDS::DomainParticipant_ptr participant,
::DDS::Topic_ptr topic)
{
DDS4CCM_TRACE ("DDS_Base_Connector_T::remove_topic");
CORBA::String_var name = topic->get_name ();
DDS4CCM_DEBUG (DDS4CCM_LOG_LEVEL_ACTION_STARTING, (LM_TRACE, DDS4CCM_INFO
"DDS_Base_Connector_T::remove_topic - "
"Going to delete topic <%C> "
DDS_ENTITY_FORMAT_SPECIFIER
"from participant"
DDS_ENTITY_FORMAT_SPECIFIER
"\n",
name.in (),
DDS_ENTITY_LOG (topic),
DDS_ENTITY_LOG (participant)));
DDS::ReturnCode_t const retcode = participant->delete_topic (topic);
DDS4CCM_DEBUG (DDS4CCM_LOG_LEVEL_ACTION, (LM_TRACE, DDS4CCM_INFO
"DDS_Base_Connector_T::remove_topic - "
"Deleted topic <%C> "
DDS_ENTITY_FORMAT_SPECIFIER
"from "
DDS_ENTITY_FORMAT_SPECIFIER
" return code <%C>\n",
name.in (),
DDS_ENTITY_LOG (topic),
DDS_ENTITY_LOG (participant),
::CIAO::DDS4CCM::translate_retcode (retcode)));
if (retcode != ::DDS::RETCODE_OK && retcode != ::DDS::RETCODE_PRECONDITION_NOT_MET)
{
throw ::CCM_DDS::InternalError (retcode, 0);
}
}
void
DDS_Base_Connector_T<CCM_TYPE>::init_subscriber (
::DDS::DomainParticipant_ptr participant,
::DDS::Subscriber_ptr & subscriber)
{
DDS4CCM_TRACE ("DDS_Base_Connector_T::init_subscriber");
if (::CORBA::is_nil (subscriber))
{
#if (CIAO_DDS4CCM_NDDS==1)
if (this->qos_profile_.in () != 0)
{
subscriber = participant->create_subscriber_with_profile (
this->qos_profile_.in (),
::DDS::SubscriberListener::_nil (),
0);
}
else
#endif
{
::DDS::SubscriberQos sqos;
DDS::ReturnCode_t const retcode =
participant->get_default_subscriber_qos (sqos);
if (retcode != DDS::RETCODE_OK)
{
DDS4CCM_ERROR (DDS4CCM_LOG_LEVEL_ERROR, (LM_ERROR, DDS4CCM_INFO
"DDS_Base_Connector_T::init_subscriber - "
"Error: Unable to retrieve get_default_subscriber_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_sub_qos =
this->qos_xml_->get_subscriber_qos (
sqos,
this->qos_profile_.in ());
if (retcode_sub_qos != DDS::RETCODE_OK)
{
DDS4CCM_ERROR (DDS4CCM_LOG_LEVEL_ERROR, (LM_ERROR, DDS4CCM_INFO
"DDS_Base_Connector_T::init_subscriber - "
"Error: Unable to retrieve subscriber QOS from XML: <%C>\n",
::CIAO::DDS4CCM::translate_retcode (retcode_sub_qos)));
throw ::CCM_DDS::InternalError (retcode_sub_qos, 0);
}
}
#if defined GEN_OSTREAM_OPS
if (DDS4CCM_debug_level >= DDS4CCM_LOG_LEVEL_DDS_STATUS)
{
std::stringstream output;
output << sqos;
std::string message = output.str();
DDS4CCM_DEBUG (DDS4CCM_LOG_LEVEL_DDS_STATUS, (LM_INFO, DDS4CCM_INFO
ACE_TEXT ("DDS_Base_Connector_T::init_subscriber - ")
ACE_TEXT ("Using subscriber QOS <%C>\n"), message.c_str()));
}
#endif
subscriber = participant->create_subscriber (sqos,
::DDS::SubscriberListener::_nil (),
0);
}
if (!::CORBA::is_nil (subscriber))
{
DDS4CCM_DEBUG (DDS4CCM_LOG_LEVEL_ACTION, (LM_TRACE, DDS4CCM_INFO
"DDS_Base_Connector_T::init_subscriber - "
"Created subscriber "
DDS_ENTITY_FORMAT_SPECIFIER
" using participant "
DDS_ENTITY_FORMAT_SPECIFIER
"\n",
DDS_ENTITY_LOG (subscriber),
DDS_ENTITY_LOG (participant)));
}
else
{
DDS4CCM_ERROR (DDS4CCM_LOG_LEVEL_DDS_NIL_RETURN, (LM_ERROR, DDS4CCM_INFO
"DDS_Base_Connector_T::init_subscriber - "
"Error: DDS returned a nil subscriber.\n"));
throw ::CCM_DDS::InternalError (::DDS::RETCODE_ERROR, 0);
}
}
}
void
DDS_Base_Connector_T<CCM_TYPE>::init_topic (
::DDS::DomainParticipant_ptr participant,
::DDS::Topic_ptr & topic,
const char * topic_name,
const char * type_name)
{
DDS4CCM_TRACE ("DDS_Base_Connector_T::init_topic");
::DDS::Duration_t timeout;
timeout.sec = 0;
timeout.nanosec = 0;
DDS4CCM_DEBUG (DDS4CCM_LOG_LEVEL_ACTION_STARTING, (LM_TRACE, DDS4CCM_INFO
"DDS_Base_Connector_T::init_topic - "
"Finding existing topic "
"name <%C> for profile <%C> in participant "
DDS_ENTITY_FORMAT_SPECIFIER "\n",
topic_name, this->qos_profile_.in (),
DDS_ENTITY_LOG (participant)));
::DDS::Topic_var dds_tp =
participant->find_topic (topic_name, timeout);
if (!CORBA::is_nil (dds_tp.in ()))
{
// Re-use topic.
DDS4CCM_DEBUG (DDS4CCM_LOG_LEVEL_ACTION_STARTING, (LM_TRACE, DDS4CCM_INFO
"DDS_Base_Connector_T::init_topic - "
"Re using topic <%C> for profile <%C>\n",
topic_name, this->qos_profile_.in ()));
topic = ::DDS::Topic::_duplicate (dds_tp);
return;
}
#if (CIAO_DDS4CCM_NDDS==1)
if (this->qos_profile_.in () != 0)
{
// Create a new topic
topic = participant->create_topic_with_profile (topic_name,
type_name,
this->qos_profile_.in (),
::DDS::TopicListener::_nil (),
0);
}
else
#endif
{
::DDS::TopicQos tqos;
DDS::ReturnCode_t const retcode =
participant->get_default_topic_qos (tqos);
if (retcode != DDS::RETCODE_OK)
{
DDS4CCM_ERROR (DDS4CCM_LOG_LEVEL_ERROR, (LM_ERROR, DDS4CCM_INFO
"DDS_Base_Connector_T::init_topic - "
"Error: Unable to retrieve default_topic_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_tp_qos =
this->qos_xml_->get_topic_qos (
tqos,
this->qos_profile_.in (),
topic_name);
if (retcode_tp_qos != DDS::RETCODE_OK)
{
DDS4CCM_ERROR (DDS4CCM_LOG_LEVEL_ERROR, (LM_ERROR, DDS4CCM_INFO
"DDS_Base_Connector_T::init_topic - "
"Error: Unable to retrieve topic QOS from XML: <%C>\n",
::CIAO::DDS4CCM::translate_retcode (retcode_tp_qos)));
throw ::CCM_DDS::InternalError (retcode_tp_qos, 0);
}
}
#if defined GEN_OSTREAM_OPS
if (DDS4CCM_debug_level >= DDS4CCM_LOG_LEVEL_DDS_STATUS)
{
std::stringstream output;
output << tqos;
std::string message = output.str();
DDS4CCM_DEBUG (DDS4CCM_LOG_LEVEL_DDS_STATUS, (LM_INFO, DDS4CCM_INFO
ACE_TEXT ("DDS_Base_Connector_T::init_topic - ")
ACE_TEXT ("Using topic QOS <%C>\n"), message.c_str()));
}
#endif
// Create a new topic
topic = participant->create_topic (topic_name,
type_name,
tqos,
::DDS::TopicListener::_nil (),
0);
}
if (!::CORBA::is_nil (topic))
{
DDS4CCM_DEBUG (DDS4CCM_LOG_LEVEL_ACTION_STARTING, (LM_TRACE, DDS4CCM_INFO
"DDS_Base_Connector_T::init_topic - "
"Created new topic "
DDS_ENTITY_FORMAT_SPECIFIER
" name <%C> type <%C> for profile <%C>\n",
DDS_ENTITY_LOG (topic),
topic_name, type_name, this->qos_profile_.in ()));
}
else
{
DDS4CCM_ERROR (DDS4CCM_LOG_LEVEL_DDS_NIL_RETURN, (LM_ERROR, DDS4CCM_INFO
"DDS_Base_Connector_T::init_topic - "
"Error: unable to create new topic <%C> for profile <%C>\n",
topic_name, this->qos_profile_.in ()));
throw ::CCM_DDS::InternalError (::DDS::RETCODE_ERROR, 0);
}
}
void
DDS_Base_Connector_T<CCM_TYPE>::remove_domain (
::DDS::DomainParticipant_ptr participant)
{
DDS4CCM_TRACE ("DDS_Base_Connector_T::remove_domain");
DDS::ReturnCode_t retcode = DDS::RETCODE_OK;
if (DPMANAGER->unregister_participant (
this->domain_id_, this->qos_profile_.in (), participant))
{
DDS4CCM_DEBUG (DDS4CCM_LOG_LEVEL_ACTION, (LM_TRACE, DDS4CCM_INFO
"DDS_Base_Connector_T"
"::remove_domain - "
"Going to delete contained entities of participant "
DDS_ENTITY_FORMAT_SPECIFIER
" for domain <%d> with qos <%C>.\n",
DDS_ENTITY_LOG (participant),
this->domain_id_, this->qos_profile_.in ()));
retcode = participant->delete_contained_entities ();
DDS4CCM_DEBUG (DDS4CCM_LOG_LEVEL_ACTION, (LM_TRACE, DDS4CCM_INFO
"DDS_Base_Connector_T"
"::remove_domain - "
"Deleted contained entities for participant "
DDS_ENTITY_FORMAT_SPECIFIER
" remove_topic - Deleted topic for domain <%d> with qos <%C> "
"return code <%C>\n",
DDS_ENTITY_LOG (participant),
this->domain_id_, this->qos_profile_.in (),
::CIAO::DDS4CCM::translate_retcode (retcode)));
if (retcode != ::DDS::RETCODE_OK)
{
throw ::CCM_DDS::InternalError (retcode, 0);
}
DDS4CCM_DEBUG (DDS4CCM_LOG_LEVEL_ACTION, (LM_TRACE, DDS4CCM_INFO
"DDS_Base_Connector_T"
"::remove_domain - "
"Going to delete participant "
DDS_ENTITY_FORMAT_SPECIFIER
" for domain <%d> with qos <%C>.\n",
DDS_ENTITY_LOG (participant),
this->domain_id_, this->qos_profile_.in ()));
retcode = this->participant_factory_->delete_participant (participant);
DDS4CCM_DEBUG (DDS4CCM_LOG_LEVEL_ACTION, (LM_TRACE, DDS4CCM_INFO
"DDS_Base_Connector_T"
"::remove_domain - "
"Deleted participant for domain <%d> with qos <%C> "
"return code <%C>\n",
this->domain_id_, this->qos_profile_.in (),
::CIAO::DDS4CCM::translate_retcode (retcode)));
}
if (retcode != ::DDS::RETCODE_OK)
{
throw ::CCM_DDS::InternalError (retcode, 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;
}
Reader::Reader(::DDS::DomainParticipant_ptr dp,
int history_depth,
int max_samples_per_instance)
: max_samples_per_instance_(max_samples_per_instance),
dp_(::DDS::DomainParticipant::_duplicate (dp))
{
sub_ = dp->create_subscriber(SUBSCRIBER_QOS_DEFAULT,
::DDS::SubscriberListener::_nil());
if (CORBA::is_nil (sub_.in ()))
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT("(%P|%t) create_subscriber failed.\n")));
throw TestException() ;
}
// Initialize the transport
if (0 != init_transport() )
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT("(%P|%t) init_transport failed!\n")));
throw TestException() ;
}
// Attach the subscriber to the transport.
TAO::DCPS::SubscriberImpl* sub_impl
= TAO::DCPS::reference_to_servant<TAO::DCPS::SubscriberImpl> (sub_.in ());
if (0 == sub_impl)
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT("(%P|%t) Failed to obtain servant ::TAO::DCPS::SubscriberImpl\n")));
throw TestException() ;
}
sub_impl->attach_transport(reader_transport_impl.in());
::DDS::TopicDescription_var description =
dp->lookup_topicdescription(MY_TOPIC);
if (CORBA::is_nil (description.in ()))
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT("(%P|%t) lookup_topicdescription failed.\n")));
throw TestException() ;
}
::DDS::DataReaderQos dr_qos;
sub_->get_default_datareader_qos (dr_qos);
dr_qos.history.depth = history_depth ;
dr_qos.resource_limits.max_samples_per_instance =
max_samples_per_instance ;
dr_qos.liveliness.lease_duration.sec =
static_cast<CORBA::Long> (max_blocking_time.sec ());
dr_qos.liveliness.lease_duration.nanosec = 0 ;
::DDS::DataReaderListener_var drl
= ::TAO::DCPS::servant_to_reference(&drl_servant_);
::DDS::DataReader_var dr = sub_->create_datareader(description.in (),
dr_qos,
// ::DDS::DataReaderListener::_nil()
drl.in ());
if (CORBA::is_nil (dr.in ()))
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT("(%P|%t) create_datareader failed.\n")));
throw TestException() ;
}
}
::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;
}
::DDS::Subscriber_ptr
create_subscriber (::DDS::DomainParticipant_ptr participant,
int attach_to_udp,
int attach_to_multicast,
int attach_to_rtps,
int attach_to_shmem)
{
// Create the subscriber
::DDS::Subscriber_var sub;
try
{
sub = participant->create_subscriber(SUBSCRIBER_QOS_DEFAULT,
::DDS::SubscriberListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (sub.in ()))
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("Failed to create_subscriber.")));
return ::DDS::Subscriber::_nil ();
}
// Attach the subscriber to the transport.
if (attach_to_udp)
{
ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) attach to udp \n")));
TheTransportRegistry->bind_config("udp", sub.in());
}
else if (attach_to_multicast)
{
ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) attach to multicast \n")));
TheTransportRegistry->bind_config("multicast", sub.in());
}
else if (attach_to_rtps)
{
ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) attach to RTPS\n")));
TheTransportRegistry->bind_config("rtps", sub);
}
else if (attach_to_shmem)
{
ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) attach to shmem\n")));
TheTransportRegistry->bind_config("shmem", sub);
}
else
{
ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) attach to tcp \n")));
TheTransportRegistry->bind_config("tcp", sub.in());
}
}
catch (const TestException&)
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT("(%P|%t) TestException caught in create_subscriber. ")));
return ::DDS::Subscriber::_nil ();
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Exception caught in create_subscriber.");
return ::DDS::Subscriber::_nil ();
}
return sub._retn ();
}
::DDS::Subscriber_ptr
create_subscriber (::DDS::DomainParticipant_ptr participant,
int attach_to_udp,
int attach_to_mcast,
int attach_to_reliable_multicast)
{
// Create the subscriber
::DDS::Subscriber_var sub;
try
{
sub = participant->create_subscriber(SUBSCRIBER_QOS_DEFAULT,
::DDS::SubscriberListener::_nil());
if (CORBA::is_nil (sub.in ()))
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("Failed to create_subscriber.")));
return ::DDS::Subscriber::_nil ();
}
// Attach the subscriber to the transport.
::TAO::DCPS::SubscriberImpl* sub_impl
= ::TAO::DCPS::reference_to_servant< ::TAO::DCPS::SubscriberImpl,
::DDS::Subscriber_ptr>
(sub.in ());
if (0 == sub_impl)
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT("(%P|%t) Failed to obtain subscriber servant\n")));
return ::DDS::Subscriber::_nil ();
}
TAO::DCPS::AttachStatus attach_status;
if (attach_to_udp)
{
ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) attach to udp \n")));
attach_status = sub_impl->attach_transport(reader_udp_impl.in());
}
else if (attach_to_mcast)
{
ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) attach to mcast \n")));
attach_status = sub_impl->attach_transport(reader_mcast_impl.in());
}
else if (attach_to_reliable_multicast)
{
ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) attach to reliable multicast \n")));
attach_status = sub_impl->attach_transport(reader_reliable_multicast_impl.in());
}
else
{
ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) attach to tcp \n")));
attach_status = sub_impl->attach_transport(reader_tcp_impl.in());
}
if (attach_status != TAO::DCPS::ATTACH_OK)
{
// We failed to attach to the transport for some reason.
ACE_TString status_str;
switch (attach_status)
{
case TAO::DCPS::ATTACH_BAD_TRANSPORT:
status_str = "ATTACH_BAD_TRANSPORT";
break;
case TAO::DCPS::ATTACH_ERROR:
status_str = "ATTACH_ERROR";
break;
case TAO::DCPS::ATTACH_INCOMPATIBLE_QOS:
status_str = "ATTACH_INCOMPATIBLE_QOS";
break;
default:
status_str = "Unknown Status";
break;
}
ACE_ERROR ((LM_ERROR,
ACE_TEXT("(%P|%t) Failed to attach to the transport. ")
ACE_TEXT("AttachStatus == %s\n"),
status_str.c_str()));
return ::DDS::Subscriber::_nil ();
}
}
catch (const TestException&)
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT("(%P|%t) TestException caught in create_subscriber. ")));
return ::DDS::Subscriber::_nil ();
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Exception caught in create_subscriber.");
return ::DDS::Subscriber::_nil ();
}
return sub._retn ();
}