int
OpenDDS::Model::WriterSync::wait_unmatch(const DDS::DataWriter_var& writer,
unsigned int num_readers)
{
DDS::ReturnCode_t stat;
DDS::StatusCondition_var condition = writer->get_statuscondition();
condition->set_enabled_statuses(DDS::PUBLICATION_MATCHED_STATUS);
DDS::WaitSet_var ws = new DDS::WaitSet;
ws->attach_condition(condition);
DDS::ConditionSeq conditions;
DDS::PublicationMatchedStatus ms = { 0, 0, 0, 0, 0 };
DDS::Duration_t timeout = { 1, 0 };
do {
if (DCPS_debug_level > 4) {
ACE_DEBUG((LM_NOTICE, ACE_TEXT("WriterSync: pub checking unmatched\n")));
}
stat = writer->get_publication_matched_status(ms);
if (stat != DDS::RETCODE_OK) {
ACE_ERROR_RETURN((
LM_ERROR,
ACE_TEXT("(%P|%t) ERROR: %N:%l: wait_unmatch() -")
ACE_TEXT(" get_publication_matched_status failed!\n")),
-1);
} else if (ms.current_count == 0 && (unsigned int)ms.total_count >= num_readers) {
if (DCPS_debug_level > 4) {
ACE_DEBUG((LM_NOTICE, ACE_TEXT("WriterSync: pub match count %d total count %d\n"),
ms.current_count, ms.total_count));
}
break; // unmatched
}
if (DCPS_debug_level > 4) {
ACE_DEBUG((LM_NOTICE, ACE_TEXT("WriterSync: pub match count %d total count %d\n"),
ms.current_count, ms.total_count));
}
// wait for a change
stat = ws->wait(conditions, timeout);
if ((stat != DDS::RETCODE_OK) && (stat != DDS::RETCODE_TIMEOUT)) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("(%P|%t) ERROR: %N:%l: wait_unmatch() -")
ACE_TEXT(" wait failed!\n")),
-1);
}
} while (true);
ws->detach_condition(condition);
if (DCPS_debug_level > 4) {
ACE_DEBUG((LM_NOTICE, ACE_TEXT("WriterSync: pub unmatched\n")));
}
return 0;
}
Publisher::Publisher( const Options& options)
: status_( 0),
options_( options),
participant_(0),
publisher_(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: 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 and register the type support.
DataTypeSupportImpl* testData = new DataTypeSupportImpl();
CORBA::String_var type_name = testData->get_type_name();
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"),
type_name.in()
));
throw BadTypeSupportException ();
} else if( this->options_.verbose()) {
ACE_DEBUG((LM_DEBUG,
ACE_TEXT("(%P|%t) Publisher::Publisher() - ")
ACE_TEXT("created type %C support.\n"),
type_name.in()
));
}
// Create the topic.
DDS::Topic_var topic = this->participant_->create_topic(
this->options_.topicName().c_str(),
type_name,
TOPIC_QOS_DEFAULT,
::DDS::TopicListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK
);
if( CORBA::is_nil( 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")
));
}
// 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;
writerQos.reliability.kind = ::DDS::RELIABLE_RELIABILITY_QOS;
if( this->options_.verbose()) {
ACE_DEBUG((LM_DEBUG,
ACE_TEXT("(%P|%t) Publisher::Publisher() - ")
ACE_TEXT("starting to create %d publications.\n"),
this->options_.publications()
));
}
// Build as many publications as are specified.
for( int index = 0; index < this->options_.publications(); ++index) {
// Create the writer.
DDS::DataWriter_var writer
= this->publisher_->create_datawriter(
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 publication %d.\n"),
(1+index)
));
}
// Create a publication and store it.
this->publications_.push_back(
new Writer( writer.in(), 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 %d.\n"),
(1+index)
));
}
}
}
int ACE_TMAIN(int argc, ACE_TCHAR** argv)
{
try {
OpenDDS::Model::Application application(argc, argv);
UDP::DefaultUDPType model(application, argc, argv);
using OpenDDS::Model::UDP::Elements;
DDS::DataWriter_var writer = model.writer( Elements::DataWriters::writer);
// START OF EXISTING MESSENGER EXAMPLE CODE
MessageDataWriter_var message_writer =
MessageDataWriter::_narrow(writer.in());
if (CORBA::is_nil(message_writer.in())) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("(%P|%t) ERROR: %N:%l: main() -")
ACE_TEXT(" _narrow failed!\n")),
-1);
}
// Block until Subscriber is available
DDS::StatusCondition_var condition = writer->get_statuscondition();
condition->set_enabled_statuses(DDS::PUBLICATION_MATCHED_STATUS);
DDS::WaitSet_var ws = new DDS::WaitSet;
ws->attach_condition(condition);
DDS::ConditionSeq conditions;
DDS::PublicationMatchedStatus matches = { 0, 0, 0, 0, 0 };
DDS::Duration_t timeout = { 30, 0 };
do {
if (ws->wait(conditions, timeout) != DDS::RETCODE_OK) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("(%P|%t) ERROR: %N:%l: main() -")
ACE_TEXT(" wait failed!\n")),
-1);
}
if (writer->get_publication_matched_status(matches) != ::DDS::RETCODE_OK) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("(%P|%t) ERROR: %N:%l: main() -")
ACE_TEXT(" get_publication_matched_status failed!\n")),
-1);
}
} while (matches.current_count < 1);
ws->detach_condition(condition);
// Write samples
Message message;
message.subject_id = 99;
message.from = CORBA::string_dup("Comic Book Guy");
message.subject = CORBA::string_dup("Review");
message.text = CORBA::string_dup("Worst. Movie. Ever.");
message.count = 0;
for (int i = 0; i < 10; i++) {
DDS::ReturnCode_t error = message_writer->write(message, DDS::HANDLE_NIL);
++message.count;
if (error != DDS::RETCODE_OK) {
ACE_ERROR((LM_ERROR,
ACE_TEXT("(%P|%t) ERROR: %N:%l: main() -")
ACE_TEXT(" write returned %d!\n"), error));
}
}
// Cannot wait for samples to be acknowledged - not supported in UDP
std::cout << "publisher sleeping...." << std::endl;
ACE_OS::sleep(2);
std::cout << "publisher done sleeping" << std::endl;
// END OF EXISTING MESSENGER EXAMPLE CODE
} catch (const CORBA::Exception& e) {
e._tao_print_exception("Exception caught in main():");
return -1;
} catch( const std::exception& ex) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("(%P|%t) ERROR: %N:%l: main() -")
ACE_TEXT(" Exception caught: %C\n"),
ex.what()),
-1);
}
return 0;
}
int
ParticipantTask::svc()
{
try
{
ACE_DEBUG((LM_INFO, ACE_TEXT("(%P|%t) -> PARTICIPANT STARTED\n")));
DDS::DomainParticipantFactory_var dpf = TheParticipantFactory;
DDS::DomainParticipant_var participant;
DDS::Publisher_var publisher;
DDS::DataWriter_var writer;
FooDataWriter_var writer_i;
DDS::StatusCondition_var cond;
DDS::WaitSet_var ws = new DDS::WaitSet;
{ // Scope for guard to serialize creating Entities.
GuardType guard(lock_);
// Create Participant
participant =
dpf->create_participant(42,
PARTICIPANT_QOS_DEFAULT,
DDS::DomainParticipantListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
#ifdef OPENDDS_SAFETY_PROFILE
// RTPS cannot be shared
char config_name[64], inst_name[64];
ACE_OS::snprintf(config_name, 64, "cfg_%d", thread_index_);
ACE_OS::snprintf(inst_name, 64, "rtps_%d", thread_index_);
++thread_index_;
ACE_DEBUG((LM_INFO,
"(%P|%t) -> PARTICIPANT creating transport config %C\n",
config_name));
OpenDDS::DCPS::TransportConfig_rch config =
TheTransportRegistry->create_config(config_name);
OpenDDS::DCPS::TransportInst_rch inst =
TheTransportRegistry->create_inst(inst_name, "rtps_udp");
config->instances_.push_back(inst);
TheTransportRegistry->bind_config(config_name, participant);
#endif
} // End of lock scope.
if (CORBA::is_nil(participant.in()))
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l: svc()")
ACE_TEXT(" create_participant failed!\n")), 1);
{
// Create Publisher
publisher =
participant->create_publisher(PUBLISHER_QOS_DEFAULT,
DDS::PublisherListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil(publisher.in()))
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l: svc()")
ACE_TEXT(" create_publisher failed!\n")), 1);
// Register Type (FooType)
FooTypeSupport_var ts = new FooTypeSupportImpl;
if (ts->register_type(participant.in(), "") != DDS::RETCODE_OK)
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l: svc()")
ACE_TEXT(" register_type failed!\n")), 1);
// Create Topic (FooTopic)
DDS::Topic_var topic =
participant->create_topic("FooTopic",
ts->get_type_name(),
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: svc()")
ACE_TEXT(" create_topic failed!\n")), 1);
// Create DataWriter
DDS::DataWriterQos writer_qos;
publisher->get_default_datawriter_qos(writer_qos);
#ifndef OPENDDS_NO_OWNERSHIP_PROFILE
writer_qos.history.depth = samples_per_thread_;
#endif
writer =
publisher->create_datawriter(topic.in(),
writer_qos,
DDS::DataWriterListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil(writer.in()))
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l: svc()")
ACE_TEXT(" create_datawriter failed!\n")), 1);
writer_i = FooDataWriter::_narrow(writer);
if (CORBA::is_nil(writer_i))
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l: svc()")
ACE_TEXT(" _narrow failed!\n")), 1);
// Block until Subscriber is available
cond = writer->get_statuscondition();
cond->set_enabled_statuses(DDS::PUBLICATION_MATCHED_STATUS);
ws->attach_condition(cond);
DDS::Duration_t timeout =
{ DDS::DURATION_INFINITE_SEC, DDS::DURATION_INFINITE_NSEC };
DDS::ConditionSeq conditions;
DDS::PublicationMatchedStatus matches = {0, 0, 0, 0, 0};
do
{
if (ws->wait(conditions, timeout) != DDS::RETCODE_OK)
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l: svc()")
ACE_TEXT(" wait failed!\n")), 1);
if (writer->get_publication_matched_status(matches) != ::DDS::RETCODE_OK)
{
ACE_ERROR ((LM_ERROR,
"(%P|%t) ERROR: failed to get publication matched status\n"));
ACE_OS::exit (1);
}
}
while (matches.current_count < 1);
ws->detach_condition(cond);
// The following is intentionally inefficient to stress various
// pathways related to publication; we should be especially dull
// and write only one sample at a time per writer.
ProgressIndicator progress("(%P|%t) PARTICIPANT %d%% (%d samples sent)\n",
samples_per_thread_);
for (std::size_t i = 0; i < samples_per_thread_; ++i)
{
Foo foo;
foo.key = 3;
DDS::InstanceHandle_t handle = writer_i->register_instance(foo);
if (writer_i->write(foo, handle) != DDS::RETCODE_OK) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l: svc()")
ACE_TEXT(" write failed!\n")), 1);
}
++progress;
}
DDS::Duration_t interval = { 30, 0};
if( DDS::RETCODE_OK != writer->wait_for_acknowledgments( interval)) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("(%P:%t) ERROR: svc() - ")
ACE_TEXT("timed out waiting for acks!\n")
), 1);
}
}
// Clean-up!
ACE_DEBUG((LM_INFO, ACE_TEXT("(%P|%t) <- PUBLISHER PARTICIPANT DEL CONT ENTITIES\n")));
participant->delete_contained_entities();
ACE_DEBUG((LM_INFO, ACE_TEXT("(%P|%t) <- PUBLISHER DELETE PARTICIPANT\n")));
dpf->delete_participant(participant.in());
ACE_DEBUG((LM_INFO, ACE_TEXT("(%P|%t) <- PUBLISHER PARTICIPANT VARS GOING OUT OF SCOPE\n")));
}
catch (const CORBA::Exception& e)
{
e._tao_print_exception("caught in svc()");
return 1;
}
ACE_DEBUG((LM_INFO, ACE_TEXT("(%P|%t) <- PARTICIPANT FINISHED\n")));
return 0;
}
int
ParticipantTask::svc()
{
try
{
ACE_DEBUG((LM_INFO, ACE_TEXT("(%P|%t) -> PARTICIPANT STARTED\n")));
ACE_Time_Value delay_between_pubs(0, this->delay_between_pubs_msec_ * 1000);
DDS::DomainParticipantFactory_var dpf = TheParticipantFactory;
// Create Participant
DDS::DomainParticipant_var participant =
dpf->create_participant(42,
PARTICIPANT_QOS_DEFAULT,
DDS::DomainParticipantListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil(participant.in()))
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l: svc()")
ACE_TEXT(" create_participant failed!\n")), 1);
// Create Publisher
DDS::Publisher_var publisher =
participant->create_publisher(PUBLISHER_QOS_DEFAULT,
DDS::PublisherListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil(publisher.in()))
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l: svc()")
ACE_TEXT(" create_publisher failed!\n")), 1);
// Register Type (FooType)
FooTypeSupport_var ts = new FooTypeSupportImpl;
if (ts->register_type(participant.in(), "") != DDS::RETCODE_OK)
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l: svc()")
ACE_TEXT(" register_type failed!\n")), 1);
// Create Topic (FooTopic)
DDS::Topic_var topic =
participant->create_topic("FooTopic",
ts->get_type_name(),
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: svc()")
ACE_TEXT(" create_topic failed!\n")), 1);
// Create DataWriter
DDS::DataWriterQos writer_qos;
publisher->get_default_datawriter_qos(writer_qos);
writer_qos.history.depth = samples_per_thread_;
if (deadline_.sec > 0 || deadline_.nanosec > 0)
{
writer_qos.deadline.period.sec = deadline_.sec;
writer_qos.deadline.period.nanosec = deadline_.nanosec;
}
DDS::DataWriter_var writer =
publisher->create_datawriter(topic.in(),
writer_qos,
DDS::DataWriterListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil(writer.in()))
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l: svc()")
ACE_TEXT(" create_datawriter failed!\n")), 1);
FooDataWriter_var writer_i = FooDataWriter::_narrow(writer);
if (CORBA::is_nil(writer_i))
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l: svc()")
ACE_TEXT(" _narrow failed!\n")), 1);
// Block until Subscriber is available
DDS::StatusCondition_var cond = writer->get_statuscondition();
cond->set_enabled_statuses(DDS::PUBLICATION_MATCHED_STATUS);
DDS::WaitSet_var ws = new DDS::WaitSet;
ws->attach_condition(cond);
DDS::Duration_t timeout =
{ DDS::DURATION_INFINITE_SEC, DDS::DURATION_INFINITE_NSEC };
DDS::ConditionSeq conditions;
DDS::PublicationMatchedStatus matches = {0, 0, 0, 0, 0};
do
{
if (ws->wait(conditions, timeout) != DDS::RETCODE_OK)
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l: svc()")
ACE_TEXT(" wait failed!\n")), 1);
if (writer->get_publication_matched_status(matches) != ::DDS::RETCODE_OK)
{
ACE_ERROR ((LM_ERROR,
"(%P|%t) ERROR: failed to get publication matched status\n"));
ACE_OS::exit (1);
}
}
while (matches.current_count < 1);
ws->detach_condition(cond);
// The following is intentionally inefficient to stress various
// pathways related to publication; we should be especially dull
// and write only one sample at a time per writer.
ProgressIndicator progress("(%P|%t) PARTICIPANT %d%% (%d samples sent)\n",
samples_per_thread_);
for (std::size_t i = 0; i < samples_per_thread_; ++i)
{
Foo foo;
foo.key = 3;
DDS::InstanceHandle_t handle = writer_i->register_instance(foo);
if (writer_i->write(foo, handle) != DDS::RETCODE_OK)
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l: svc()")
ACE_TEXT(" write failed!\n")), 1);
++progress;
ACE_OS::sleep(delay_between_pubs);
}
DDS::Duration_t interval = { 30, 0};
if( DDS::RETCODE_OK != writer->wait_for_acknowledgments( interval)) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("(%P:%t) ERROR: svc() - ")
ACE_TEXT("timed out waiting for acks!\n")
), 1);
}
publisher->delete_datawriter(writer);
// Clean-up!
participant->delete_contained_entities();
dpf->delete_participant(participant.in());
}
catch (const CORBA::Exception& e)
{
e._tao_print_exception("caught in svc()");
return 1;
}
ACE_DEBUG((LM_INFO, ACE_TEXT("(%P|%t) <- PARTICIPANT FINISHED\n")));
return 0;
}
int ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
try {
// Initialize DomainParticipantFactory
DDS::DomainParticipantFactory_var dpf =
TheParticipantFactoryWithArgs(argc, argv);
int error;
if ((error = parse_args(argc, argv)) != 0) {
return error;
}
// Create DomainParticipant
DDS::DomainParticipant_var participant =
dpf->create_participant(4,
PARTICIPANT_QOS_DEFAULT,
0,
OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (!participant) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("ERROR: %N:%l: main() -")
ACE_TEXT(" create_participant failed!\n")),
-1);
}
ACE_DEBUG((LM_DEBUG, "(%P|%t) Start publisher\n"));
{
// Register TypeSupport (Messenger::Message)
Messenger::MessageTypeSupport_var ts =
new Messenger::MessageTypeSupportImpl;
if (ts->register_type(participant, "Messenger") != DDS::RETCODE_OK) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("ERROR: %N:%l: main() -")
ACE_TEXT(" register_type failed!\n")),
-1);
}
// Create Topic (Movie Discussion List)
CORBA::String_var type_name = ts->get_type_name();
ACE_DEBUG((LM_DEBUG, "registered type name = %s\n", type_name.in()));
DDS::Topic_var topic =
participant->create_topic("Movie Discussion List",
type_name,
TOPIC_QOS_DEFAULT,
0,
OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (!topic) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("ERROR: %N:%l: main() -")
ACE_TEXT(" create_topic failed!\n")),
-1);
}
// setup partition
DDS::PublisherQos pub_qos;
participant->get_default_publisher_qos(pub_qos);
DDS::StringSeq my_partition;
my_partition.length(1);
my_partition[0] = "One";
pub_qos.partition.name = my_partition;
// Create Publisher
DDS::Publisher_var publisher =
participant->create_publisher(pub_qos,
0,
OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (!publisher) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("ERROR: %N:%l: main() -")
ACE_TEXT(" create_publisher failed!\n")),
-1);
}
// Create DataWriter
DDS::DataWriter_var writer =
publisher->create_datawriter(topic,
DATAWRITER_QOS_DEFAULT,
0,
OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (!writer) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("ERROR: %N:%l: main() -")
ACE_TEXT(" create_datawriter failed!\n")),
-1);
}
Messenger::MessageDataWriter_var message_writer =
Messenger::MessageDataWriter::_narrow(writer);
if (!message_writer) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("ERROR: %N:%l: main() -")
ACE_TEXT(" _narrow failed!\n")),
-1);
}
// Block until Subscriber is available
DDS::StatusCondition_var condition = writer->get_statuscondition();
condition->set_enabled_statuses(DDS::PUBLICATION_MATCHED_STATUS);
DDS::WaitSet_var ws = new DDS::WaitSet;
ws->attach_condition(condition);
while (true) {
DDS::PublicationMatchedStatus matches;
if (writer->get_publication_matched_status(matches) != ::DDS::RETCODE_OK) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("ERROR: %N:%l: main() -")
ACE_TEXT(" get_publication_matched_status failed!\n")),
-1);
}
if (matches.current_count >= 1) {
break;
}
DDS::ConditionSeq conditions;
DDS::Duration_t timeout = { 60, 0 };
if (ws->wait(conditions, timeout) != DDS::RETCODE_OK) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("ERROR: %N:%l: main() -")
ACE_TEXT(" wait failed!\n")),
-1);
}
}
ws->detach_condition(condition);
// Write samples
Messenger::Message message;
message.subject_id = 99;
message.from = "Comic Book Guy";
message.subject = "Review";
message.text = "Worst. Movie. Ever.";
message.count = 0;
for (int i = 0; i < 10; ++i) {
DDS::ReturnCode_t error = message_writer->write(message, DDS::HANDLE_NIL);
++message.count;
++message.subject_id;
if (error != DDS::RETCODE_OK) {
ACE_ERROR((LM_ERROR,
ACE_TEXT("ERROR: %N:%l: main() -")
ACE_TEXT(" write returned %d!\n"), error));
}
}
}
ACE_DEBUG((LM_DEBUG, "(%P|%t) Stop publisher\n"));
// Clean-up!
participant->delete_contained_entities();
dpf->delete_participant(participant);
TheServiceParticipant->shutdown();
} catch (const CORBA::Exception& e) {
e._tao_print_exception("Exception caught in main():");
return -1;
}
ACE_DEBUG((LM_DEBUG, "(%P|%t) Publisher exiting\n"));
return 0;
}
int svc()
{
int thread_id = thread_counter_++;
// Create Publisher
DDS::Publisher_var publisher =
participant_->create_publisher(PUBLISHER_QOS_DEFAULT,
0,
OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (!publisher) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("ERROR: %N:%l: main() -")
ACE_TEXT(" create_publisher failed!\n")),
-1);
}
writers_[thread_id].resize(6);
ACE_DEBUG((LM_DEBUG, "(%P|%t) Starting DataWriter %C\n", writers_[thread_id].c_str()));
DDS::DataWriterQos qos;
publisher->get_default_datawriter_qos(qos);
qos.user_data.value.length(3);
qos.user_data.value[0] = fromhex(writers_[thread_id], 0);
qos.user_data.value[1] = fromhex(writers_[thread_id], 1);
qos.user_data.value[2] = fromhex(writers_[thread_id], 2);
if (reliable_) {
qos.reliability.kind = DDS::RELIABLE_RELIABILITY_QOS;
qos.reliability.max_blocking_time.sec = DDS::DURATION_INFINITE_SEC;
// qos.resource_limits.max_instances = 10;
// qos.history.depth = 10;
} else {
qos.reliability.kind = DDS::BEST_EFFORT_RELIABILITY_QOS;
}
// Create DataWriter
DDS::DataWriter_var writer =
publisher->create_datawriter(topic_,
qos,
0,
OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (!writer) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("ERROR: %N:%l: main() -")
ACE_TEXT(" create_datawriter failed!\n")),
-1);
}
TestMsgDataWriter_var message_writer =
TestMsgDataWriter::_narrow(writer);
if (!message_writer) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("ERROR: %N:%l: main() -")
ACE_TEXT(" _narrow failed!\n")),
-1);
}
// Block until Subscriber is available
DDS::StatusCondition_var condition = writer->get_statuscondition();
condition->set_enabled_statuses(DDS::PUBLICATION_MATCHED_STATUS);
DDS::WaitSet_var ws = new DDS::WaitSet;
ws->attach_condition(condition);
while (true) {
DDS::PublicationMatchedStatus matches;
if (writer->get_publication_matched_status(matches) != ::DDS::RETCODE_OK) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("ERROR: %N:%l: main() -")
ACE_TEXT(" get_publication_matched_status failed!\n")),
-1);
}
ACE_DEBUG((LM_DEBUG, "(%P|%t) DataWriter %C has %d of %d readers\n", writers_[thread_id].c_str(), matches.current_count, total_readers_));
if (matches.current_count >= total_readers_) {
break;
}
DDS::ConditionSeq conditions;
DDS::Duration_t timeout = { 60, 0 };
if (ws->wait(conditions, timeout) != DDS::RETCODE_OK) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("ERROR: %N:%l: main() -")
ACE_TEXT(" wait failed!\n")),
-1);
}
}
ws->detach_condition(condition);
// Write samples
TestMsg message;
message.value = 0;
for (int i = 0; i < MSGS_PER_WRITER; ++i) {
DDS::ReturnCode_t error = message_writer->write(message, DDS::HANDLE_NIL);
++message.value;
if (error != DDS::RETCODE_OK) {
ACE_ERROR((LM_ERROR,
ACE_TEXT("ERROR: %N:%l: main() -")
ACE_TEXT(" write returned %d!\n"), error));
}
}
ACE_DEBUG((LM_DEBUG, "(%P|%t) DataWriter %C is waiting for acknowledgements\n", writers_[thread_id].c_str()));
DDS::Duration_t timeout = { 30, 0 };
message_writer->wait_for_acknowledgments(timeout);
// With static discovery, it's not an error for wait_for_acks to fail
// since the peer process may have terminated before sending acks.
ACE_DEBUG((LM_DEBUG, "(%P|%t) DataWriter %C is done\n", writers_[thread_id].c_str()));
return 0;
}
int ACE_TMAIN (int argc, ACE_TCHAR *argv[]){
try
{
DDS::DomainParticipantFactory_var dpf =
TheParticipantFactoryWithArgs(argc, argv);
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 ())) {
ACE_DEBUG((LM_DEBUG, "create_participant failed.\n"));
return 1;
}
MessageTypeSupportImpl* servant = new MessageTypeSupportImpl();
if (DDS::RETCODE_OK != servant->register_type(participant.in (), "")) {
ACE_DEBUG((LM_DEBUG, "register_type failed.\n"));
exit(1);
}
CORBA::String_var type_name = servant->get_type_name ();
DDS::TopicQos topic_qos;
participant->get_default_topic_qos(topic_qos);
DDS::Topic_var topic =
participant->create_topic ("Movie Discussion List",
type_name.in (),
topic_qos,
DDS::TopicListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (topic.in ())) {
ACE_DEBUG((LM_DEBUG, "create_topic failed.\n"));
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 ())) {
ACE_DEBUG((LM_DEBUG, "create_publisher failed.\n"));
exit(1);
}
DDS::DataWriterQos dw_qos;
pub->get_default_datawriter_qos (dw_qos);
dw_qos.deadline.period.sec = 4;
dw_qos.deadline.period.nanosec = 0;
// Create DataWriter with 4 second deadline period which
// should be compatible with first DataReader which has 5
// seconds deadline period and not with second DataReader
// which has 3 seconds deadline period.
DDS::DataWriter_var dw =
pub->create_datawriter(topic, dw_qos, 0,
OpenDDS::DCPS::DEFAULT_STATUS_MASK);
int const max_attempts = 20000;
int attempts = 1;
{
// Wait for both first DataReader connect and write messages.
std::auto_ptr<Writer> writer (new Writer (dw.in ()));
while (attempts != max_attempts)
{
::DDS::InstanceHandleSeq handles;
dw->get_matched_subscriptions(handles);
if (handles.length() == 1)
break;
else
ACE_OS::sleep(1);
++attempts;
}
if (attempts == max_attempts)
{
ACE_DEBUG((LM_DEBUG, "ERROR: subscriptions failed to match.\n"));
exit (1);
}
writer->start ();
writer->end ();
ACE_DEBUG((LM_DEBUG, "Writer changing deadline to incompatible value\n"));
// Now set DataWriter deadline to be 6 seconds which is not
// compatible with the existing DataReader. This QoS change
// should be applied and the association broken.
dw_qos.deadline.period.sec = 6;
if (dw->set_qos (dw_qos) != ::DDS::RETCODE_OK) {
ACE_DEBUG((LM_DEBUG,
"ERROR: DataWriter could not change deadline period which "
"should break DataReader associations\n"));
exit (1);
} else {
DDS::WaitSet_var ws = new DDS::WaitSet;
DDS::StatusCondition_var sc = dw->get_statuscondition();
sc->set_enabled_statuses(DDS::PUBLICATION_MATCHED_STATUS);
ws->attach_condition(sc);
DDS::PublicationMatchedStatus matched;
DDS::ConditionSeq active;
const DDS::Duration_t timeout = {5, 0}; // seconds
while (dw->get_publication_matched_status(matched) == DDS::RETCODE_OK
&& matched.current_count) {
if (ws->wait(active, timeout) == DDS::RETCODE_TIMEOUT) {
break;
}
}
ws->detach_condition(sc);
if (matched.current_count != 0) {
ACE_DEBUG((LM_DEBUG,
"ERROR: DataWriter changed deadline period which should "
"break association with all existing DataReaders, but did not\n"));
exit(1);
}
}
// We know the reader has been disassociated, but the reader itself may
// not have been notified yet. Introducing delay here to let the reader
// sync up with the disassociated state before re-associating.
// Wait for reader to finish unmatching.
FILE* fp = ACE_OS::fopen (synch_fname, ACE_TEXT("r"));
int i = 0;
while (fp == 0 && i < 15)
{
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT("(%P|%t) waiting reader to unmatch...\n")));
ACE_OS::sleep (1);
++i;
fp = ACE_OS::fopen (synch_fname, ACE_TEXT("r"));
}
if (fp != 0)
ACE_OS::fclose (fp);
ACE_DEBUG((LM_DEBUG, "Writer restoring deadline to compatible value\n"));
// change it back
dw_qos.deadline.period.sec = 5;
if (dw->set_qos (dw_qos) != ::DDS::RETCODE_OK)
{
ACE_DEBUG((LM_DEBUG,
"ERROR: DataWriter could not change deadline period which "
"should restore DataReader associations\n"));
exit (1);
}
}
{
// Wait for both second DataReader connect which changed deadline period
// from 3 seconds to 5 seconds.
std::auto_ptr<Writer> writer (new Writer (dw.in ()));
attempts = 1;
while (attempts != max_attempts)
{
::DDS::InstanceHandleSeq handles;
dw->get_matched_subscriptions(handles);
if (handles.length() == 2)
break;
else
ACE_OS::sleep(1);
++attempts;
}
if (attempts == max_attempts)
{
ACE_DEBUG((LM_DEBUG, "ERROR: subscriptions failed to match.\n"));
exit(1);
}
writer->start ();
writer->end ();
}
{
// Wait for subscriber exit.
attempts = 1;
while (attempts != max_attempts)
{
::DDS::InstanceHandleSeq handles;
dw->get_matched_subscriptions(handles);
if (handles.length() == 0)
break;
else
ACE_OS::sleep(1);
++ attempts;
}
if (attempts == max_attempts)
{
ACE_DEBUG((LM_DEBUG, "ERROR: failed to wait for DataReader exit.\n"));
exit (1);
}
}
participant->delete_contained_entities();
dpf->delete_participant(participant.in ());
}
catch (CORBA::Exception& e)
{
cerr << "PUB: Exception caught in main.cpp:" << endl
<< e << endl;
exit(1);
}
TheServiceParticipant->shutdown ();
return 0;
}
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()
));
}
}
}
int
ACE_TMAIN(int argc, ACE_TCHAR** argv)
{
try
{
TheParticipantFactoryWithArgs(argc, argv);
// Create Participant
DDS::DomainParticipant_var participant =
TheParticipantFactory->create_participant(42,
PARTICIPANT_QOS_DEFAULT,
DDS::DomainParticipantListener::_nil(),
OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil(participant.in()))
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l: main()")
ACE_TEXT(" ERROR: create_participant failed!\n")), 1);
// Create Subscriber
DDS::Subscriber_var subscriber =
participant->create_subscriber(SUBSCRIBER_QOS_DEFAULT,
DDS::SubscriberListener::_nil(),
OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil(subscriber.in()))
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l: main()")
ACE_TEXT(" ERROR: create_subscriber failed!\n")), 2);
// Create Publisher
DDS::Publisher_var publisher =
participant->create_publisher(PUBLISHER_QOS_DEFAULT,
DDS::PublisherListener::_nil(),
OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil(publisher.in()))
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l: main()")
ACE_TEXT(" ERROR: create_publisher failed!\n")), 1);
OpenDDS::DCPS::TransportIdType transportId(0);
// Attach Subscriber Transport
++transportId;
OpenDDS::DCPS::TransportConfiguration_rch sub_config =
TheTransportFactory->get_or_create_configuration(transportId, ACE_TEXT("SimpleTcp"));
OpenDDS::DCPS::TransportImpl_rch sub_transport =
TheTransportFactory->create_transport_impl(transportId);
OpenDDS::DCPS::SubscriberImpl* subscriber_i =
dynamic_cast<OpenDDS::DCPS::SubscriberImpl*>(subscriber.in());
if (subscriber_i == 0)
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l: main()")
ACE_TEXT(" ERROR: dynamic_cast failed!\n")), 1);
OpenDDS::DCPS::AttachStatus sub_status =
subscriber_i->attach_transport(sub_transport.in());
if (sub_status != OpenDDS::DCPS::ATTACH_OK)
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l: main()")
ACE_TEXT(" ERROR: attach_transport failed!\n")), 1);
// Attach Publisher Transport
++transportId;
OpenDDS::DCPS::TransportConfiguration_rch pub_config =
TheTransportFactory->get_or_create_configuration(transportId, ACE_TEXT("SimpleTcp"));
OpenDDS::DCPS::TransportImpl_rch pub_transport =
TheTransportFactory->create_transport_impl(transportId);
OpenDDS::DCPS::PublisherImpl* publisher_i =
dynamic_cast<OpenDDS::DCPS::PublisherImpl*>(publisher.in());
if (publisher_i == 0)
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l: main()")
ACE_TEXT(" ERROR: dynamic_cast failed!\n")), 1);
OpenDDS::DCPS::AttachStatus pub_status =
publisher_i->attach_transport(pub_transport.in());
if (pub_status != OpenDDS::DCPS::ATTACH_OK)
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l: main()")
ACE_TEXT(" ERROR: attach_transport failed!\n")), 1);
// Register Type (FooType)
FooTypeSupport_var ts = new FooTypeSupportImpl;
if (ts->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 (FooTopic)
DDS::Topic_var topic =
participant->create_topic("FooTopic",
ts->get_type_name(),
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 DataReader
DDS::DataReaderQos qos;
if (subscriber->get_default_datareader_qos(qos) != DDS::RETCODE_OK)
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l main()")
ACE_TEXT(" ERROR: create_datareader failed!\n")), -1);
qos.history.kind = DDS::KEEP_ALL_HISTORY_QOS;
DDS::DataReader_var reader =
subscriber->create_datareader(topic.in(),
qos,
DDS::DataReaderListener::_nil(),
OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil(reader.in()))
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l: main()")
ACE_TEXT(" ERROR: create_datareader failed!\n")), 7);
FooDataReader_var reader_i = FooDataReader::_narrow(reader);
if (CORBA::is_nil(reader_i))
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l: main()")
ACE_TEXT(" ERROR: _narrow failed!\n")), 1);
// Create DataWriter
DDS::DataWriter_var writer =
publisher->create_datawriter(topic.in(),
DATAWRITER_QOS_DEFAULT,
DDS::DataWriterListener::_nil(),
OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil(writer.in()))
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l: main()")
ACE_TEXT(" ERROR: create_datawriter failed!\n")), 1);
FooDataWriter_var writer_i = FooDataWriter::_narrow(writer);
if (CORBA::is_nil(writer_i))
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l: main()")
ACE_TEXT(" ERROR: _narrow failed!\n")), 1);
// Block until Subscriber is associated
DDS::StatusCondition_var cond = writer->get_statuscondition();
cond->set_enabled_statuses(DDS::PUBLICATION_MATCHED_STATUS);
DDS::WaitSet_var ws = new DDS::WaitSet;
ws->attach_condition(cond);
DDS::Duration_t timeout =
{ DDS::DURATION_INFINITE_SEC, DDS::DURATION_INFINITE_NSEC };
DDS::ConditionSeq conditions;
DDS::PublicationMatchedStatus matches = { 0, 0, 0, 0, 0 };
do
{
if (ws->wait(conditions, timeout) != DDS::RETCODE_OK)
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l: main()")
ACE_TEXT(" ERROR: wait failed!\n")), 1);
if (writer->get_publication_matched_status(matches) != ::DDS::RETCODE_OK)
{
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l: main()")
ACE_TEXT(" ERROR: failed to get publication matched status!\n")),
2);
}
}
while (matches.current_count < 1);
ws->detach_condition(cond);
//
// FooDataWriter::dispose should cause an instance to be
// deleted after the last sample in the instance has been
// taken from the ReceivedDataElementList:
//
DDS_TEST test(reader_i);
if (!test) return 1;
Foo foo;
DDS::InstanceHandle_t handle;
handle = writer_i->register_instance(foo);
writer_i->write(foo, handle);
writer_i->dispose(foo, handle);
ACE_OS::sleep(5); // wait for samples to arrive
if (!test.take_all_samples())
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l: main()")
ACE_TEXT(" ERROR: unable to take samples!\n")), 2);
/// Verify instance has been deleted
if (test.has_instance(handle))
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l: main()")
ACE_TEXT(" ERROR: instance not removed!\n")), 3);
// Clean-up!
participant->delete_contained_entities();
TheParticipantFactory->delete_participant(participant);
TheTransportFactory->release();
TheServiceParticipant->shutdown();
}
catch (const CORBA::Exception& e)
{
e._tao_print_exception("caught in main()");
return -1;
}
return 0;
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
try {
// Initialize DomainParticipantFactory
DDS::DomainParticipantFactory_var dpf =
TheParticipantFactoryWithArgs(argc, argv);
// Create DomainParticipant
DDS::DomainParticipant_var participant =
dpf->create_participant(42,
PARTICIPANT_QOS_DEFAULT,
DDS::DomainParticipantListener::_nil(),
OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil(participant.in())) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("ERROR: %N:%l: main() -")
ACE_TEXT(" create_participant failed!\n")),
-1);
}
// Register TypeSupport (Messenger::Message)
Messenger::MessageTypeSupport_var ts =
new Messenger::MessageTypeSupportImpl();
if (ts->register_type(participant.in(), "") != DDS::RETCODE_OK) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("ERROR: %N:%l: main() -")
ACE_TEXT(" register_type failed!\n")),
-1);
}
// Create Topic (Movie Discussion List)
CORBA::String_var type_name = ts->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("ERROR: %N:%l: main() -")
ACE_TEXT(" create_topic failed!\n")),
-1);
}
// Create Publisher
DDS::Publisher_var publisher =
participant->create_publisher(PUBLISHER_QOS_DEFAULT,
DDS::PublisherListener::_nil(),
OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil(publisher.in())) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("ERROR: %N:%l: main() -")
ACE_TEXT(" create_publisher failed!\n")),
-1);
}
// Create DataWriter
DDS::DataWriter_var writer =
publisher->create_datawriter(topic.in(),
DATAWRITER_QOS_DEFAULT,
DDS::DataWriterListener::_nil(),
OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil(writer.in())) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("ERROR: %N:%l: main() -")
ACE_TEXT(" create_datawriter failed!\n")),
-1);
}
Messenger::MessageDataWriter_var message_writer =
Messenger::MessageDataWriter::_narrow(writer.in());
if (CORBA::is_nil(message_writer.in())) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("ERROR: %N:%l: main() -")
ACE_TEXT(" _narrow failed!\n")),
-1);
}
// Block until Subscriber is available
DDS::StatusCondition_var condition = writer->get_statuscondition();
condition->set_enabled_statuses(DDS::PUBLICATION_MATCHED_STATUS);
DDS::WaitSet_var ws = new DDS::WaitSet;
ws->attach_condition(condition);
DDS::ConditionSeq conditions;
DDS::PublicationMatchedStatus matches = { 0, 0, 0, 0, 0 };
DDS::Duration_t timeout = { 30, 0 };
do {
if (ws->wait(conditions, timeout) != DDS::RETCODE_OK) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("ERROR: %N:%l: main() -")
ACE_TEXT(" wait failed!\n")),
-1);
}
if (writer->get_publication_matched_status(matches) != ::DDS::RETCODE_OK) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("ERROR: %N:%l: main() -")
ACE_TEXT(" get_publication_matched_status failed!\n")),
-1);
}
} while (matches.current_count < 1);
ws->detach_condition(condition);
// Write samples
Messenger::Message message;
message.subject_id = 99;
message.from = CORBA::string_dup("Comic Book Guy");
message.subject = CORBA::string_dup("Review");
message.text = CORBA::string_dup("Worst. Movie. Ever.");
message.count = 0;
for (int i = 0; i < 10; i++) {
DDS::ReturnCode_t error = message_writer->write(message, DDS::HANDLE_NIL);
if (error != DDS::RETCODE_OK) {
ACE_ERROR((LM_ERROR,
ACE_TEXT("ERROR: %N:%l: main() -")
ACE_TEXT(" write returned %d!\n"), error));
}
}
// Wait for samples to be acknowledged
if (message_writer->wait_for_acknowledgments(timeout) != DDS::RETCODE_OK) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("ERROR: %N:%l: main() -")
ACE_TEXT(" wait_for_acknowledgments failed!\n")),
-1);
}
// Clean-up!
participant->delete_contained_entities();
dpf->delete_participant(participant.in());
TheServiceParticipant->shutdown();
} catch (const CORBA::Exception& e) {
e._tao_print_exception("Exception caught in main():");
return -1;
}
return 0;
}
