int
Writer_Base::svc()
{
ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) %C svc() begins. %C\n"), name_, get_id()));
try {
DDS::InstanceHandleSeq handles;
while (true) {
writer_->get_matched_subscriptions(handles);
if (handles.length() > 0)
break;
else
ACE_OS::sleep(ACE_Time_Value(0, 200000));
}
pre_loop();
for (int i = 0; i < num_messages; ++i) {
if (!liveliness_lost_test || i == 0 || i == num_messages - 1) {
in_loop(i);
if (i == 0) {
// Since an arbitrary amount of time was spent in the get_matched_subscriptions
// loop above, any number of liveliness lost callbacks may have already occurred.
// These are not the callbacks that the test is counting (liveliness_lost_test).
DDS::DataWriterListener_var dwl = writer_->get_listener();
DataWriterListenerImpl* listener = dynamic_cast<DataWriterListenerImpl*>(dwl.in());
listener->reset_liveliness_lost_callbacks();
}
}
ACE_OS::sleep(assert_liveliness_period);
}
while (true) {
writer_->get_matched_subscriptions(handles);
if (handles.length() == 0)
break;
else
ACE_OS::sleep(1);
}
} catch (const CORBA::Exception& e) {
cerr << "Exception caught in svc:" << endl << e << endl;
}
ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) Writer_Base::svc finished %C.\n"), name_));
return 0;
}
DDS::DataWriter_var
Factory::writer(const DDS::Publisher_var& pub, const DDS::Topic_var& topic, const DDS::DataWriterListener_var& dwl) const
{
// Create the data writer
DDS::DataWriterQos dw_qos;
pub->get_default_datawriter_qos(dw_qos);
dw_qos.durability.kind = opts_.durability_kind;
dw_qos.liveliness.kind = opts_.liveliness_kind;
dw_qos.liveliness.lease_duration = opts_.LEASE_DURATION;
dw_qos.reliability.kind = opts_.reliability_kind;
DDS::DataWriter_var dw = pub->create_datawriter(topic,
dw_qos,
dwl.in(),
OpenDDS::DCPS::DEFAULT_STATUS_MASK);
// Initialize the transport configuration for the appropriate entity
if (opts_.configuration_str != "none" && opts_.entity_str == "rw")
{
OpenDDS::DCPS::TransportRegistry::instance()->bind_config(opts_.configuration_str,
dw.in());
if (!opts_.entity_autoenable)
{
TEST_ASSERT(DDS::RETCODE_OK == dw->enable());
}
}
return dw;
}
bool
assert_publication_matched(const Options& opts, const DDS::DataWriterListener_var& dwl)
{
// Assert if pub/sub made a match ...
DataWriterListenerImpl* dwl_servant =
dynamic_cast<DataWriterListenerImpl*> (dwl.in());
// check to see if the publisher worked
if (opts.compatible != dwl_servant->publication_matched() && opts.reliability_kind == DDS::RELIABLE_RELIABILITY_QOS)
{
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("(%P|%t) Expected publication_matched to be %C, but it was %C [")
ACE_TEXT(" durability_kind=%C, liveliness_kind=%C, liveliness_duration=%C, ")
ACE_TEXT("reliability_kind=%C]\n"),
(opts.compatible) ? "true" : "false",
(dwl_servant->publication_matched()) ? "true" : "false",
opts.durability_kind_str.c_str(),
opts.liveliness_kind_str.c_str(),
opts.LEASE_DURATION_STR.c_str(),
opts.reliability_kind_str.c_str()),
false);
}
return true;
}
void
OpenDDS::DCPS::OfferedDeadlineWatchdog::execute(OpenDDS::DCPS::PublicationInstance_rch instance, bool timer_called)
{
if (instance->deadline_timer_id_ != -1) {
bool missed = false;
if (instance->cur_sample_tv_ == ACE_Time_Value::zero) { // not write any sample.
missed = true;
} else if (timer_called) { // handle_timeout is called
ACE_Time_Value diff = ACE_OS::gettimeofday() - instance->cur_sample_tv_;
missed = diff >= this->interval_;
} else if (instance->last_sample_tv_ != ACE_Time_Value::zero) { // upon writing sample.
ACE_Time_Value diff = instance->cur_sample_tv_ - instance->last_sample_tv_;
missed = diff > this->interval_;
}
if (missed) {
ACE_GUARD(ACE_Recursive_Thread_Mutex, monitor, this->status_lock_);
if (timer_called) {
++this->status_.total_count;
this->status_.total_count_change =
this->status_.total_count - this->last_total_count_;
this->status_.last_instance_handle = instance->instance_handle_;
this->writer_impl_->set_status_changed_flag(
DDS::OFFERED_DEADLINE_MISSED_STATUS, true);
DDS::DataWriterListener_var listener =
this->writer_impl_->listener_for(
DDS::OFFERED_DEADLINE_MISSED_STATUS);
if (! CORBA::is_nil(listener.in())) {
// Copy before releasing the lock.
DDS::OfferedDeadlineMissedStatus const status = this->status_;
// Release the lock during the upcall.
ACE_GUARD(reverse_lock_type, reverse_monitor, this->reverse_status_lock_);
// @todo Will this operation ever throw? If so we may want to
// catch all exceptions, and act accordingly.
listener->on_offered_deadline_missed(this->writer_.in(),
status);
}
this->writer_impl_->notify_status_condition();
}
}
// This next part is without status_lock_ held to avoid reactor deadlock.
if (!timer_called) {
this->cancel_timer(instance);
this->schedule_timer(instance);
}
} else {
// not an error - timer is scheduled asynchronously so we can get here
// via WriteDataContainer::enqueue() before schedule_timer() is done
}
}
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 ())) {
cerr << "create_participant failed." << endl;
return 1;
}
MessageTypeSupportImpl* servant = new MessageTypeSupportImpl();
if (DDS::RETCODE_OK != servant->register_type(participant.in (), "")) {
cerr << "register_type failed." << endl;
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 ())) {
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);
}
// ----------------------------------------------
// Create the listener.
DDS::DataWriterListener_var listener (new DataWriterListenerImpl);
if (CORBA::is_nil (listener.in ()))
{
cerr << "ERROR: listener is nil." << endl;
exit(1);
}
DDS::DataWriterQos dw_qos; // Good QoS.
pub->get_default_datawriter_qos (dw_qos);
assert (DEADLINE_PERIOD.sec > 1); // Requirement for the test.
// First data writer will have a listener to test listener
// callback on deadline expiration.
DDS::DataWriter_var dw =
pub->create_datawriter (topic.in (),
dw_qos,
listener.in (),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (dw.in ()))
{
cerr << "ERROR: create_datawriter failed." << endl;
exit(1);
}
dw_qos.deadline.period.sec = DEADLINE_PERIOD.sec;
dw_qos.deadline.period.nanosec = DEADLINE_PERIOD.nanosec;
// Set qos with deadline. The watch dog starts now.
if (dw->set_qos (dw_qos) != ::DDS::RETCODE_OK)
{
cerr << "ERROR: set deadline qos failed." << endl;
exit(1);
}
{
// Two threads use same datawriter to write different instances.
std::auto_ptr<Writer> writer1 (new Writer (dw.in (), 99, SLEEP_DURATION));
std::auto_ptr<Writer> writer2 (new Writer (dw.in (), 100, SLEEP_DURATION));
writer1->start ();
writer2->start ();
// ----------------------------------------------
// Wait for fully associate with DataReaders.
if (writer1->wait_for_start () == false || writer2->wait_for_start () == false)
{
cerr << "ERROR: took too long to associate. " << endl;
exit (1);
}
ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%P|%t) Publisher: sleep for %d milliseconds\n"),
SLEEP_DURATION.msec ()));
// Wait for a set of deadline periods to expire.
ACE_OS::sleep (SLEEP_DURATION);
ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%P|%t) Publisher: now verify missed ")
ACE_TEXT ("deadline status \n")));
::DDS::InstanceHandle_t handle1 = writer1->get_instance_handle ();
::DDS::InstanceHandle_t handle2 = writer2->get_instance_handle ();
DDS::OfferedDeadlineMissedStatus deadline_status;
if (dw->get_offered_deadline_missed_status(deadline_status) != ::DDS::RETCODE_OK)
{
cerr << "ERROR: Failed to get offered deadline missed status" << endl;
exit (1);
}
ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%P|%t) Publisher: got missed")
ACE_TEXT ("deadline status \n")));
if (deadline_status.total_count != NUM_EXPIRATIONS * NUM_WRITE_THREADS)
{
cerr << "ERROR: Unexpected number of missed offered "
<< "deadlines (" << deadline_status.total_count
<< " instead of " << NUM_EXPIRATIONS * NUM_WRITE_THREADS << ") "
<< endl;
exit (1);
}
if (deadline_status.total_count_change != NUM_EXPIRATIONS * NUM_WRITE_THREADS)
{
cerr << "ERROR: Incorrect missed offered "
<< "deadline count change ("
<< deadline_status.total_count_change
<< ") instead of " << NUM_EXPIRATIONS * NUM_WRITE_THREADS
<< endl;
exit (1);
}
if (deadline_status.last_instance_handle != handle1
&& deadline_status.last_instance_handle != handle2)
{
cerr << "ERROR: Unexpected last instance handle "
<< deadline_status.last_instance_handle << " instead of "
<< handle1 << " or "
<< handle2 << endl;
exit (1);
}
writer1->wait ();
writer2->wait ();
ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%P|%t) Publisher: sleep for %d milliseconds\n"),
SLEEP_DURATION.msec()));
// Wait for another set of deadline periods to expire.
ACE_OS::sleep (SLEEP_DURATION);
ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%P|%t) Publisher: now verify missed ")
ACE_TEXT ("deadline status \n")));
if (dw->get_offered_deadline_missed_status(deadline_status) != ::DDS::RETCODE_OK)
{
cerr << "ERROR: Failed to get offered deadline missed status" << endl;
exit (1);
}
ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%P|%t) Publisher: got missed")
ACE_TEXT ("deadline status \n")));
if (deadline_status.total_count != (NUM_EXPIRATIONS + 2) * NUM_WRITE_THREADS)
{
cerr << "ERROR: Unexpected number of missed offered "
<< "deadlines (" << deadline_status.total_count
<< " instead of " << (NUM_EXPIRATIONS + 2) * NUM_WRITE_THREADS << ") "
<< endl;
exit (1);
}
if (deadline_status.total_count_change != NUM_WRITE_THREADS * 2)
{
cerr << "ERROR: Incorrect missed offered "
<< "deadline count change ("
<< deadline_status.total_count_change
<< ") instead of " << NUM_WRITE_THREADS * 2
<< endl;
exit (1);
}
if (deadline_status.last_instance_handle != handle1
&& deadline_status.last_instance_handle != handle2)
{
cerr << "ERROR: Unexpected last instance handle "
<< deadline_status.last_instance_handle << " instead of "
<< handle1 << " or "
<< handle2 << endl;
exit (1);
}
// Wait for datareader finish.
while (1)
{
::DDS::InstanceHandleSeq handles;
dw->get_matched_subscriptions (handles);
if (handles.length () == 0)
break;
else
ACE_OS::sleep(1);
}
}
participant->delete_contained_entities();
dpf->delete_participant(participant.in ());
TheServiceParticipant->shutdown ();
}
catch (CORBA::Exception& e)
{
cerr << "PUB: Exception caught in main.cpp:" << endl
<< e << endl;
exit(1);
}
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(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;
}
Test::DataTypeSupportImpl* servant = new Test::DataTypeSupportImpl();
if (DDS::RETCODE_OK != servant->register_type(participant.in (), "")) {
cerr << "register_type failed." << endl;
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 ("Data",
type_name.in (),
topic_qos,
DDS::TopicListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (topic.in ()))
{
cerr << "create_topic failed." << endl;
exit(1);
}
size_t const num_partitions =
sizeof (Test::Offered::PartitionConfigs)
/ sizeof (Test::Offered::PartitionConfigs[0]);
Test::PartitionConfig const * const begin =
Test::Offered::PartitionConfigs;
Test::PartitionConfig const * const end =
begin + num_partitions;
// Keep the writers around long enough for the publications and
// subscriptions to match.
typedef std::vector<DDS::DataWriter_var> writers_type;
writers_type writers (num_partitions);
for (Test::PartitionConfig const * i = begin; i != end; ++i)
{
DDS::PublisherQos pub_qos;
participant->get_default_publisher_qos (pub_qos);
// Specify partitions we're offering.
CORBA::ULong n = 0;
DDS::StringSeq & names = pub_qos.partition.name;
for (char const * const * s = (*i).partitions;
s != 0 && *s != 0;
++s, ++n)
{
CORBA::ULong const new_len = names.length () + 1;
names.length (new_len);
names[n] = *s;
}
DDS::Publisher_var pub =
participant->create_publisher (pub_qos,
DDS::PublisherListener::_nil (),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (pub.in ()))
{
cerr << "create_publisher failed." << endl;
exit(1);
}
DDS::DataWriterListener_var listener (
new Test::DataWriterListener ((*i).expected_matches));
// Create the datawriter
DDS::DataWriterQos dw_qos;
pub->get_default_datawriter_qos (dw_qos);
DDS::DataWriter_var dw =
pub->create_datawriter(topic.in (),
dw_qos,
listener.in (),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (dw.in ()))
{
cerr << "create_datawriter failed." << endl;
exit(1);
}
writers.push_back (dw);
Test::DataDataWriter_var writer
= Test::DataDataWriter::_narrow (dw.in());
if (CORBA::is_nil (writer.in ()))
{
cerr << "Data Writer could not be narrowed"<< endl;
exit(1);
}
Test::Data the_data;
the_data.key = 2;
the_data.the_data = CORBA::string_dup ("Data Wuz Here!");
::DDS::InstanceHandle_t const handle =
writer->register_instance(the_data);
ACE_DEBUG((LM_DEBUG,
ACE_TEXT("(%P|%t) %T PUB starting to write.\n")));
::DDS::ReturnCode_t const ret = writer->write (the_data, handle);;
if (ret != ::DDS::RETCODE_OK)
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT("(%P|%t) ERROR: PUB ")
ACE_TEXT ("write() returned %d.\n"),
ret));
}
}
// // Wait for DataReaders to finish.
// writers_type::const_iterator zend (writers.end ());
// for (writers_type::const_iterator z (writers.begin ()); z != zend; ++z)
// {
// ::DDS::InstanceHandleSeq handles;
// while (1)
// {
// (*z)->get_matched_subscriptions (handles);
// if (handles.length () == 0)
// break;
// else
// ACE_OS::sleep (1);
// }
// }
ACE_OS::sleep (20);
{
// Force contents of writers vector to be destroyed now.
writers_type tmp;
tmp.swap (writers);
}
participant->delete_contained_entities();
dpf->delete_participant(participant.in ());
TheServiceParticipant->shutdown ();
}
catch (CORBA::Exception& e)
{
cerr << "PUB: Exception caught in main.cpp:" << endl
<< e << endl;
exit(1);
}
return 0;
}
int main (int argc, char *argv[]) {
try {
DDS::DomainParticipantFactory_var dpf =
TheParticipantFactoryWithArgs(argc, argv);
if( parse_args(argc, argv) != 0)
return 1;
DDS::DomainParticipant_var participant =
dpf->create_participant(411,
PARTICIPANT_QOS_DEFAULT,
DDS::DomainParticipantListener::_nil());
if (CORBA::is_nil (participant.in ())) {
cerr << "create_participant failed." << endl;
return 1;
}
Messenger::MessageTypeSupportImpl* servant = new Messenger::MessageTypeSupportImpl();
OpenDDS::DCPS::LocalObject_var safe_servant = servant;
if (DDS::RETCODE_OK != servant->register_type(participant.in (), "")) {
cerr << "register_type failed." << endl;
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());
if (CORBA::is_nil (topic.in ())) {
cerr << "create_topic failed." << endl;
exit(1);
}
// Initialize the transport
OpenDDS::DCPS::TransportImpl_rch tcp_impl =
TheTransportFactory->create_transport_impl (TCP_IMPL_ID,
"SimpleTcp",
OpenDDS::DCPS::DONT_AUTO_CONFIG);
OpenDDS::DCPS::TransportConfiguration_rch writer_config
= TheTransportFactory->create_configuration (TCP_IMPL_ID, "SimpleTcp");
OpenDDS::DCPS::SimpleTcpConfiguration* writer_tcp_config
= static_cast <OpenDDS::DCPS::SimpleTcpConfiguration*> (writer_config.in ());
writer_tcp_config->local_address_ = ACE_INET_Addr (local_address.c_str());
writer_tcp_config->local_address_str_ = local_address;
// This is needed for bp_timeout test.
writer_tcp_config->max_output_pause_period_ = 2000;
// This is needed to get the connection deletion callback.
writer_tcp_config->datalink_release_delay_ = 0;
if (tcp_impl->configure(writer_config.in()) != 0)
{
cerr << "Failed to configure the transport." << endl;
exit(1);
}
DDS::Publisher_var pub =
participant->create_publisher(PUBLISHER_QOS_DEFAULT,
DDS::PublisherListener::_nil());
if (CORBA::is_nil (pub.in ())) {
cerr << "create_publisher failed." << endl;
exit(1);
}
// Attach the publisher to the transport.
OpenDDS::DCPS::PublisherImpl* pub_impl =
dynamic_cast<OpenDDS::DCPS::PublisherImpl*> (pub.in ());
if (0 == pub_impl) {
cerr << "Failed to obtain publisher servant" << endl;
exit(1);
}
OpenDDS::DCPS::AttachStatus status = pub_impl->attach_transport(tcp_impl.in());
if (status != OpenDDS::DCPS::ATTACH_OK) {
std::string status_str;
switch (status) {
case OpenDDS::DCPS::ATTACH_BAD_TRANSPORT:
status_str = "ATTACH_BAD_TRANSPORT";
break;
case OpenDDS::DCPS::ATTACH_ERROR:
status_str = "ATTACH_ERROR";
break;
case OpenDDS::DCPS::ATTACH_INCOMPATIBLE_QOS:
status_str = "ATTACH_INCOMPATIBLE_QOS";
break;
default:
status_str = "Unknown Status";
break;
}
cerr << "Failed to attach to the transport. Status == "
<< status_str.c_str() << endl;
exit(1);
}
// activate the listener
DDS::DataWriterListener_var listener (new DataWriterListenerImpl);
if (CORBA::is_nil (listener.in ())) {
cerr << "listener is nil." << endl;
exit(1);
}
// Create the datawriter
DDS::DataWriterQos dw_qos;
pub->get_default_datawriter_qos (dw_qos);
// Make it KEEP_ALL history so we can verify the received
// data without dropping.
dw_qos.history.kind = ::DDS::KEEP_ALL_HISTORY_QOS;
dw_qos.reliability.kind = ::DDS::RELIABLE_RELIABILITY_QOS;
dw_qos.resource_limits.max_samples_per_instance = num_writes;
DDS::DataWriter_var dw =
pub->create_datawriter(topic.in (),
dw_qos,
listener.in ());
if (CORBA::is_nil (dw.in ())) {
cerr << "create_datawriter failed." << endl;
exit(1);
}
Writer* writer = new Writer(dw.in());
// Indicate that the publisher is ready
FILE* writers_ready = ACE_OS::fopen (pub_ready_filename, "w");
if (writers_ready == 0) {
cerr << "ERROR Unable to create publisher ready file" << endl;
exit(1);
}
ACE_OS::fclose(writers_ready);
// Wait for the subscriber to be ready.
FILE* readers_ready = 0;
do {
ACE_Time_Value small(0,250000);
ACE_OS::sleep (small);
readers_ready = ACE_OS::fopen (sub_ready_filename, "r");
} while (0 == readers_ready);
ACE_OS::fclose(readers_ready);
// ensure the associations are fully established before writing.
ACE_OS::sleep(3);
writer->start ();
while ( !writer->is_finished()) {
ACE_Time_Value small(0,250000);
ACE_OS::sleep (small);
}
// Indicate that the publisher is done
FILE* writers_completed = ACE_OS::fopen (pub_finished_filename, "w");
if (writers_completed == 0) {
cerr << "ERROR Unable to i publisher completed file" << endl;
} else {
ACE_OS::fprintf (writers_completed, "%d\n",
writer->get_timeout_writes());
}
ACE_OS::fclose (writers_completed);
// Wait for the subscriber to finish.
FILE* readers_completed = 0;
do {
ACE_Time_Value small(0,250000);
ACE_OS::sleep (small);
readers_completed = ACE_OS::fopen (sub_finished_filename, "r");
} while (0 == readers_completed);
ACE_OS::fclose(readers_completed);
writer->end ();
delete writer;
// Sleep a while before shutdown to avoid the problem of repository
// crashes when it handles both remove_association from subscriber
// and publisher at the same time.
// Cleanup
//ACE_OS::sleep (2);
participant->delete_contained_entities();
dpf->delete_participant(participant.in ());
TheTransportFactory->release();
TheServiceParticipant->shutdown ();
} catch (CORBA::Exception& e) {
cerr << "Exception caught in main.cpp:" << endl
<< e << endl;
exit(1);
}
if (actual_lost_pub_notification != expected_lost_pub_notification)
{
ACE_ERROR ((LM_ERROR, "(%P|%t)ERROR: on_publication_lost called %d times "
"and expected %d times\n", actual_lost_pub_notification,
expected_lost_pub_notification));
return 1;
}
if (num_deleted_connections != expected_deleted_connections)
{
ACE_ERROR ((LM_ERROR, "(%P|%t)ERROR: on_connection_deleted called %d times "
"and expected %d times\n", num_deleted_connections,
expected_deleted_connections));
return 1;
}
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 (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;
}
if (parse_args (argc, argv) != 0)
return -1;
if (delete_data)
{
using OpenDDS::FileSystemStorage::Directory;
Directory::create (ACE_TEXT_ALWAYS_CHAR (dir))->remove ();
dpf->delete_participant (participant);
TheServiceParticipant->shutdown ();
return 0;
}
MessageTypeSupport_var servant = new MessageTypeSupportImpl ();
if (DDS::RETCODE_OK != servant->register_type(participant.in (), ""))
{
cerr << "register_type failed." << endl;
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 ()))
{
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);
}
// Configure DataWriter QoS policies.
DDS::DataWriterQos dw_qos;
pub->get_default_datawriter_qos (dw_qos);
dw_qos.durability.kind = DDS::PERSISTENT_DURABILITY_QOS;
dw_qos.durability_service.history_kind = ::DDS::KEEP_ALL_HISTORY_QOS;
dw_qos.reliability.kind = ::DDS::RELIABLE_RELIABILITY_QOS;
dw_qos.resource_limits.max_samples_per_instance = 1000;
dw_qos.history.kind = ::DDS::KEEP_ALL_HISTORY_QOS;
// -------------------------------------------------------
{
DataWriterListenerImpl* listener = new DataWriterListenerImpl;
DDS::DataWriterListener_var dwl = listener;
// Create a DataWriter.
// Upon exiting this scope, all unsent data should be
// transferred to OpenDDS's data durability cache since the
// run_test.pl script should not have started the subscriber
// until it detects the "Done writing" log text.
DDS::DataWriter_var dw =
pub->create_datawriter (topic.in (),
dw_qos,
dwl.in (),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (dw.in ()))
{
cerr << "create_datawriter failed." << endl;
exit (1);
}
// Only write samples if configured to do so. The expectation
// is to otherwise retrieve the data from the PERSISTENT data
// durability cache.
if (do_write)
{
// Write samples.
std::auto_ptr<Writer> writer (new Writer (dw.in ()));
if (!writer->start () || !writer->end ())
{
// Error logging performed in above method call.
exit (1);
}
// Explicitly destroy the DataWriter.
if (pub->delete_datawriter (dw.in ())
== ::DDS::RETCODE_PRECONDITION_NOT_MET)
{
cerr << "Unable to delete DataWriter" << endl;
exit (1);
}
}
else
{
int const max_attempts = 50;
int attempts;
for (attempts = 1;
attempts != max_attempts
&& listener->publication_matched_.value () == false;
++attempts)
{
ACE_OS::sleep (5);
}
if (attempts == max_attempts)
{
cerr << "ERROR: subscriptions failed to match." << endl;
exit (1);
}
// Wait for DataReader to finish.
::DDS::InstanceHandleSeq handles;
for (attempts = 1; attempts != max_attempts; ++attempts)
{
dw->get_matched_subscriptions (handles);
if (handles.length () == 0)
break;
else
ACE_OS::sleep(1);
}
// The data durability cache should no longer contain samples
// for this domain/topic/type.
}
}
// -------------------------------------------------------
{
// Write samples that will not be sent. Exercise
// service_cleanup_delay. We can either do this through the
// durability member or durability_service member in either of
// TopicQos or DataWriterQos. This test arbitrarily uses the
// DataWriterQos::durability_service member.
// Cleanup data after this number of seconds.
CORBA::Long const delay_seconds = 5;
::DDS::Duration_t & cleanup_delay =
dw_qos.durability_service.service_cleanup_delay;
cleanup_delay.sec = delay_seconds;
cleanup_delay.nanosec = 0;
// Create a dummy topic which will have no subscriptions.
DDS::Topic_var dummy_topic =
participant->create_topic ("Dummy Topic",
type_name.in (),
topic_qos,
DDS::TopicListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
DDS::DataWriter_var dummy_dw =
pub->create_datawriter (dummy_topic.in (),
dw_qos,
::DDS::DataWriterListener::_nil (),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (dummy_dw.in ()))
{
cerr << "create_datawriter for dummy topic failed." << endl;
exit (1);
}
// Write samples using multiple threads.
std::auto_ptr<Writer> writer (new Writer (dummy_dw.in ()));
// Explicitly destroy the DataWriter.
if (pub->delete_datawriter (dummy_dw.in ())
== ::DDS::RETCODE_PRECONDITION_NOT_MET)
{
cerr << "Unable to delete DataWriter" << endl;
exit (1);
}
// Allow durability cleanup to occur
ACE_OS::sleep (delay_seconds + 3);
}
participant->delete_contained_entities();
dpf->delete_participant(participant.in ());
TheServiceParticipant->shutdown ();
} catch (CORBA::Exception& e) {
cerr << "PUB: Exception caught in main.cpp:" << endl
<< e << endl;
exit (1);
}
catch (const std::runtime_error& err) {
ACE_ERROR_RETURN((LM_ERROR, ACE_TEXT("ERROR: main() - %s\n"),
err.what()), -1);
}
return 0;
}
