int UDPProxyTransport::setTransport(DDS::DomainParticipantQos &participantQos, DDS::DomainParticipant *participant)
{
#if defined(RTI_WIN32) || defined(RTI_LINUX)
if(m_to_connect != NULL)
{
char buffer[100];
const char *pointer;
SNPRINTF(buffer, 100, "builtin.udpv4://%s", m_to_connect);
participantQos.discovery.accept_unknown_peers = DDS_BOOLEAN_FALSE;
participantQos.discovery.initial_peers.ensure_length(1, 1);
pointer = strdup(buffer);
participantQos.discovery.initial_peers.set_at(0, pointer);
}
return 0;
#elif defined(OPENDDS)
const char* const METHOD_NAME = "setTransport";
int returnedValue = -1;
char cfgbuffer[50], trabuffer[50];
OpenDDS::DCPS::RepoId pid = dynamic_cast<OpenDDS::DCPS::DomainParticipantImpl*>(participant)->get_id();
int participantId = *(int*)&pid.guidPrefix[8];
SNPRINTF(cfgbuffer, 50, "config_%ld", participantId);
SNPRINTF(trabuffer, 50, "trans_%ld", participantId);
OpenDDS::DCPS::TransportConfig_rch cfg = TheTransportRegistry->get_config(cfgbuffer);
if(cfg.is_nil())
{
cfg = TheTransportRegistry->create_config(cfgbuffer);
if(cfg != NULL)
{
OpenDDS::DCPS::TransportInst_rch inst = TheTransportRegistry->create_inst(trabuffer, "rtps_udp");
if(inst != NULL)
{
OpenDDS::DCPS::dynamic_rchandle_cast<OpenDDS::DCPS::RtpsUdpInst>(inst)->use_multicast_ = true;
OpenDDS::DCPS::dynamic_rchandle_cast<OpenDDS::DCPS::RtpsUdpInst>(inst)->heartbeat_period_ = ACE_Time_Value(3);
cfg->instances_.push_back(inst);
TheTransportRegistry->bind_config(cfg, participant);
returnedValue = 0;
}
else
{
printf("ERROR<%s::%s>: Cannot create transport instance\n", CLASS_NAME, METHOD_NAME);
}
}
else
{
printf("ERROR<%s::%s>: Cannot create transport config object\n", CLASS_NAME, METHOD_NAME);
}
}
return returnedValue;
#endif
}
// TheTransportRegistry::global_config
jobject JNICALL Java_OpenDDS_DCPS_transport_TheTransportRegistry_global_1config__
(JNIEnv * jni, jclass)
{
try {
OpenDDS::DCPS::TransportConfig_rch config =
TheTransportRegistry->global_config();
jclass configClazz =
findClass(jni, "OpenDDS/DCPS/transport/TransportConfig");
jmethodID ctor = jni->GetMethodID(configClazz, "<init>", "(J)V");
return jni->NewObject(configClazz, ctor,
reinterpret_cast<jlong>(config._retn()));
} catch (const CORBA::SystemException &se) {
throw_java_exception(jni, se);
return 0;
} catch (const OpenDDS::DCPS::Transport::Exception &te) {
throw_java_exception(jni, te);
return 0;
}
}
int ACE_TMAIN (int argc, ACE_TCHAR *argv[]) {
int status = 0;
try
{
DDS::DomainParticipantFactory_var dpf =
TheParticipantFactoryWithArgs(argc, argv);
DDS::DomainParticipant_var participant =
dpf->create_participant(411,
PARTICIPANT_QOS_DEFAULT,
DDS::DomainParticipantListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (participant.in ())) {
cerr << "create_participant failed." << endl;
return 1;
}
DDS::DomainParticipant_var participant2 =
dpf->create_participant(411,
PARTICIPANT_QOS_DEFAULT,
DDS::DomainParticipantListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (participant2.in ())) {
cerr << "create_participant failed." << endl;
return 1;
}
OpenDDS::DCPS::TransportConfig_rch cfg = TheTransportRegistry->get_config("part1");
if (!cfg.is_nil()) {
TheTransportRegistry->bind_config(cfg, participant);
}
cfg = TheTransportRegistry->get_config("part2");
if (!cfg.is_nil()) {
TheTransportRegistry->bind_config(cfg, participant2);
}
if (parse_args (argc, argv) == -1) {
return -1;
}
MessageTypeSupport_var mts = new MessageTypeSupportImpl();
MessageTypeSupport_var mts2 = new MessageTypeSupportImpl();
if (DDS::RETCODE_OK != mts->register_type(participant.in (), "")) {
cerr << "register_type failed." << endl;
exit(1);
}
if (DDS::RETCODE_OK != mts2->register_type(participant2.in (), "")) {
cerr << "register_type failed." << endl;
exit(1);
}
CORBA::String_var type_name = mts->get_type_name ();
CORBA::String_var type_name2 = mts2->get_type_name ();
DDS::Topic_var topic =
participant->create_topic ("Movie Discussion List",
type_name.in (),
TOPIC_QOS_DEFAULT,
DDS::TopicListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (topic.in ())) {
cerr << "create_topic failed." << endl;
exit(1);
}
DDS::Topic_var topic2 =
participant2->create_topic ("Movie Discussion List",
type_name2.in (),
TOPIC_QOS_DEFAULT,
DDS::TopicListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (topic2.in ())) {
cerr << "create_topic failed." << endl;
exit(1);
}
DDS::Publisher_var pub =
participant->create_publisher(PUBLISHER_QOS_DEFAULT,
DDS::PublisherListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (pub.in ())) {
cerr << "create_publisher failed." << endl;
exit(1);
}
DDS::Publisher_var pub2 =
participant2->create_publisher(PUBLISHER_QOS_DEFAULT,
DDS::PublisherListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (pub2.in ())) {
cerr << "create_publisher failed." << endl;
exit(1);
}
DataWriterListenerImpl * dwl1_servant = new DataWriterListenerImpl;
::DDS::DataWriterListener_var dwl1 (dwl1_servant);
DataWriterListenerImpl * dwl2_servant = new DataWriterListenerImpl;
::DDS::DataWriterListener_var dwl2 (dwl2_servant);
DataWriterListenerImpl * dwl3_servant = new DataWriterListenerImpl;
::DDS::DataWriterListener_var dwl3 (dwl3_servant);
DataWriterListenerImpl * dwl4_servant = new DataWriterListenerImpl;
::DDS::DataWriterListener_var dwl4 (dwl4_servant);
// Create the datawriters
::DDS::DataWriterQos dw_qos;
pub->get_default_datawriter_qos (dw_qos);
::DDS::DataWriterQos dw2_qos;
pub2->get_default_datawriter_qos (dw2_qos);
dw_qos.liveliness.kind = ::DDS::MANUAL_BY_PARTICIPANT_LIVELINESS_QOS;
dw_qos.liveliness.lease_duration.sec = LEASE_DURATION_SEC;
dw_qos.liveliness.lease_duration.nanosec = 0;
dw2_qos.liveliness.kind = ::DDS::MANUAL_BY_PARTICIPANT_LIVELINESS_QOS;
dw2_qos.liveliness.lease_duration.sec = LEASE_DURATION_SEC;
dw2_qos.liveliness.lease_duration.nanosec = 0;
// Create the datawriter
DDS::DataWriter_var dw1 =
pub->create_datawriter(topic.in (),
dw_qos,
dwl1.in(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (dw1.in ())) {
cerr << "create_datawriter failed." << endl;
exit(1);
}
// Create the datawriter
DDS::DataWriter_var dw2 =
pub2->create_datawriter(topic2.in (),
dw2_qos,
dwl2.in(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (dw2.in ())) {
cerr << "create_datawriter failed." << endl;
exit(1);
}
dw_qos.liveliness.kind = ::DDS::MANUAL_BY_TOPIC_LIVELINESS_QOS;
// Create the datawriter
DDS::DataWriter_var dw3 =
pub->create_datawriter(topic.in (),
dw_qos,
dwl3.in(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (dw3.in ())) {
cerr << "create_datawriter failed." << endl;
exit(1);
}
// Create the datawriter
DDS::DataWriter_var dw4 =
pub->create_datawriter(topic.in (),
dw_qos,
dwl4.in(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (dw4.in ())) {
cerr << "create_datawriter failed." << endl;
exit(1);
}
{
Write_Samples writer1(dw1, "Manual_By_Participant_Writer_1");
Assert_Participant_Liveliness writer2(dw2, "Manual_By_Participant_Writer_2");
Write_Samples writer3(dw3, "Manual_By_Topic_Writer_1");
Assert_Writer_Liveliness writer4(dw4, "Manual_By_Topic_Writer_2");
writer1.start();
writer2.start();
writer3.start();
writer4.start();
writer1.end();
writer2.end();
writer3.end();
writer4.end();
}
const unsigned long actual = dwl1_servant->num_liveliness_lost_callbacks() +
dwl2_servant->num_liveliness_lost_callbacks() +
dwl3_servant->num_liveliness_lost_callbacks() +
dwl4_servant->num_liveliness_lost_callbacks();
if (liveliness_lost_test
&& static_cast<int>(actual) != num_liveliness_lost_callbacks)
{
cerr << "ERROR: did not receive expected liveliness lost callbacks. "
<< actual << "/" <<
num_liveliness_lost_callbacks << endl;
status = 1;
}
ACE_OS::sleep(1);
ACE_DEBUG((LM_INFO, "publisher deleting entities\n"));
participant->delete_contained_entities();
dpf->delete_participant(participant.in ());
participant2->delete_contained_entities();
dpf->delete_participant(participant2.in ());
TheServiceParticipant->shutdown ();
}
catch (CORBA::Exception& e)
{
cerr << "PUB: Exception caught in main.cpp:" << endl
<< e << endl;
exit(1);
}
return status;
}
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;
}
Publisher::Publisher( const Options& options)
: options_( options),
waiter_( new DDS::WaitSet)
{
DDS::DomainParticipantFactory_var dpf = TheParticipantFactory;
// Create the DomainParticipant
this->participant_
= dpf->create_participant(
this->options_.domain(),
PARTICIPANT_QOS_DEFAULT,
DDS::DomainParticipantListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK
);
if( CORBA::is_nil( this->participant_.in())) {
ACE_ERROR((LM_ERROR,
ACE_TEXT("(%P|%t) ERROR: Publisher::Publisher() - ")
ACE_TEXT("failed to create a participant.\n")
));
throw BadParticipantException();
} else if( this->options_.verbose()) {
ACE_DEBUG((LM_DEBUG,
ACE_TEXT("(%P|%t) Publisher::Publisher() - ")
ACE_TEXT("created participant in domain %d.\n"),
this->options_.domain()
));
}
// Create the transport.
OpenDDS::DCPS::TransportConfig_rch transport =
TheTransportRegistry->get_config(this->options_.transportKey());
if (transport.is_nil()) {
ACE_ERROR((LM_ERROR,
ACE_TEXT("(%P|%t) ERROR: Subscriber::Subscriber() - ")
ACE_TEXT("failed to get %C transport.\n"),
this->options_.transportKey().c_str()
));
throw BadTransportException();
} else if( this->options_.verbose()) {
ACE_DEBUG((LM_DEBUG,
ACE_TEXT("(%P|%t) Subscriber::Subscriber() - ")
ACE_TEXT("created %C transport.\n"),
this->options_.transportKey().c_str()
));
}
// Create and register the type support.
DataTypeSupportImpl* testData = new DataTypeSupportImpl();
if( ::DDS::RETCODE_OK
!= testData->register_type( this->participant_.in(), 0)) {
ACE_ERROR((LM_ERROR,
ACE_TEXT("(%P|%t) ERROR: Publisher::Publisher() - ")
ACE_TEXT("unable to install type %C support.\n"),
testData->get_type_name()
));
throw BadTypeSupportException ();
} else if( this->options_.verbose()) {
ACE_DEBUG((LM_DEBUG,
ACE_TEXT("(%P|%t) Publisher::Publisher() - ")
ACE_TEXT("created type %C support.\n"),
testData->get_type_name()
));
}
// Create the topic.
this->topic_ = this->participant_->create_topic(
this->options_.topicName().c_str(),
testData->get_type_name(),
TOPIC_QOS_DEFAULT,
::DDS::TopicListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK
);
if( CORBA::is_nil( this->topic_.in())) {
ACE_ERROR((LM_ERROR,
ACE_TEXT("(%P|%t) ERROR: Publisher::Publisher() - ")
ACE_TEXT("failed to create topic %C.\n"),
this->options_.topicName().c_str()
));
throw BadTopicException();
} else if( this->options_.verbose()) {
ACE_DEBUG((LM_DEBUG,
ACE_TEXT("(%P|%t) Publisher::Publisher() - ")
ACE_TEXT("created topic %C.\n"),
this->options_.topicName().c_str()
));
}
// Create the publisher.
this->publisher_ = this->participant_->create_publisher(
PUBLISHER_QOS_DEFAULT,
::DDS::PublisherListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK
);
if( CORBA::is_nil( this->publisher_.in())) {
ACE_ERROR((LM_ERROR,
ACE_TEXT("(%P|%t) ERROR: Publisher::Publisher() - ")
ACE_TEXT("failed to create publisher.\n")
));
throw BadPublisherException();
} else if( this->options_.verbose()) {
ACE_DEBUG((LM_DEBUG,
ACE_TEXT("(%P|%t) Publisher::Publisher() - ")
ACE_TEXT("created publisher.\n")
));
}
TheTransportRegistry->bind_config(transport, this->publisher_);
if( this->options_.verbose()) {
ACE_DEBUG((LM_DEBUG,
ACE_TEXT("(%P|%t) Publisher::Publisher() - ")
ACE_TEXT("attached transport to publisher.\n")
));
}
// Writer Qos policy values.
::DDS::DataWriterQos writerQos;
this->publisher_->get_default_datawriter_qos( writerQos);
writerQos.durability.kind = ::DDS::TRANSIENT_LOCAL_DURABILITY_QOS;
writerQos.history.kind = ::DDS::KEEP_ALL_HISTORY_QOS;
writerQos.resource_limits.max_samples_per_instance = ::DDS::LENGTH_UNLIMITED;
// Reliability varies with the transport implementation.
switch( this->options_.transportType()) {
case Options::TCP:
case Options::MC:
writerQos.reliability.kind = ::DDS::RELIABLE_RELIABILITY_QOS;
break;
case Options::UDP:
writerQos.reliability.kind = ::DDS::BEST_EFFORT_RELIABILITY_QOS;
break;
case Options::TRANSPORT_NONE:
default:
ACE_ERROR((LM_ERROR,
ACE_TEXT("(%P|%t) ERROR: Publisher::Publisher() - ")
ACE_TEXT("unrecognized transport when setting up Qos policies.\n")
));
throw BadQosException();
}
if( this->options_.verbose()) {
ACE_DEBUG((LM_DEBUG,
ACE_TEXT("(%P|%t) Publisher::Publisher() - ")
ACE_TEXT("starting to create %d publications.\n"),
this->options_.profiles().size()
));
}
// Build as many publications as are specified.
for( unsigned int index = 0; index < this->options_.profiles().size(); ++index) {
// This publications priority is needed when creating the writer.
writerQos.transport_priority.value = this->options_.profiles()[ index]->priority();
// Create the writer.
DDS::DataWriter_var writer
= this->publisher_->create_datawriter(
this->topic_.in(),
writerQos,
DDS::DataWriterListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK
);
if( CORBA::is_nil( writer.in())) {
ACE_ERROR((LM_ERROR,
ACE_TEXT("(%P|%t) ERROR: Publisher::Publisher() - ")
ACE_TEXT("failed to create writer.\n")
));
throw BadWriterException();
} else if( this->options_.verbose()) {
ACE_DEBUG((LM_DEBUG,
ACE_TEXT("(%P|%t) Publisher::Publisher() - ")
ACE_TEXT("created writer for publication %C ")
ACE_TEXT("with priority %d.\n"),
this->options_.profiles()[ index]->name().c_str(),
writerQos.transport_priority.value
));
}
// Create a publication and store it.
this->publications_[ this->options_.profiles()[ index]->name()]
= new Writer(
writer.in(),
*this->options_.profiles()[ index],
this->options_.verbose()
);
//
// Grab, enable and attach the status condition for test
// synchronization of the current publication.
//
DDS::StatusCondition_var status = writer->get_statuscondition();
status->set_enabled_statuses( DDS::PUBLICATION_MATCHED_STATUS);
this->waiter_->attach_condition( status.in());
if( this->options_.verbose()) {
ACE_DEBUG((LM_DEBUG,
ACE_TEXT("(%P|%t) Publisher::Publisher() - ")
ACE_TEXT("created StatusCondition for publication %C.\n"),
this->options_.profiles()[ index]->name().c_str()
));
}
}
}
Subscriber::Subscriber( const Options& options)
: options_( options),
listener_( 0),
waiter_( new DDS::WaitSet)
{
DDS::DomainParticipantFactory_var dpf = TheParticipantFactory;
// Create the DomainParticipant
this->participant_
= dpf->create_participant(
this->options_.domain(),
PARTICIPANT_QOS_DEFAULT,
DDS::DomainParticipantListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK
);
if( CORBA::is_nil( this->participant_.in())) {
ACE_ERROR((LM_ERROR,
ACE_TEXT("(%P|%t) ERROR: Subscriber::Subscriber() - ")
ACE_TEXT("failed to create a participant.\n")
));
throw BadParticipantException();
} else if( this->options_.verbose()) {
ACE_DEBUG((LM_DEBUG,
ACE_TEXT("(%P|%t) Subscriber::Subscriber() - ")
ACE_TEXT("created participant in domain %d.\n"),
this->options_.domain()
));
}
// Create the transport.
OpenDDS::DCPS::TransportConfig_rch transport =
TheTransportRegistry->get_config(this->options_.transportKey());
if (transport.is_nil()) {
ACE_ERROR((LM_ERROR,
ACE_TEXT("(%P|%t) ERROR: Subscriber::Subscriber() - ")
ACE_TEXT("failed to get %C transport.\n"),
this->options_.transportKey().c_str()
));
throw BadTransportException();
} else if( this->options_.verbose()) {
ACE_DEBUG((LM_DEBUG,
ACE_TEXT("(%P|%t) Subscriber::Subscriber() - ")
ACE_TEXT("created %C transport.\n"),
this->options_.transportKey().c_str()
));
}
// Create the listener.
this->listener_ = new DataReaderListener( this->options_.verbose());
this->safe_listener_ = this->listener_;
if( this->options_.verbose()) {
ACE_DEBUG((LM_DEBUG,
ACE_TEXT("(%P|%t) Subscriber::Subscriber() - ")
ACE_TEXT("created reader listener.\n")
));
}
// Create and register the type support.
DataTypeSupportImpl* testData = new DataTypeSupportImpl();
if( ::DDS::RETCODE_OK
!= testData->register_type( this->participant_.in(), 0)) {
ACE_ERROR((LM_ERROR,
ACE_TEXT("(%P|%t) ERROR: Subscriber::Subscriber() - ")
ACE_TEXT("unable to install type %C support.\n"),
testData->get_type_name()
));
throw BadTypeSupportException ();
} else if( this->options_.verbose()) {
ACE_DEBUG((LM_DEBUG,
ACE_TEXT("(%P|%t) Subscriber::Subscriber() - ")
ACE_TEXT("created type %C support.\n"),
testData->get_type_name()
));
}
// Create the topic.
this->topic_ = this->participant_->create_topic(
this->options_.topicName().c_str(),
testData->get_type_name(),
TOPIC_QOS_DEFAULT,
::DDS::TopicListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK
);
if( CORBA::is_nil( this->topic_.in())) {
ACE_ERROR((LM_ERROR,
ACE_TEXT("(%P|%t) ERROR: Subscriber::Subscriber() - ")
ACE_TEXT("failed to create topic %C.\n"),
this->options_.topicName().c_str()
));
throw BadTopicException();
} else if( this->options_.verbose()) {
ACE_DEBUG((LM_DEBUG,
ACE_TEXT("(%P|%t) Subscriber::Subscriber() - ")
ACE_TEXT("created topic %C.\n"),
this->options_.topicName().c_str()
));
}
// Create the subscriber.
this->subscriber_ = this->participant_->create_subscriber(
SUBSCRIBER_QOS_DEFAULT,
::DDS::SubscriberListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK
);
if( CORBA::is_nil( this->subscriber_.in())) {
ACE_ERROR((LM_ERROR,
ACE_TEXT("(%P|%t) ERROR: Subscriber::Subscriber() - ")
ACE_TEXT("failed to create subscriber.\n")
));
throw BadSubscriberException();
} else if( this->options_.verbose()) {
ACE_DEBUG((LM_DEBUG,
ACE_TEXT("(%P|%t) Subscriber::Subscriber() - ")
ACE_TEXT("created subscriber.\n")
));
}
// Attach the transport to the subscriber.
::OpenDDS::DCPS::SubscriberImpl* servant
= dynamic_cast< ::OpenDDS::DCPS::SubscriberImpl*>( this->subscriber_.in());
if( 0 == servant) {
ACE_ERROR((LM_ERROR,
ACE_TEXT("(%P|%t) ERROR: Subscriber::Subscriber() - ")
ACE_TEXT("failed to narrow subscriber servant.\n")
));
throw BadServantException();
}
// Configure the raw data gathering.
servant->raw_latency_buffer_size() = this->options_.raw_buffer_size();
servant->raw_latency_buffer_type() = this->options_.raw_buffer_type();
if( this->options_.verbose()) {
ACE_DEBUG((LM_DEBUG,
ACE_TEXT("(%P|%t) Subscriber::Subscriber() - ")
ACE_TEXT("configured to capture %d latency measurements of type %d ")
ACE_TEXT("per writer to file %C.\n"),
this->options_.raw_buffer_size(),
this->options_.raw_buffer_type(),
this->options_.rawOutputFilename().c_str()
));
}
TheTransportRegistry->bind_config(transport, servant);
if( this->options_.verbose()) {
ACE_DEBUG((LM_DEBUG,
ACE_TEXT("(%P|%t) Subscriber::Subscriber() - ")
ACE_TEXT("attached transport to subscriber.\n")
));
}
// Reader Qos policy values.
::DDS::DataReaderQos readerQos;
this->subscriber_->get_default_datareader_qos( readerQos);
readerQos.durability.kind = ::DDS::TRANSIENT_LOCAL_DURABILITY_QOS;
readerQos.history.kind = ::DDS::KEEP_ALL_HISTORY_QOS;
readerQos.resource_limits.max_samples_per_instance = ::DDS::LENGTH_UNLIMITED;
// Reliability varies with the transport implementation.
switch( this->options_.transportType()) {
case Options::TCP:
case Options::MC:
readerQos.reliability.kind = ::DDS::RELIABLE_RELIABILITY_QOS;
break;
case Options::UDP:
readerQos.reliability.kind = ::DDS::BEST_EFFORT_RELIABILITY_QOS;
break;
case Options::TRANSPORT_NONE:
default:
ACE_ERROR((LM_ERROR,
ACE_TEXT("(%P|%t) ERROR: Subscriber::Subscriber() - ")
ACE_TEXT("unrecognized transport when setting up Qos policies.\n")
));
throw BadQosException();
}
// Create the reader.
::DDS::DataReader_var reader
= this->subscriber_->create_datareader(
this->topic_.in(),
readerQos,
DDS::DataReaderListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK
);
if( CORBA::is_nil( reader.in())) {
ACE_ERROR((LM_ERROR,
ACE_TEXT("(%P|%t) ERROR: Subscriber::Subscriber() - ")
ACE_TEXT("failed to create reader.\n")
));
throw BadReaderException();
} else if( this->options_.verbose()) {
ACE_DEBUG((LM_DEBUG,
ACE_TEXT("(%P|%t) Subscriber::Subscriber() - ")
ACE_TEXT("created reader.\n")
));
}
this->reader_ = ::OpenDDS::DCPS::DataReaderEx::_narrow( reader.in());
if( CORBA::is_nil( this->reader_.in())) {
ACE_ERROR((LM_ERROR,
ACE_TEXT("(%P|%t) ERROR: Subscriber::Subscriber() - ")
ACE_TEXT("failed to narrow reader to extract statistics.\n")
));
throw BadReaderException();
}
// Clear and start statistics gathering. Ideally we would want to
// configurably delay the start here to avoid edge effects.
this->reader_->reset_latency_stats();
this->reader_->statistics_enabled( true);
// Set the listener mask here so that we don't conflict with the
// StatusCondition(s) that we want to wait on in the main thread.
this->reader_->set_listener( this->listener_, DDS::DATA_AVAILABLE_STATUS);
// Grab, enable and attach the status condition for test synchronization.
this->status_ = this->reader_->get_statuscondition();
this->status_->set_enabled_statuses( DDS::SUBSCRIPTION_MATCHED_STATUS);
this->waiter_->attach_condition( this->status_.in());
if( this->options_.verbose()) {
ACE_DEBUG((LM_DEBUG,
ACE_TEXT("(%P|%t) Subscriber::Subscriber() - ")
ACE_TEXT("created StatusCondition and WaitSet for test synchronization.\n")
));
}
}
int ACE_TMAIN (int argc, ACE_TCHAR *argv[]){
try
{
DDS::DomainParticipantFactory_var dpf =
TheParticipantFactoryWithArgs(argc, argv);
OpenDDS::DCPS::TransportConfig_rch config =
OpenDDS::DCPS::TransportRegistry::instance()->get_config("dds4ccm_rtps");
if (config.is_nil())
{
config =
OpenDDS::DCPS::TransportRegistry::instance()->create_config("dds4ccm_rtps");
}
OpenDDS::DCPS::TransportInst_rch inst =
OpenDDS::DCPS::TransportRegistry::instance()->get_inst("the_rtps_transport");
if (inst.is_nil())
{
inst =
OpenDDS::DCPS::TransportRegistry::instance()->create_inst("the_rtps_transport",
"rtps_udp");
config->instances_.push_back(inst);
OpenDDS::DCPS::TransportRegistry::instance()->global_config(config);
}
// Create another transport instance for participant2 since RTPS transport instances
// cannot be shared by domain participants.
OpenDDS::DCPS::TransportConfig_rch config2 =
OpenDDS::DCPS::TransportRegistry::instance()->get_config("dds4ccm_rtps_2");
if (config2.is_nil())
{
config2 =
OpenDDS::DCPS::TransportRegistry::instance()->create_config("dds4ccm_rtps_2");
}
OpenDDS::DCPS::TransportInst_rch inst2 =
OpenDDS::DCPS::TransportRegistry::instance()->get_inst("the_rtps_transport_2");
if (inst2.is_nil())
{
inst2 =
OpenDDS::DCPS::TransportRegistry::instance()->create_inst("the_rtps_transport_2",
"rtps_udp");
config2->instances_.push_back(inst2);
}
#ifndef DDS_HAS_MINIMUM_BIT
OpenDDS::RTPS::RtpsDiscovery_rch disc =
new OpenDDS::RTPS::RtpsDiscovery(OpenDDS::DCPS::Discovery::DEFAULT_RTPS);
// The recommended value for the resend period is 2 seconds for
// the current implementation of OpenDDS.
disc->resend_period(ACE_Time_Value(2));
TheServiceParticipant->add_discovery(OpenDDS::DCPS::static_rchandle_cast<OpenDDS::DCPS::Discovery>(disc));
TheServiceParticipant->set_repo_domain(11, disc->key());
#endif
TheServiceParticipant->set_default_discovery (OpenDDS::DCPS::Discovery::DEFAULT_RTPS);
DDS::DomainParticipant_var participant =
dpf->create_participant(11,
PARTICIPANT_QOS_DEFAULT,
DDS::DomainParticipantListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (participant.in ())) {
cerr << "create_participant failed." << endl;
return 1;
}
else
{
ACE_DEBUG ((LM_DEBUG, "Created participant 1 with instance handle %d\n",
participant->get_instance_handle ()));
}
OpenDDS::DCPS::TransportRegistry::instance()->bind_config(config, participant.in());
DDS::DomainParticipant_var participant2 =
dpf->create_participant(11,
PARTICIPANT_QOS_DEFAULT,
DDS::DomainParticipantListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (participant2.in ())) {
cerr << "create_participant failed." << endl;
return 1;
}
else
{
ACE_DEBUG ((LM_DEBUG, "Created participant 2 with instance handle %d\n",
participant2->get_instance_handle ()));
}
try {
OpenDDS::DCPS::TransportRegistry::instance()->bind_config(config2, participant2.in());
}
catch (const OpenDDS::DCPS::Transport::MiscProblem &) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l: main()")
ACE_TEXT(" ERROR: TransportRegistry::bind_config() throws")
ACE_TEXT(" Transport::MiscProblem exception\n")),
-1);
}
catch (const OpenDDS::DCPS::Transport::NotFound &) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l: main()")
ACE_TEXT(" ERROR: TransportRegistry::bind_config() throws")
ACE_TEXT(" Transport::NotFound exception\n")),
-1);
}
// Register TypeSupport (Messenger::Message)
Messenger::MessageTypeSupport_var mts =
new Messenger::MessageTypeSupportImpl();
if (mts->register_type(participant.in(), "") != DDS::RETCODE_OK) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l: main()")
ACE_TEXT(" ERROR: register_type failed!\n")),
-1);
}
// Create Topic
CORBA::String_var type_name = mts->get_type_name();
DDS::Topic_var topic =
participant->create_topic("Movie Discussion List",
type_name.in(),
TOPIC_QOS_DEFAULT,
DDS::TopicListener::_nil(),
OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil(topic.in())) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l: main()")
ACE_TEXT(" ERROR: create_topic failed!\n")),
-1);
}
// Create Publisher
DDS::Publisher_var pub =
participant->create_publisher(PUBLISHER_QOS_DEFAULT,
DDS::PublisherListener::_nil(),
OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil(pub.in())) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l: main()")
ACE_TEXT(" ERROR: create_publisher failed!\n")),
-1);
}
// Create DataWriter
DDS::DataWriter_var dw =
pub->create_datawriter(topic.in(),
DATAWRITER_QOS_DEFAULT,
DDS::DataWriterListener::_nil(),
OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil(dw.in())) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l: main()")
ACE_TEXT(" ERROR: create_datawriter failed!\n")),
-1);
}
DDS::ReturnCode_t retcode2 = pub->delete_datawriter (dw.in ());
if (retcode2 != DDS::RETCODE_OK) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l: main()")
ACE_TEXT(" ERROR: should be able to delete datawriter\n")),
-1);
}
DDS::ReturnCode_t retcode5 = dpf->delete_participant(participant.in ());
if (retcode5 != DDS::RETCODE_PRECONDITION_NOT_MET) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l: main()")
ACE_TEXT(" ERROR: should not be able to delete participant\n")),
-1);
}
DDS::ReturnCode_t retcode3 = participant->delete_publisher (pub.in ());
if (retcode3 != DDS::RETCODE_OK) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l: main()")
ACE_TEXT(" ERROR: should be able to delete publisher\n")),
-1);
}
DDS::ReturnCode_t retcode4 = participant->delete_topic (topic.in ());
if (retcode4 != DDS::RETCODE_OK) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l: main()")
ACE_TEXT(" ERROR: should be able to delete topic\n")),
-1);
}
DDS::ReturnCode_t retcode6 = dpf->delete_participant(participant.in ());
if (retcode6 != DDS::RETCODE_OK) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l: main()")
ACE_TEXT(" ERROR: should be able to delete participant\n")),
-1);
}
// DDS::ReturnCode_t retcode7 = dpf->delete_participant(participant2.in ());
// if (retcode7 != DDS::RETCODE_OK) {
// ACE_ERROR_RETURN((LM_ERROR,
// ACE_TEXT("%N:%l: main()")
// ACE_TEXT(" ERROR: should be able to delete participant2\n")),
// -1);
// }
ACE_DEBUG ((LM_DEBUG, "Shutting down the service participant with one participant still registered\n"));
TheServiceParticipant->shutdown ();
}
catch (CORBA::Exception& e)
{
cerr << "dp: Exception caught in main.cpp:" << endl
<< e << endl;
exit(1);
}
return 0;
}
void
MonitorFactoryImpl::initialize()
{
DDS::DomainParticipantFactory_var dpf =
TheServiceParticipant->get_domain_participant_factory();
DDS::DomainParticipant_var participant =
dpf->create_participant(MONITOR_DOMAIN_ID,
PARTICIPANT_QOS_DEFAULT,
DDS::DomainParticipantListener::_nil(),
OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil(participant.in())) {
ACE_DEBUG((LM_DEBUG,
ACE_TEXT("ERROR: %N:%l: MonitorFactoryImpl::initialize() -")
ACE_TEXT(" create_participant failed!\n")));
}
DDS::Publisher_var publisher =
participant->create_publisher(PUBLISHER_QOS_DEFAULT,
DDS::PublisherListener::_nil(),
OpenDDS::DCPS::DEFAULT_STATUS_MASK);
static const std::string config_name = TransportRegistry::DEFAULT_INST_PREFIX
+ std::string("MonitorBITTransportConfig");
OpenDDS::DCPS::TransportConfig_rch config =
TheTransportRegistry->get_config (config_name);
if (config.is_nil ())
{
config = TransportRegistry::instance()->create_config(config_name);
std::string inst_name = TransportRegistry::DEFAULT_INST_PREFIX
+ std::string("FederationBITTCPTransportInst");
TransportInst_rch inst =
TransportRegistry::instance()->create_inst(inst_name, "tcp");
config->instances_.push_back(inst);
}
TransportRegistry::instance()->bind_config(config, publisher.in());
DDS::DataWriter_var writer;
DDS::DataWriterQos dw_qos;
publisher->get_default_datawriter_qos(dw_qos);
dw_qos.durability.kind = DDS::TRANSIENT_LOCAL_DURABILITY_QOS;
OpenDDS::DCPS::ServiceParticipantReportTypeSupport_var sp_ts =
new OpenDDS::DCPS::ServiceParticipantReportTypeSupportImpl();
::DDS::ReturnCode_t ret = sp_ts->register_type(participant.in(), "");
if (DDS::RETCODE_OK == ret) {
CORBA::String_var sp_type_name = sp_ts->get_type_name();
writer = create_data_writer(participant.in(),
publisher.in(),
sp_type_name.in(),
SERVICE_PARTICIPANT_MONITOR_TOPIC,
dw_qos);
this->sp_writer_ =
OpenDDS::DCPS::ServiceParticipantReportDataWriter::_narrow(writer.in());
if (CORBA::is_nil(this->sp_writer_)) {
ACE_DEBUG((LM_DEBUG, "MonitorFactoryImpl::initialize(): Failed to narrow sp_writer\n"));
}
} else {
ACE_DEBUG((LM_DEBUG, "MonitorFactoryImpl::initialize(): Failed to register sp_ts\n"));
}
OpenDDS::DCPS::DomainParticipantReportTypeSupport_var dp_ts =
new OpenDDS::DCPS::DomainParticipantReportTypeSupportImpl();
ret = dp_ts->register_type(participant.in(), "");
if (DDS::RETCODE_OK == ret) {
CORBA::String_var dp_type_name = dp_ts->get_type_name();
writer = create_data_writer(participant.in(),
publisher.in(),
dp_type_name.in(),
DOMAIN_PARTICIPANT_MONITOR_TOPIC,
dw_qos);
this->dp_writer_ =
OpenDDS::DCPS::DomainParticipantReportDataWriter::_narrow(writer.in());
if (CORBA::is_nil(this->dp_writer_)) {
ACE_DEBUG((LM_DEBUG, "MonitorFactoryImpl::initialize(): Failed to narrow dp_writer\n"));
}
} else {
ACE_DEBUG((LM_DEBUG, "MonitorFactoryImpl::initialize(): Failed to register dp_ts\n"));
}
OpenDDS::DCPS::TopicReportTypeSupport_var topic_ts =
new OpenDDS::DCPS::TopicReportTypeSupportImpl();
ret = topic_ts->register_type(participant.in(), "");
if (DDS::RETCODE_OK == ret) {
CORBA::String_var topic_type_name = topic_ts->get_type_name();
writer = create_data_writer(participant.in(),
publisher.in(),
topic_type_name.in(),
TOPIC_MONITOR_TOPIC,
dw_qos);
this->topic_writer_ =
OpenDDS::DCPS::TopicReportDataWriter::_narrow(writer.in());
if (CORBA::is_nil(this->topic_writer_)) {
ACE_DEBUG((LM_DEBUG, "MonitorFactoryImpl::initialize(): Failed to narrow topic_writer\n"));
}
} else {
ACE_DEBUG((LM_DEBUG, "MonitorFactoryImpl::initialize(): Failed to register topic_ts\n"));
}
OpenDDS::DCPS::PublisherReportTypeSupport_var pub_ts =
new OpenDDS::DCPS::PublisherReportTypeSupportImpl();
ret = pub_ts->register_type(participant.in(), "");
if (DDS::RETCODE_OK == ret) {
CORBA::String_var pub_type_name = pub_ts->get_type_name();
writer = create_data_writer(participant.in(),
publisher.in(),
pub_type_name.in(),
PUBLISHER_MONITOR_TOPIC,
dw_qos);
this->pub_writer_ =
OpenDDS::DCPS::PublisherReportDataWriter::_narrow(writer.in());
if (CORBA::is_nil(this->pub_writer_)) {
ACE_DEBUG((LM_DEBUG, "MonitorFactoryImpl::initialize(): Failed to narrow pub_writer\n"));
}
} else {
ACE_DEBUG((LM_DEBUG, "MonitorFactoryImpl::initialize(): Failed to register pub_ts\n"));
}
OpenDDS::DCPS::SubscriberReportTypeSupport_var sub_ts =
new OpenDDS::DCPS::SubscriberReportTypeSupportImpl();
ret = sub_ts->register_type(participant.in(), "");
if (DDS::RETCODE_OK == ret) {
CORBA::String_var sub_type_name = sub_ts->get_type_name();
writer = create_data_writer(participant.in(),
publisher.in(),
sub_type_name.in(),
SUBSCRIBER_MONITOR_TOPIC,
dw_qos);
this->sub_writer_ =
OpenDDS::DCPS::SubscriberReportDataWriter::_narrow(writer.in());
if (CORBA::is_nil(this->sub_writer_)) {
ACE_DEBUG((LM_DEBUG, "MonitorFactoryImpl::initialize(): Failed to narrow sub_writer\n"));
}
} else {
ACE_DEBUG((LM_DEBUG, "MonitorFactoryImpl::initialize(): Failed to register sub_ts\n"));
}
OpenDDS::DCPS::DataWriterReportTypeSupport_var dw_ts =
new OpenDDS::DCPS::DataWriterReportTypeSupportImpl();
ret = dw_ts->register_type(participant.in(), "");
if (DDS::RETCODE_OK == ret) {
CORBA::String_var dw_type_name = dw_ts->get_type_name();
writer = create_data_writer(participant.in(),
publisher.in(),
dw_type_name.in(),
DATA_WRITER_MONITOR_TOPIC,
dw_qos);
this->dw_writer_ =
OpenDDS::DCPS::DataWriterReportDataWriter::_narrow(writer.in());
if (CORBA::is_nil(this->dw_writer_)) {
ACE_DEBUG((LM_DEBUG, "MonitorFactoryImpl::initialize(): Failed to narrow dw_writer\n"));
}
} else {
ACE_DEBUG((LM_DEBUG, "MonitorFactoryImpl::initialize(): Failed to register sp_ts\n"));
}
OpenDDS::DCPS::DataWriterPeriodicReportTypeSupport_var dw_per_ts =
new OpenDDS::DCPS::DataWriterPeriodicReportTypeSupportImpl();
ret = dw_per_ts->register_type(participant.in(), "");
if (DDS::RETCODE_OK == ret) {
CORBA::String_var dw_per_type_name = dw_per_ts->get_type_name();
writer = create_data_writer(participant.in(),
publisher.in(),
dw_per_type_name.in(),
DATA_WRITER_PERIODIC_MONITOR_TOPIC,
dw_qos);
this->dw_per_writer_ =
OpenDDS::DCPS::DataWriterPeriodicReportDataWriter::_narrow(writer.in());
if (CORBA::is_nil(this->dw_per_writer_)) {
ACE_DEBUG((LM_DEBUG, "MonitorFactoryImpl::initialize(): Failed to narrow dw_per_writer\n"));
}
} else {
ACE_DEBUG((LM_DEBUG, "MonitorFactoryImpl::initialize(): Failed to register dw_per_ts\n"));
}
OpenDDS::DCPS::DataReaderReportTypeSupport_var dr_ts =
new OpenDDS::DCPS::DataReaderReportTypeSupportImpl();
ret = dr_ts->register_type(participant.in(), "");
if (DDS::RETCODE_OK == ret) {
CORBA::String_var dr_type_name = dr_ts->get_type_name();
writer = create_data_writer(participant.in(),
publisher.in(),
dr_type_name.in(),
DATA_READER_MONITOR_TOPIC,
dw_qos);
this->dr_writer_ =
OpenDDS::DCPS::DataReaderReportDataWriter::_narrow(writer.in());
if (CORBA::is_nil(this->dr_writer_)) {
ACE_DEBUG((LM_DEBUG, "MonitorFactoryImpl::initialize(): Failed to narrow dr_writer\n"));
}
} else {
ACE_DEBUG((LM_DEBUG, "MonitorFactoryImpl::initialize(): Failed to register dr_ts\n"));
}
OpenDDS::DCPS::DataReaderPeriodicReportTypeSupport_var dr_per_ts =
new OpenDDS::DCPS::DataReaderPeriodicReportTypeSupportImpl();
ret = dr_per_ts->register_type(participant.in(), "");
if (DDS::RETCODE_OK == ret) {
CORBA::String_var dr_per_type_name = dr_per_ts->get_type_name();
writer = create_data_writer(participant.in(),
publisher.in(),
dr_per_type_name.in(),
DATA_READER_PERIODIC_MONITOR_TOPIC,
dw_qos);
this->dr_per_writer_ =
OpenDDS::DCPS::DataReaderPeriodicReportDataWriter::_narrow(writer.in());
if (CORBA::is_nil(this->dr_per_writer_)) {
ACE_DEBUG((LM_DEBUG, "MonitorFactoryImpl::initialize(): Failed to narrow dr_per_writer\n"));
}
} else {
ACE_DEBUG((LM_DEBUG, "MonitorFactoryImpl::initialize(): Failed to register dr_per_ts\n"));
}
OpenDDS::DCPS::TransportReportTypeSupport_var transport_ts =
new OpenDDS::DCPS::TransportReportTypeSupportImpl();
ret = transport_ts->register_type(participant.in(), "");
if (DDS::RETCODE_OK == ret) {
CORBA::String_var transport_type_name = transport_ts->get_type_name();
writer = create_data_writer(participant.in(),
publisher.in(),
transport_type_name.in(),
TRANSPORT_MONITOR_TOPIC,
dw_qos);
this->transport_writer_ =
OpenDDS::DCPS::TransportReportDataWriter::_narrow(writer.in());
if (CORBA::is_nil(this->transport_writer_)) {
ACE_DEBUG((LM_DEBUG, "MonitorFactoryImpl::initialize(): Failed to narrow transport_writer\n"));
}
} else {
ACE_DEBUG((LM_DEBUG, "MonitorFactoryImpl::initialize(): Failed to register transport_ts\n"));
}
}