bool
SyncServer_i::wait_session (void)
{
while (true)
{
if (shutdown_) {
break;
}
ACE_Time_Value small_time(0,250000);
ACE_OS::sleep (small_time);
}
return true;
}
int wait_for_data (::DDS::Subscriber_ptr sub,
int timeout_sec)
{
const int factor = 10;
ACE_Time_Value small_time(0,1000000/factor);
int timeout_loops = timeout_sec * factor;
::DDS::DataReaderSeq_var discard = new ::DDS::DataReaderSeq(10);
while (timeout_loops-- > 0)
{
sub->get_datareaders (
discard.inout (),
::DDS::NOT_READ_SAMPLE_STATE,
::DDS::ANY_VIEW_STATE,
::DDS::ANY_INSTANCE_STATE );
if (discard->length () > 0)
return 1;
ACE_OS::sleep (small_time);
}
return 0;
}
int ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
int status = 0;
try
{
ACE_DEBUG((LM_INFO,"(%P|%t) %T publisher main\n"));
dpf = TheParticipantFactoryWithArgs(argc, argv);
// let the Service_Participant (in above line) strip out -DCPSxxx parameters
// and then get application specific parameters.
parse_args (argc, argv);
init ();
// Indicate that the publisher is ready
FILE* writers_ready = ACE_OS::fopen (pub_ready_filename.c_str (), ACE_TEXT("w"));
if (writers_ready == 0)
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT("(%P|%t) ERROR: Unable to create publisher ready file\n")));
}
// Wait for the subscriber to be ready.
FILE* readers_ready = 0;
do
{
ACE_Time_Value small_time(0,250000);
ACE_OS::sleep (small_time);
readers_ready = ACE_OS::fopen (sub_ready_filename.c_str (), ACE_TEXT("r"));
} while (0 == readers_ready);
ACE_OS::fclose(writers_ready);
ACE_OS::fclose(readers_ready);
// ensure the associations are fully established before writing.
ACE_OS::sleep(3);
{ // Extra scope for VC6
for (int i = 0; i < num_datawriters; i ++)
{
writers[i]->start ();
}
}
int timeout_writes = 0;
bool writers_finished = false;
while ( !writers_finished )
{
writers_finished = true;
for (int i = 0; i < num_datawriters; i ++)
{
writers_finished = writers_finished && writers[i]->is_finished();
}
}
{ // Extra scope for VC6
for (int i = 0; i < num_datawriters; i ++)
{
timeout_writes += writers[i]->get_timeout_writes();
}
}
// Indicate that the publisher is done
FILE* writers_completed = ACE_OS::fopen (pub_finished_filename.c_str (), ACE_TEXT("w"));
if (writers_completed == 0)
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT("(%P|%t) ERROR: Unable to i publisher completed file\n")));
}
else
{
ACE_OS::fprintf (writers_completed, "%d\n", timeout_writes);
}
// Wait for the subscriber to finish.
FILE* readers_completed = 0;
do
{
ACE_Time_Value small_time(0,250000);
ACE_OS::sleep (small_time);
readers_completed = ACE_OS::fopen (sub_finished_filename.c_str (), ACE_TEXT("r"));
} while (0 == readers_completed);
ACE_OS::fclose(writers_completed);
ACE_OS::fclose(readers_completed);
{ // Extra scope for VC6
for (int i = 0; i < num_datawriters; i ++)
{
writers[i]->end ();
delete writers[i];
}
}
}
catch (const TestException&)
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT("(%P|%t) TestException caught in main (). ")));
status = 1;
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Exception caught in main ():");
status = 1;
}
try
{
if (! CORBA::is_nil (participant.in ()))
{
participant->delete_contained_entities();
}
if (! CORBA::is_nil (dpf.in ()))
{
dpf->delete_participant(participant.in ());
}
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Exception caught in cleanup.");
status = 1;
}
shutdown ();
return status;
}
int ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
int status = 0;
try
{
ACE_DEBUG((LM_INFO,"(%P|%t) %T subscriber main\n"));
dpf = TheParticipantFactoryWithArgs(argc, argv);
// let the Service_Participant (in above line) strip out -DCPSxxx parameters
// and then get application specific parameters.
parse_args (argc, argv);
init_listener ();
init_dcps_objects (0);
init_dcps_objects (1);
// Indicate that the subscriber is ready
FILE* readers_ready = ACE_OS::fopen (sub_ready_filename.c_str (), ACE_TEXT("w"));
if (readers_ready == 0)
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT("(%P|%t) ERROR: Unable to create subscriber completed file\n")));
}
// Wait for the publisher to be ready
FILE* writers_ready = 0;
do
{
ACE_Time_Value small_time(0,250000);
ACE_OS::sleep (small_time);
writers_ready = ACE_OS::fopen (pub_ready_filename.c_str (), ACE_TEXT("r"));
} while (0 == writers_ready);
ACE_OS::fclose(readers_ready);
ACE_OS::fclose(writers_ready);
int expected
= num_datawriters * num_instances_per_writer * num_samples_per_instance;
FILE* writers_completed = 0;
int timeout_writes = 0;
while ( num_reads < expected)
{
// Get the number of the timed out writes from publisher so we
// can re-calculate the number of expected messages. Otherwise,
// the blocking timeout test will never exit from this loop.
if (writers_completed == 0)
{
writers_completed = ACE_OS::fopen (pub_finished_filename.c_str (), ACE_TEXT("r"));
if (writers_completed != 0)
{
//writers_completed = ACE_OS::fopen (pub_finished_filename.c_str (), ACE_TEXT("r"));
fscanf (writers_completed, "%d\n", &timeout_writes);
expected -= timeout_writes;
ACE_DEBUG((LM_DEBUG,
ACE_TEXT ("(%P|%t) timed out writes %d, we expect %d\n"),
timeout_writes, expected));
}
}
ACE_OS::sleep (1);
}
// Indicate that the subscriber is done
FILE* readers_completed = ACE_OS::fopen (sub_finished_filename.c_str (), ACE_TEXT("w"));
if (readers_completed == 0)
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT("(%P|%t) ERROR: Unable to create subscriber completed file\n")));
}
// Wait for the publisher to finish
while (writers_completed == 0)
{
ACE_Time_Value small_time(0,250000);
ACE_OS::sleep (small_time);
writers_completed = ACE_OS::fopen (pub_finished_filename.c_str (), ACE_TEXT("r"));
}
ACE_OS::fclose(readers_completed);
ACE_OS::fclose(writers_completed);
}
catch (const TestException&)
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT("(%P|%t) TestException caught in main (). ")));
status = 1;
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Exception caught in main ():");
status = 1;
}
try
{
for (int i = 0; i < 2; ++i)
{
if (! CORBA::is_nil (participant[i].in ()))
{
participant[i]->delete_contained_entities();
}
if (! CORBA::is_nil (dpf.in ()))
{
dpf->delete_participant(participant[i].in ());
}
}
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Exception caught in cleanup.");
status = 1;
}
shutdown ();
return status;
}
int ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
int status = 0;
try
{
ACE_DEBUG((LM_INFO,"(%P|%t) %T subscriber main\n"));
::DDS::DomainParticipantFactory_var dpf = TheParticipantFactoryWithArgs(argc, argv);
// TheServiceParticipant->liveliness_factor(100);
// let the Service_Participant (in above line) strip out -DCPSxxx parameters
// and then get application specific parameters.
parse_args(argc, argv);
if (!topics)
{
ACE_ERROR((LM_ERROR,
ACE_TEXT("(%P|%t) Must run with one or more of the following: -t1 -t2 -t3\n")));
return 1;
}
::DDS::DomainParticipant_var dp =
dpf->create_participant(MY_DOMAIN,
PARTICIPANT_QOS_DEFAULT,
::DDS::DomainParticipantListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil(dp.in()))
{
ACE_ERROR((LM_ERROR,
ACE_TEXT("(%P|%t) create_participant failed.\n")));
return 1;
}
::DDS::Subscriber_var sub =
dp->create_subscriber(SUBSCRIBER_QOS_DEFAULT,
::DDS::SubscriberListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil(sub.in()))
{
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("(%P|%t) create_subscriber failed.\n")),
1);
}
// Create the Datareaders
::DDS::DataReaderQos dr_qos;
sub->get_default_datareader_qos(dr_qos);
#ifndef OPENDDS_NO_OWNERSHIP_PROFILE
dr_qos.history.depth = history_depth;
#endif
dr_qos.resource_limits.max_samples_per_instance =
max_samples_per_instance;
dr_qos.liveliness.lease_duration.sec = LEASE_DURATION_SEC;
dr_qos.liveliness.lease_duration.nanosec = 0;
int drl1_num_samples = 0, drl2_num_samples = 0,
drl3_num_samples = 0, drl4_num_samples = 0;
::DDS::DataReaderListener_var drl1 =
new DataReaderListenerImpl<T1::Foo1>(num_ops_per_thread, drl1_num_samples, print1);
::DDS::DataReaderListener_var drl2 =
new DataReaderListenerImpl<T2::Foo2>(num_ops_per_thread, drl2_num_samples, print2);
::DDS::DataReaderListener_var drl3 =
new DataReaderListenerImpl<T3::Foo3>(num_ops_per_thread, drl3_num_samples, print3);
::DDS::DataReaderListener_var drl4 =
new DataReaderListenerImpl<T3::Foo3>(num_ops_per_thread, drl4_num_samples, print3);
::DDS::DataReader_var dr1;
::DDS::DataReader_var dr2;
::DDS::DataReader_var dr3;
::DDS::DataReader_var dr4;
if (topics & TOPIC_T1)
{
dr1 = create_reader<T1::Foo1>(sub, MY_TOPIC1, dr_qos, drl1);
}
if (topics & TOPIC_T2)
{
dr2 = create_reader<T2::Foo2>(sub, MY_TOPIC2, dr_qos, drl2);
}
if (topics & TOPIC_T3)
{
dr3 = create_reader<T3::Foo3>(sub, MY_TOPIC3, dr_qos, drl3);
}
if (topics & TOPIC_T4)
{
dr4 = create_reader<T3::Foo3>(sub, MY_TOPIC4, dr_qos, drl4);
}
/*
// Indicate that the subscriber is ready
FILE* readers_ready = ACE_OS::fopen(sub_ready_filename.c_str(), ACE_TEXT("w"));
if (readers_ready == 0)
{
ACE_ERROR((LM_ERROR,
ACE_TEXT("(%P|%t) ERROR: Unable to create subscriber completed file\n")));
}
// Wait for the publisher to be ready
FILE* writers_ready = 0;
do
{
ACE_Time_Value small(0,250000);
ACE_OS::sleep(small);
writers_ready = ACE_OS::fopen(pub_ready_filename.c_str(), ACE_TEXT("r"));
} while (0 == writers_ready);
ACE_OS::fclose(readers_ready);
ACE_OS::fclose(writers_ready);
*/
// Indicate that the subscriber is done
if (topics & TOPIC_T1)
{
ACE_TString t1_fn = ACE_TEXT(MY_TOPIC1) + sub_finished_filename;
FILE* readers_completed =
ACE_OS::fopen((synch_dir + t1_fn).c_str(), ACE_TEXT("w"));
if (readers_completed == 0)
{
ACE_ERROR((LM_ERROR,
ACE_TEXT("(%P|%t) ERROR: Unable to create subscriber completed file\n")));
}
ACE_OS::fclose(readers_completed);
}
if (topics & TOPIC_T2)
{
ACE_TString t2_fn = ACE_TEXT(MY_TOPIC2) + sub_finished_filename;
FILE* readers_completed =
ACE_OS::fopen((synch_dir + t2_fn).c_str(), ACE_TEXT("w"));
if (readers_completed == 0)
{
ACE_ERROR((LM_ERROR,
ACE_TEXT("(%P|%t) ERROR: Unable to create subscriber completed file\n")));
}
ACE_OS::fclose(readers_completed);
}
if (topics & TOPIC_T3)
{
ACE_TString t3_fn = ACE_TEXT(MY_TOPIC3) + sub_finished_filename;
FILE* readers_completed =
ACE_OS::fopen((synch_dir + t3_fn).c_str(), ACE_TEXT("w"));
if (readers_completed == 0)
{
ACE_ERROR((LM_ERROR,
ACE_TEXT("(%P|%t) ERROR: Unable to create subscriber completed file\n")));
}
ACE_OS::fclose(readers_completed);
}
// Wait for the publisher(s) to finish
if (topics & TOPIC_T1)
{
FILE* writers_completed = 0;
ACE_TString t1_fn = ACE_TEXT(MY_TOPIC1) + pub_finished_filename;
do
{
ACE_Time_Value small_time(0, 250000);
ACE_OS::sleep(small_time);
writers_completed =
ACE_OS::fopen((synch_dir + t1_fn).c_str(), ACE_TEXT("r"));
} while (0 == writers_completed);
ACE_OS::fclose(writers_completed);
}
if (topics & TOPIC_T2)
{
FILE* writers_completed = 0;
ACE_TString t2_fn = ACE_TEXT(MY_TOPIC2) + pub_finished_filename;
do
{
ACE_Time_Value small_time(0,250000);
ACE_OS::sleep(small_time);
writers_completed =
ACE_OS::fopen((synch_dir + t2_fn).c_str(), ACE_TEXT("r"));
} while (0 == writers_completed);
ACE_OS::fclose(writers_completed);
}
if (topics & TOPIC_T3)
{
FILE* writers_completed = 0;
ACE_TString t3_fn = ACE_TEXT(MY_TOPIC3) + pub_finished_filename;
do
{
ACE_Time_Value small_time(0,250000);
ACE_OS::sleep(small_time);
writers_completed =
ACE_OS::fopen((synch_dir + t3_fn).c_str(), ACE_TEXT("r"));
} while (0 == writers_completed);
ACE_OS::fclose(writers_completed);
}
if (topics & TOPIC_T1)
{
ACE_OS::printf("\n*** %s received %d samples.\n", MY_TOPIC1,
drl1_num_samples);
if (drl1_num_samples != num_ops_per_thread)
{
ACE_OS::fprintf(stderr,
"%s: Expected %d samples, got %d samples.\n",
MY_TOPIC1,
num_ops_per_thread, drl1_num_samples);
return 1;
}
}
if (topics & TOPIC_T2)
{
ACE_OS::printf("\n*** %s received %d samples.\n", MY_TOPIC2,
drl2_num_samples);
if (drl2_num_samples != num_ops_per_thread)
{
ACE_OS::fprintf(stderr,
"%s: Expected %d samples, got %d samples.\n",
MY_TOPIC2,
num_ops_per_thread, drl2_num_samples);
return 1;
}
}
if (topics & TOPIC_T3)
{
ACE_OS::printf("\n*** %s received %d samples.\n", MY_TOPIC3,
drl3_num_samples);
if (drl3_num_samples != num_ops_per_thread)
{
ACE_OS::fprintf(stderr,
"%s: Expected %d samples, got %d samples.\n",
MY_TOPIC3,
num_ops_per_thread, drl3_num_samples);
return 1;
}
}
if (topics & TOPIC_T4)
{
ACE_OS::printf("\n*** %s received %d samples.\n", MY_TOPIC4,
drl4_num_samples);
if (drl4_num_samples != num_ops_per_thread)
{
ACE_OS::fprintf(stderr,
"%s: Expected %d samples, got %d samples.\n",
MY_TOPIC4,
num_ops_per_thread, drl4_num_samples);
return 1;
}
}
// clean up subscriber objects
dp->delete_contained_entities();
dpf->delete_participant(dp.in ());
TheServiceParticipant->shutdown ();
}
catch (const TestException&)
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT("(%P|%t) TestException caught in main.cpp. ")));
return 1;
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Exception caught in main.cpp:");
return 1;
}
return status;
}
void
Reader::read (const SampleInfoMap& si_map,
::DDS::SampleStateMask ss,
::DDS::ViewStateMask vs,
::DDS::InstanceStateMask is)
{
ACE_DEBUG((LM_DEBUG,
ACE_TEXT("(%P|%t) Reader::read \n")));
const int factor = 20;
const int timeout_sec = 10 ;
ACE_Time_Value small_time(0,1000000/factor);
int timeout_loops = timeout_sec * factor;
try
{
::DDS::DataReaderSeq_var readers = new ::DDS::DataReaderSeq(10);
bool found(false) ;
while (timeout_loops-- > 0) // Danger! fix later
{
sub_->get_datareaders (
readers.inout (),
ss,
vs,
is );
if (readers->length () > 0)
{
found = true ;
break ;
}
ACE_OS::sleep (small_time);
}
if (!found)
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT("(%P|%t) ERROR: timeout waiting for data.\n")));
throw TestException() ;
}
else
{
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT("(%P|%t) get_datareaders returned %d reader(s)\n"),
readers->length ()));
}
::Xyz::FooSeq foo(max_samples_per_instance_) ;
::DDS::SampleInfoSeq si(max_samples_per_instance_) ;
for (CORBA::ULong i = 0 ; i < readers->length() ; i++)
{
::Xyz::FooDataReader_var foo_dr
= ::Xyz::FooDataReader::_narrow(readers[i]);
if (CORBA::is_nil (foo_dr.in ()))
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT("(%P|%t) ::Xyz::FooDataReader::_narrow failed.\n")));
throw TestException() ;
}
::Xyz::FooDataReaderImpl* dr_servant =
dynamic_cast<Xyz::FooDataReaderImpl*> (foo_dr.in ());
DDS::ReturnCode_t status ;
status = dr_servant->read(foo, si,
max_samples_per_instance_,
ss,
vs,
is) ;
if (status == ::DDS::RETCODE_OK)
{
for (CORBA::ULong i = 0 ; i < si.length() ; i++)
{
// skip the dispose notification sample.
if (si[i].valid_data == 0)
{
ACE_OS::printf ("got SampleInfo[%d] dispose sample\n", i);
continue;
}
ACE_OS::printf ("foo[%d] - %c : x = %f y = %f, key = %d\n",
i, foo[i].c, foo[i].x, foo[i].y, foo[i].key);
PrintSampleInfo(si[i]) ;
SampleInfoMap::const_iterator it = si_map.find(foo[i].c);
if (it == si_map.end())
{
ACE_OS::printf ("read - Error: %c not returned\n", foo[i].c) ;
throw TestException() ;
}
else
{
if (si[i] != it->second)
{
ACE_OS::printf ("read - Error: %c SampleInfo != expected\n",
foo[i].c) ;
throw TestException() ;
}
}
}
}
else if (status == ::DDS::RETCODE_NO_DATA)
{
ACE_OS::printf ("read returned ::DDS::RETCODE_NO_DATA\n") ;
throw TestException() ;
}
else
{
ACE_OS::printf ("read - Error: %d\n", status) ;
throw TestException() ;
}
}
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Exception caught in read:");
throw TestException() ;
}
}
int ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
try {
// Initialize DomainParticipantFactory
DDS::DomainParticipantFactory_var dpf =
TheParticipantFactoryWithArgs(argc, argv);
if (parse_args (argc, argv) != 0) {
return 1;
}
TheServiceParticipant->monitor_factory_->initialize();
// Create DomainParticipant
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())) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l: main()")
ACE_TEXT(" ERROR: create_participant failed!\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
DDS::Topic_var topic =
participant->create_topic("Movie Discussion List",
mts->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 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);
}
// Start writing threads
Writer* writer = new Writer(dw.in());
writer->start();
while (!writer->is_finished()) {
ACE_Time_Value small_time(0, 250000);
ACE_OS::sleep(small_time);
}
writer->end();
delete writer;
// 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():");
ACE_OS::exit(-1);
}
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(111,
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);
}
// 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
DDS::Topic_var topic =
participant->create_topic("Movie Discussion List",
CORBA::String_var(mts->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);
}
::DDS::PublisherQos publisher_qos;
participant->get_default_publisher_qos (publisher_qos);
publisher_qos.presentation.access_scope = DDS::GROUP_PRESENTATION_QOS;
publisher_qos.presentation.coherent_access = true;
publisher_qos.presentation.ordered_access = true;
// Create Publisher
DDS::Publisher_var pub =
participant->create_publisher(publisher_qos,
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);
}
::DDS::DataWriterQos dw_qos;
pub->get_default_datawriter_qos (dw_qos);
dw_qos.history.kind = ::DDS::KEEP_ALL_HISTORY_QOS;
dw_qos.resource_limits.max_samples_per_instance = ::DDS::LENGTH_UNLIMITED;
// Create DataWriter
DDS::DataWriter_var dw1 =
pub->create_datawriter(topic.in(),
dw_qos,
DDS::DataWriterListener::_nil(),
OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil(dw1.in())) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l: main()")
ACE_TEXT(" ERROR: create_datawriter failed!\n")),
-1);
}
DDS::DataWriter_var dw2 =
pub->create_datawriter(topic.in(),
dw_qos,
DDS::DataWriterListener::_nil(),
OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil(dw2.in())) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l: main()")
ACE_TEXT(" ERROR: create_datawriter failed!\n")),
-1);
}
// Start writing threads
Writer* writer1 = new Writer(pub.in(), dw1.in());
writer1->start();
Writer* writer2 = new Writer(pub.in(), dw2.in());
writer2->start();
while (!writer1->is_finished() || !writer2->is_finished()) {
ACE_Time_Value small_time(0, 250000);
ACE_OS::sleep(small_time);
}
writer1->end();
writer2->end();
delete writer1;
delete writer2;
// 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():");
ACE_OS::exit(-1);
}
return 0;
}
int ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
::DDS::DomainParticipantFactory_var dpf;
::DDS::DomainParticipant_var participant;
int status = 0;
try
{
ACE_DEBUG((LM_INFO,"(%P|%t) %T publisher main\n"));
dpf = TheParticipantFactoryWithArgs(argc, argv);
// let the Service_Participant (in above line) strip out -DCPSxxx parameters
// and then get application specific parameters.
parse_args (argc, argv);
participant
= dpf->create_participant(MY_DOMAIN,
PARTICIPANT_QOS_DEFAULT,
::DDS::DomainParticipantListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (participant.in ()))
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT("(%P|%t) create_participant failed.\n")));
throw TestException ();
}
if (no_key)
{
::Xyz::FooNoKeyTypeSupportImpl* nokey_fts_servant
= new ::Xyz::FooNoKeyTypeSupportImpl();
CORBA::LocalObject_var safe_servant = nokey_fts_servant;
if (::DDS::RETCODE_OK != nokey_fts_servant->register_type(participant.in (), MY_TYPE))
{
ACE_ERROR ((LM_ERROR, ACE_TEXT("(%P|%t) register_type failed.\n")));
throw TestException ();
}
}
else
{
::Xyz::FooTypeSupportImpl* fts_servant
= new ::Xyz::FooTypeSupportImpl();
OpenDDS::DCPS::LocalObject_var safe_servant = fts_servant;
if (::DDS::RETCODE_OK != fts_servant->register_type(participant.in (), MY_TYPE))
{
ACE_ERROR ((LM_ERROR, ACE_TEXT("(%P|%t) register_type failed.\n")));
throw TestException ();
}
}
if (mixed_trans)
{
::Xyz::FooTypeSupportImpl* fts_servant
= new ::Xyz::FooTypeSupportImpl();
OpenDDS::DCPS::LocalObject_var safe_servant = fts_servant;
if (::DDS::RETCODE_OK != fts_servant->register_type(participant.in (), MY_TYPE_FOR_UDP))
{
ACE_ERROR ((LM_ERROR, ACE_TEXT("(%P|%t) register_type failed.\n")));
throw TestException ();
}
}
::DDS::TopicQos topic_qos;
participant->get_default_topic_qos(topic_qos);
::DDS::Topic_var topic
= participant->create_topic (MY_TOPIC,
MY_TYPE,
topic_qos,
::DDS::TopicListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (topic.in ()))
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT("(%P|%t) create_topic failed.\n")));
throw TestException ();
}
::DDS::Topic_var topic1;
if (mixed_trans)
{
topic1 = participant->create_topic (MY_TOPIC_FOR_UDP,
MY_TYPE_FOR_UDP,
topic_qos,
::DDS::TopicListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (topic1.in ()))
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT("(%P|%t) create_topic failed.\n")));
throw TestException ();
}
}
int attach_to_udp = using_udp;
int attach_to_multicast = using_multicast;
// Create the default publisher
::DDS::Publisher_var pub =
create_publisher(participant, attach_to_udp, attach_to_multicast,
using_rtps_transport, using_shmem);
if (CORBA::is_nil (pub.in ()))
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT("(%P|%t) create_publisher failed.\n")));
throw TestException ();
}
::DDS::Publisher_var pub1;
if (mixed_trans)
{
// Create another publisher for a difference transport.
pub1 = create_publisher(participant, !attach_to_udp,
attach_to_multicast, false /*rtps*/, false);
if (CORBA::is_nil (pub1.in ()))
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT("(%P|%t) create_publisher failed.\n")));
throw TestException ();
}
}
// Create the datawriters
::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 =
max_samples_per_instance ;
if (blocking_ms > 0) {
dw_qos.reliability.max_blocking_time.sec = blocking_ms/1000;
dw_qos.reliability.max_blocking_time.nanosec = blocking_ms%1000 * 1000000;
}
// The history depth is only used for KEEP_LAST.
//dw_qos.history.depth = history_depth ;
::DDS::DataWriter_var* dw = new ::DDS::DataWriter_var[num_datawriters];
Writer** writers = new Writer*[num_datawriters];
for (int i = 0; i < num_datawriters; i ++)
{
int attach_to_udp = using_udp;
::DDS::Publisher_var the_pub = pub;
::DDS::Topic_var the_topic = topic;
// The first datawriter would be using a different transport
// from others for the diff trans test case.
if (mixed_trans && i == 0)
{
attach_to_udp = ! attach_to_udp;
the_pub = pub1;
the_topic = topic1;
}
dw[i] = the_pub->create_datawriter(the_topic.in (),
dw_qos,
::DDS::DataWriterListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (dw[i].in ()))
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT("(%P|%t) create_datawriter failed.\n")));
throw TestException ();
}
writers[i] = new Writer (dw[i].in (), i);
}
// Indicate that the publisher is ready
ACE_DEBUG((LM_INFO, "(%P|%t) publisher signaling ready\n"));
FILE* writers_ready = ACE_OS::fopen (pub_ready_filename.c_str (), ACE_TEXT("w"));
if (writers_ready == 0)
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT("(%P|%t) ERROR: Unable to create publisher ready file\n")));
}
// Wait for the subscriber to be ready.
FILE* readers_ready = 0;
do
{
ACE_Time_Value small_time(0,250000);
ACE_OS::sleep (small_time);
ACE_DEBUG((LM_INFO, "(%P|%t) publisher checking for sub ready\n"));
readers_ready = ACE_OS::fopen (sub_ready_filename.c_str (), ACE_TEXT("r"));
} while (0 == readers_ready);
if (writers_ready) ACE_OS::fclose(writers_ready);
if (readers_ready) ACE_OS::fclose(readers_ready);
// If mixed transports, each writer will associate with only one reader
int associations_per_writer = mixed_trans ? 1 : num_datareaders;
for (int i = 0; i < num_datawriters; i ++)
{
OpenDDS::Model::WriterSync::wait_match(dw[i], associations_per_writer);
writers[i]->start ();
}
int timeout_writes = 0;
bool writers_finished = false;
while ( !writers_finished )
{
const ACE_Time_Value small_time(0,250000);
ACE_OS::sleep(small_time);
writers_finished = true;
for (int i = 0; i < num_datawriters; i ++)
{
writers_finished = writers_finished && writers[i]->is_finished();
}
}
for (int i = 0; i < num_datawriters; i ++)
{
timeout_writes += writers[i]->get_timeout_writes();
}
// Indicate that the publisher is done
ACE_DEBUG((LM_INFO, "(%P|%t) publisher signaling finished\n"));
FILE* writers_completed = ACE_OS::fopen (pub_finished_filename.c_str (), ACE_TEXT("w"));
if (writers_completed == 0)
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT("(%P|%t) ERROR: Unable to i publisher completed file\n")));
}
else
{
ACE_DEBUG((LM_DEBUG,
ACE_TEXT("(%P|%t) notifying subscriber of %d timeout writes\n"),
timeout_writes));
ACE_OS::fprintf (writers_completed, "%d\n", timeout_writes);
ACE_OS::fclose(writers_completed);
}
// Wait for the subscriber to finish.
FILE* readers_completed = 0;
do
{
ACE_Time_Value small_time(0,250000);
ACE_OS::sleep (small_time);
ACE_DEBUG((LM_INFO, "(%P|%t) publisher checking for sub finished\n"));
readers_completed = ACE_OS::fopen (sub_finished_filename.c_str (), ACE_TEXT("r"));
} while (0 == readers_completed);
ACE_OS::fclose(readers_completed);
for (int i = 0; i < num_datawriters; i ++)
{
writers[i]->end ();
delete writers[i];
}
delete [] dw;
delete [] writers;
}
catch (const TestException&)
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT("(%P|%t) TestException caught in main (). ")));
status = 1;
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Exception caught in main ():");
status = 1;
}
try
{
if (! CORBA::is_nil (participant.in ()))
{
participant->delete_contained_entities();
}
if (! CORBA::is_nil (dpf.in ()))
{
dpf->delete_participant(participant.in ());
}
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Exception caught in cleanup.");
status = 1;
}
TheServiceParticipant->shutdown ();
return status;
}
int ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
try {
DDS::DomainParticipantFactory_var dpf;
DDS::DomainParticipant_var participant;
dpf = TheParticipantFactoryWithArgs(argc, argv);
if( parse_args(argc, argv) != 0)
return 1;
ACE_DEBUG((LM_DEBUG, "(%P|%t) subscriber.cpp main()\n"));
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 ;
}
Messenger::MessageTypeSupportImpl* mts_servant = new Messenger::MessageTypeSupportImpl();
OpenDDS::DCPS::LocalObject_var safe_servant = mts_servant;
if (DDS::RETCODE_OK != mts_servant->register_type(participant.in (),
"")) {
cerr << "Failed to register the MessageTypeTypeSupport." << endl;
exit(1);
}
CORBA::String_var type_name = mts_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 << "Failed to create_topic." << endl;
exit(1);
}
// Create the subscriber and attach to the corresponding
// transport.
DDS::Subscriber_var sub =
participant->create_subscriber(SUBSCRIBER_QOS_DEFAULT,
DDS::SubscriberListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (sub.in ())) {
cerr << "Failed to create_subscriber." << endl;
exit(1);
}
// activate the listener
DDS::DataReaderListener_var listener (new DataReaderListenerImpl);
if (CORBA::is_nil (listener.in ())) {
cerr << "listener is nil." << endl;
exit(1);
}
DataReaderListenerImpl* listener_servant =
dynamic_cast<DataReaderListenerImpl*>(listener.in());
// Create the Datareaders
DDS::DataReaderQos dr_qos;
sub->get_default_datareader_qos (dr_qos);
DDS::DataReader_var dr = sub->create_datareader(topic.in (),
dr_qos,
listener.in (),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (dr.in ())) {
cerr << "create_datareader failed." << endl;
exit(1);
}
// Indicate that the subscriber is ready
FILE* readers_ready = ACE_OS::fopen (sub_ready_filename, ACE_TEXT ("w"));
if (readers_ready == 0) {
cerr << "ERROR Unable to create subscriber ready file." << endl;
exit(1);
}
ACE_OS::fclose(readers_ready);
// Wait for the publisher to be ready
FILE* writers_ready = 0;
do {
ACE_Time_Value small_time(0,250000);
ACE_OS::sleep (small_time);
writers_ready = ACE_OS::fopen (pub_ready_filename, ACE_TEXT ("r"));
} while (0 == writers_ready);
ACE_OS::fclose(writers_ready);
// Since the publisher continue sending while the subscriber crashes,
// some messages may be lost, we lower the num_expected_reads by 2.
num_expected_reads -= num_reads_deviation;
FILE* writers_completed = 0;
int timeout_writes = 0;
while ( listener_servant->num_reads() < num_expected_reads) {
// Get the number of the timed out writes from publisher so we
// can re-calculate the number of expected messages. Otherwise,
// the blocking timeout test will never exit from this loop.
if (writers_completed == 0) {
writers_completed = ACE_OS::fopen (pub_finished_filename, ACE_TEXT ("r"));
if (writers_completed != 0) {
if (end_with_publisher)
{
// Since we are in the "bp_timeout" test case that publisher
// close connection when backpressure last longer than
// max_output_pause_period, the publisher ends as it finishes
// sending. As the subscriber sees the publisher is done, it
// changes the read_delay_ms to 0 so it can read all received
// messages and them announce it completed.
int old_read_delay_ms = read_delay_ms;
read_delay_ms = 0;
// Give time to finish reading.
ACE_OS::sleep (old_read_delay_ms/1000 * 2);
break;
}
//writers_completed = ACE_OS::fopen (pub_finished_filename, "r");
fscanf (writers_completed, "%d\n", &timeout_writes);
num_expected_reads -= timeout_writes;
cout << "timed out writes " << timeout_writes << ", we expect "
<< num_expected_reads << endl;
}
}
ACE_OS::sleep (1);
}
// Indicate that the subscriber is done
FILE* readers_completed = ACE_OS::fopen (sub_finished_filename, ACE_TEXT ("w"));
if (readers_completed == 0) {
cerr << "ERROR Unable to create subscriber completed file." << endl;
exit(1);
}
ACE_OS::fclose(readers_completed);
// Wait for 5 seconds to (>passive_reconnect_duration)
// to give transport time to detect the connection lost due to
// backpressure timeout before shutdown the datareader.
if (end_with_publisher)
ACE_OS::sleep (5);
if (!CORBA::is_nil (participant.in ())) {
participant->delete_contained_entities();
}
if (!CORBA::is_nil (dpf.in ())) {
dpf->delete_participant(participant.in ());
}
TheServiceParticipant->shutdown ();
} catch (CORBA::Exception& e) {
cerr << "Exception caught in main ():" << endl << e << endl;
return 1;
}
if (verify_lost_sub_notification
&& actual_lost_sub_notification != expected_lost_sub_notification)
{
ACE_ERROR ((LM_ERROR, "(%P|%t) ERROR: on_subscription_lost called %d times "
"and expected %d times\n", actual_lost_sub_notification,
expected_lost_sub_notification));
return 1;
}
return 0;
}
int ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
::DDS::DomainParticipantFactory_var dpf;
::DDS::DomainParticipant_var participant;
int status = 0;
try
{
ACE_DEBUG((LM_INFO,"(%P|%t) %T subscriber main\n"));
dpf = TheParticipantFactoryWithArgs(argc, argv);
// let the Service_Participant (in above line) strip out -DCPSxxx parameters
// and then get application specific parameters.
parse_args (argc, argv);
results.init ();
participant =
dpf->create_participant(MY_DOMAIN,
PARTICIPANT_QOS_DEFAULT,
::DDS::DomainParticipantListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (participant.in ()))
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT("(%P|%t) create_participant failed.\n")));
return 1 ;
}
if (no_key)
{
::Xyz::FooNoKeyTypeSupportImpl* nokey_fts_servant
= new ::Xyz::FooNoKeyTypeSupportImpl();
OpenDDS::DCPS::LocalObject_var safe_servant = nokey_fts_servant;
if (::DDS::RETCODE_OK != nokey_fts_servant->register_type(participant.in (), MY_TYPE))
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("Failed to register the FooTypeSupport.")));
throw TestException ();
}
}
else
{
::Xyz::FooTypeSupportImpl* fts_servant
= new ::Xyz::FooTypeSupportImpl();
OpenDDS::DCPS::LocalObject_var safe_servant = fts_servant;
if (::DDS::RETCODE_OK != fts_servant->register_type(participant.in (), MY_TYPE))
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("Failed to register the FooNoTypeTypeSupport.")));
throw TestException ();
}
}
if (mixed_trans)
{
::Xyz::FooTypeSupportImpl* fts_servant
= new ::Xyz::FooTypeSupportImpl();
OpenDDS::DCPS::LocalObject_var safe_servant = fts_servant;
if (::DDS::RETCODE_OK != fts_servant->register_type(participant.in (), MY_TYPE_FOR_UDP))
{
ACE_ERROR ((LM_ERROR, ACE_TEXT("(%P|%t) register_type failed.\n")));
throw TestException ();
}
}
::DDS::TopicQos topic_qos;
participant->get_default_topic_qos(topic_qos);
::DDS::Topic_var topic
= participant->create_topic(MY_TOPIC,
MY_TYPE,
topic_qos,
::DDS::TopicListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (topic.in ()))
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("Failed to create_topic.")));
throw TestException ();
}
::DDS::TopicDescription_var description
= participant->lookup_topicdescription(MY_TOPIC);
if (CORBA::is_nil (description.in ()))
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("Failed to lookup_topicdescription.")));
throw TestException ();
}
::DDS::Topic_var topic1;
::DDS::TopicDescription_var description1;
if (mixed_trans)
{
topic1 = participant->create_topic (MY_TOPIC_FOR_UDP,
MY_TYPE_FOR_UDP,
topic_qos,
::DDS::TopicListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (topic1.in ()))
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT("(%P|%t) create_topic failed.\n")));
throw TestException ();
}
description1
= participant->lookup_topicdescription(MY_TOPIC_FOR_UDP);
if (CORBA::is_nil (description1.in ()))
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("Failed to lookup_topicdescription.")));
throw TestException ();
}
}
int attach_to_udp = using_udp;
int attach_to_multicast = using_multicast;
// Create the subscriber and attach to the corresponding
// transport.
DDS::Subscriber_var sub =
create_subscriber(participant, attach_to_udp, attach_to_multicast,
using_rtps_transport, using_shmem);
if (CORBA::is_nil (sub.in ()))
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("Failed to create_subscriber.")));
throw TestException ();
}
::DDS::Subscriber_var sub1;
if (mixed_trans)
{
// Create the subscriber with a different transport from previous
// subscriber.
sub1 = create_subscriber(participant, !attach_to_udp,
attach_to_multicast, false /*rtps*/, false);
if (CORBA::is_nil (sub1.in ()))
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("Failed to create_subscriber.")));
throw TestException ();
}
}
// Create the Datareaders
::DDS::DataReaderQos dr_qos;
sub->get_default_datareader_qos (dr_qos);
// Make it KEEP_ALL history so we can verify the received
// data without dropping.
dr_qos.history.kind = ::DDS::KEEP_ALL_HISTORY_QOS;
dr_qos.reliability.kind =
(using_udp || mixed_trans)
? ::DDS::BEST_EFFORT_RELIABILITY_QOS
: ::DDS::RELIABLE_RELIABILITY_QOS;
dr_qos.resource_limits.max_samples_per_instance =
max_samples_per_instance ;
// The history depth is only used for KEEP_LAST.
//dr_qos.history.depth = history_depth ;
// activate the listener
::DDS::DataReaderListener_var listener (new DataReaderListenerImpl);
if (CORBA::is_nil (listener.in ()))
{
ACE_ERROR ((LM_ERROR, ACE_TEXT ("(%P|%t) listener is nil.")));
throw TestException ();
}
::DDS::DataReader_var * drs = new ::DDS::DataReader_var[num_datareaders];
// Create one datareader or multiple datareaders belonging to the same
// subscriber.
for (int i = 0; i < num_datareaders; i ++)
{
int attach_to_udp = using_udp;
::DDS::Subscriber_var the_sub = sub;
::DDS::TopicDescription_var the_description = description;
// The first datawriter would be using a different transport
// from others for the diff trans test case.
if (mixed_trans && i == 0)
{
attach_to_udp = ! attach_to_udp;
the_sub = sub1;
the_description = description1;
}
// create the datareader.
drs[i] = the_sub->create_datareader(the_description.in (),
dr_qos,
listener.in (),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (drs[i].in ()))
{
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT("(%P|%t) create_datareader failed.\n")),
1);
}
}
// Indicate that the subscriber is ready
ACE_DEBUG((LM_INFO, "(%P|%t) subscriber signaling ready\n"));
FILE* readers_ready = ACE_OS::fopen (sub_ready_filename.c_str (), ACE_TEXT("w"));
if (readers_ready == 0)
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT("(%P|%t) ERROR: Unable to create subscriber completed file\n")));
}
// Wait for the publisher to be ready
FILE* writers_ready = 0;
do
{
ACE_Time_Value small_time(0,250000);
ACE_OS::sleep (small_time);
ACE_DEBUG((LM_INFO, "(%P|%t) subscriber checking for pub ready\n"));
writers_ready = ACE_OS::fopen (pub_ready_filename.c_str (), ACE_TEXT("r"));
} while (0 == writers_ready);
ACE_OS::fclose(readers_ready);
ACE_OS::fclose(writers_ready);
int num_associations = mixed_trans ? num_datawriters :
num_datareaders * num_datawriters;
int expected = num_associations *
num_instances_per_writer * num_samples_per_instance;
FILE* writers_completed = 0;
int timeout_writes = 0;
while ( num_reads < expected)
{
// Get the number of the timed out writes from publisher so we
// can re-calculate the number of expected messages. Otherwise,
// the blocking timeout test will never exit from this loop.
if (writers_completed == 0)
{
ACE_DEBUG((LM_INFO, "(%P|%t) subscriber checking for pub finished\n"));
writers_completed = ACE_OS::fopen (pub_finished_filename.c_str (), ACE_TEXT("r"));
if (writers_completed != 0)
{
//writers_completed = ACE_OS::fopen (pub_finished_filename.c_str (), ACE_TEXT("r"));
if (std::fscanf (writers_completed, "%d\n", &timeout_writes) != 1) {
//if fscanf return 0 or EOF(-1), failed to read a matching line format to populate in timeout_writes
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT("(%P|%t) Warning: subscriber could not read timeout_writes\n")));
} else if (timeout_writes) {
expected -= timeout_writes;
ACE_DEBUG((LM_DEBUG,
ACE_TEXT ("(%P|%t) %d timed out writes, adjusted we expected to %d\n"),
timeout_writes, expected));
}
// After we got the number of timed out writes, we should speed the
// receiving.
op_interval_ms = 0;
}
ACE_DEBUG((LM_DEBUG,
ACE_TEXT ("(%P|%t) received %d of expected %d\n"),
num_reads.value(), expected));
}
ACE_OS::sleep (1);
}
// Indicate that the subscriber is done
ACE_DEBUG((LM_INFO, "(%P|%t) subscriber signaling finished\n"));
FILE* readers_completed = ACE_OS::fopen (sub_finished_filename.c_str (), ACE_TEXT("w"));
if (readers_completed == 0)
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT("(%P|%t) ERROR: Unable to create subscriber completed file\n")));
}
// Wait for the publisher to finish
while (writers_completed == 0)
{
ACE_Time_Value small_time(0,250000);
ACE_OS::sleep (small_time);
ACE_DEBUG((LM_INFO, "(%P|%t) subscriber checking for pub finished\n"));
writers_completed = ACE_OS::fopen (pub_finished_filename.c_str (), ACE_TEXT("r"));
}
ACE_OS::fclose(readers_completed);
ACE_OS::fclose(writers_completed);
if (results.test_passed (expected) == false)
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT("(%P|%t) Verify received samples - not passed \n")));
status = 1;
}
delete [] drs;
}
catch (const TestException&)
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT("(%P|%t) TestException caught in main (). ")));
status = 1;
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Exception caught in main ():");
status = 1;
}
catch (const OpenDDS::DCPS::Transport::MiscProblem &)
{
ACE_ERROR((LM_ERROR,
ACE_TEXT("(%P|%t) Transport::MiscProblem exception caught during processing.\n")
));
status = 1;
}
ACE_DEBUG((LM_INFO, "(%P|%t) subscriber starting shutdown\n"));
try
{
if (! CORBA::is_nil (participant.in ()))
{
participant->delete_contained_entities();
}
if (! CORBA::is_nil (dpf.in ()))
{
dpf->delete_participant(participant.in ());
participant = 0;
dpf = 0;
}
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Exception caught in cleanup.");
status = 1;
}
ACE_DEBUG((LM_INFO, "(%P|%t) subscriber shutdown of ServiceParticipant\n"));
TheServiceParticipant->shutdown ();
ACE_DEBUG((LM_INFO, "(%P|%t) subscriber exiting with status %d\n", status));
return status;
}
int ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
int status = 0;
try
{
ACE_DEBUG((LM_INFO,"(%P|%t) %T subscriber main\n"));
::DDS::DomainParticipantFactory_var dpf = TheParticipantFactoryWithArgs(argc, argv);
// TheServiceParticipant->liveliness_factor(100) ;
// let the Service_Participant (in above line) strip out -DCPSxxx parameters
// and then get application specific parameters.
parse_args (argc, argv);
::Xyz::FooTypeSupport_var fts (new ::Xyz::FooTypeSupportImpl);
::DDS::DomainParticipant_var dp =
dpf->create_participant(MY_DOMAIN,
PARTICIPANT_QOS_DEFAULT,
::DDS::DomainParticipantListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (dp.in ()))
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT("(%P|%t) create_participant failed.\n")));
return 1 ;
}
if (::DDS::RETCODE_OK != fts->register_type(dp.in (), MY_TYPE))
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("Failed to register the FooTypeSupport.")));
return 1;
}
::DDS::TopicQos topic_qos;
dp->get_default_topic_qos(topic_qos);
topic_qos.resource_limits.max_samples_per_instance =
max_samples_per_instance ;
topic_qos.history.depth = history_depth;
::DDS::Topic_var topic =
dp->create_topic (MY_TOPIC,
MY_TYPE,
topic_qos,
::DDS::TopicListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (topic.in ()))
{
return 1 ;
}
::DDS::TopicDescription_var description =
dp->lookup_topicdescription(MY_TOPIC);
if (CORBA::is_nil (description.in ()))
{
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT("(%P|%t) lookup_topicdescription failed.\n")),
1);
}
// Create the subscriber
::DDS::Subscriber_var sub =
dp->create_subscriber(SUBSCRIBER_QOS_DEFAULT,
::DDS::SubscriberListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (sub.in ()))
{
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT("(%P|%t) create_subscriber failed.\n")),
1);
}
// Create the Datareaders
::DDS::DataReaderQos dr_qos;
sub->get_default_datareader_qos (dr_qos);
dr_qos.history.depth = history_depth ;
dr_qos.resource_limits.max_samples_per_instance =
max_samples_per_instance ;
dr_qos.liveliness.lease_duration.sec = LEASE_DURATION_SEC ;
dr_qos.liveliness.lease_duration.nanosec = 0 ;
::DDS::DataReaderListener_var drl (new DataReaderListenerImpl);
DataReaderListenerImpl* drl_servant =
dynamic_cast<DataReaderListenerImpl*>(drl.in());
::DDS::DataReader_var dr ;
dr = sub->create_datareader(description.in (),
dr_qos,
drl.in (),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
// Indicate that the subscriber is ready
FILE* readers_ready = ACE_OS::fopen (sub_ready_filename.c_str (), ACE_TEXT("w"));
if (readers_ready == 0)
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT("(%P|%t) ERROR: Unable to create subscriber completed file\n")));
}
ACE_DEBUG((LM_DEBUG,ACE_TEXT("(%P|%t) %T waiting for publisher to be ready\n") ));
// Wait for the publisher to be ready
FILE* writers_ready = 0;
do
{
ACE_Time_Value small_time(0,250000);
ACE_OS::sleep (small_time);
writers_ready = ACE_OS::fopen (pub_ready_filename.c_str (), ACE_TEXT("r"));
} while (0 == writers_ready);
ACE_OS::fclose(readers_ready);
ACE_OS::fclose(writers_ready);
ACE_DEBUG((LM_DEBUG,ACE_TEXT("(%P|%t) %T Publisher is ready\n") ));
// Indicate that the subscriber is done
// (((it is done when ever the publisher is done)))
FILE* readers_completed = ACE_OS::fopen (sub_finished_filename.c_str (), ACE_TEXT("w"));
if (readers_completed == 0)
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT("(%P|%t) ERROR: Unable to create subscriber completed file\n")));
}
ACE_DEBUG((LM_DEBUG,ACE_TEXT("(%P|%t) %T waiting for publisher to finish\n") ));
// Wait for the publisher to finish
FILE* writers_completed = 0;
do
{
ACE_Time_Value small_time(0,250000);
ACE_OS::sleep (small_time);
writers_completed = ACE_OS::fopen (pub_finished_filename.c_str (), ACE_TEXT("r"));
} while (0 == writers_completed);
ACE_OS::fclose(readers_completed);
ACE_OS::fclose(writers_completed);
//
// We need to wait for liveliness to go away here.
//
ACE_OS::sleep( 5);
//
// Determine the test status at this point.
//
ACE_OS::fprintf (stderr, "**********\n") ;
ACE_OS::fprintf (stderr, "drl_servant->liveliness_changed_count() = %d\n",
drl_servant->liveliness_changed_count()) ;
ACE_OS::fprintf (stderr, "drl_servant->no_writers_generation_count() = %d\n",
drl_servant->no_writers_generation_count()) ;
ACE_OS::fprintf (stderr, "********** use_take=%d\n", use_take) ;
if( drl_servant->liveliness_changed_count() < 2 + 2 * num_unlively_periods) {
status = 1;
// Some error condition.
ACE_ERROR((LM_ERROR,
ACE_TEXT("(%P|%t) ERROR: subscriber - ")
ACE_TEXT("test failed first condition.\n")
));
} else if( drl_servant->verify_last_liveliness_status () == false) {
status = 1;
// Some other error condition.
ACE_ERROR((LM_ERROR,
ACE_TEXT("(%P|%t) ERROR: subscriber - ")
ACE_TEXT("test failed second condition.\n")
));
} else if( drl_servant->no_writers_generation_count() != num_unlively_periods) {
status = 1;
// Yet another error condition.
// Using take will remove the instance and instance state will be
// reset for any subsequent samples sent. Since there are no
// more samples sent, the information available from the listener
// retains that from the last read sample rather than the reset
// value for an (as yet unreceived) next sample.
ACE_ERROR((LM_ERROR,
ACE_TEXT("(%P|%t) ERROR: subscriber - ")
ACE_TEXT("test failed third condition.\n")
));
}
ACE_DEBUG((LM_DEBUG,ACE_TEXT("(%P|%t) %T publisher is finish - cleanup subscriber\n") ));
// clean up subscriber objects
sub->delete_contained_entities() ;
dp->delete_subscriber(sub.in ());
dp->delete_topic(topic.in ());
dpf->delete_participant(dp.in ());
TheServiceParticipant->shutdown ();
}
catch (const TestException&)
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT("(%P|%t) TestException caught in main.cpp. ")));
return 1;
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Exception caught in main.cpp:");
return 1;
}
return status;
}
int ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
DDS::DomainParticipantFactory_var dpf;
DDS::DomainParticipant_var participant;
try {
std::cout << "Starting publisher" << std::endl;
{
// Initialize DomainParticipantFactory
dpf = TheParticipantFactoryWithArgs(argc, argv);
std::cout << "Starting publisher with " << argc << " args" << std::endl;
int error;
if ((error = parse_args(argc, argv)) != 0) {
return error;
}
// Create DomainParticipant
participant = dpf->create_participant(4,
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);
}
// 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);
}
DDS::DataWriterQos qos;
pub->get_default_datawriter_qos(qos);
if (dw_reliable()) {
std::cout << "Reliable DataWriter" << std::endl;
qos.history.kind = DDS::KEEP_ALL_HISTORY_QOS;
qos.reliability.kind = DDS::RELIABLE_RELIABILITY_QOS;
}
// Create DataWriter
DDS::DataWriter_var dw =
pub->create_datawriter(topic.in(),
qos,
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);
}
// Start writing threads
std::cout << "Creating Writer" << std::endl;
Writer* writer = new Writer(dw.in());
std::cout << "Starting Writer" << std::endl;
writer->start();
while (!writer->is_finished()) {
ACE_Time_Value small_time(0, 250000);
ACE_OS::sleep(small_time);
}
std::cout << "Writer finished " << std::endl;
writer->end();
if (wait_for_acks) {
std::cout << "Writer wait for ACKS" << std::endl;
DDS::Duration_t timeout =
{ DDS::DURATION_INFINITE_SEC, DDS::DURATION_INFINITE_NSEC };
dw->wait_for_acknowledgments(timeout);
} else {
// let any missed multicast/rtps messages get re-delivered
ACE_Time_Value small_time(0, 250000);
ACE_OS::sleep(small_time);
}
std::cout << "deleting DW" << std::endl;
delete writer;
}
// 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():");
ACE_OS::exit(-1);
}
return 0;
}
int ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
int status = 0;
try
{
ACE_DEBUG((LM_INFO,"(%P|%t) %T publisher main\n"));
::DDS::DomainParticipantFactory_var dpf = TheParticipantFactoryWithArgs(argc, argv);
// let the Service_Participant (in above line) strip out -DCPSxxx parameters
// and then get application specific parameters.
parse_args(argc, argv);
if (!topics)
{
ACE_ERROR((LM_ERROR,
ACE_TEXT("(%P|%t) Must run with one or more of the following: -t1 -t2 -t3\n")));
return 1;
}
::DDS::DomainParticipant_var dp =
dpf->create_participant(MY_DOMAIN,
PARTICIPANT_QOS_DEFAULT,
::DDS::DomainParticipantListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil(dp.in()))
{
ACE_ERROR((LM_ERROR,
ACE_TEXT("(%P|%t) create_participant failed.\n")));
return 1;
}
// Create the publisher
::DDS::Publisher_var pub =
dp->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("(%P|%t) create_publisher failed.\n")),
1);
}
// Create the datawriters
::DDS::DataWriterQos dw_qos;
pub->get_default_datawriter_qos(dw_qos);
#ifndef OPENDDS_NO_OWNERSHIP_PROFILE
dw_qos.history.depth = history_depth;
#endif
dw_qos.resource_limits.max_samples_per_instance =
max_samples_per_instance;
dw_qos.liveliness.lease_duration.sec = LEASE_DURATION_SEC;
dw_qos.liveliness.lease_duration.nanosec = 0;
T1::Foo1DataWriter_var dw1;
T2::Foo2DataWriter_var dw2;
T3::Foo3DataWriter_var dw3;
T3::Foo3DataWriter_var dw4;
if (topics & TOPIC_T1)
{
dw1 = create_writer<T1::Foo1>(pub, MY_TOPIC1, dw_qos);
if (CORBA::is_nil(dw1.in()))
{
ACE_ERROR((LM_ERROR,
ACE_TEXT("(%P|%t) create_datawriter failed.\n")));
return 1;
}
}
if (topics & TOPIC_T2)
{
dw2 = create_writer<T2::Foo2>(pub, MY_TOPIC2, dw_qos);
if (CORBA::is_nil(dw2.in()))
{
ACE_ERROR((LM_ERROR,
ACE_TEXT("(%P|%t) create_datawriter failed.\n")));
return 1;
}
}
if (topics & TOPIC_T3)
{
dw3 = create_writer<T3::Foo3>(pub, MY_TOPIC3, dw_qos);
if (CORBA::is_nil(dw3.in()))
{
ACE_ERROR((LM_ERROR,
ACE_TEXT("(%P|%t) create_datawriter failed.\n")));
return 1;
}
}
if (topics & TOPIC_T4)
{
dw4 = create_writer<T3::Foo3>(pub, MY_TOPIC4, dw_qos);
if (CORBA::is_nil(dw4.in()))
{
ACE_ERROR((LM_ERROR,
ACE_TEXT("(%P|%t) create_datawriter failed.\n")));
return 1;
}
}
/*
// Indicate that the publisher is ready
FILE* writers_ready = ACE_OS::fopen(pub_ready_filename.c_str(), ACE_TEXT("w"));
if (writers_ready == 0)
{
ACE_ERROR((LM_ERROR,
ACE_TEXT("(%P|%t) ERROR: Unable to create publisher ready file\n")));
}
// Wait for the subscriber to be ready.
FILE* readers_ready = 0;
do
{
ACE_Time_Value small_time(0,250000);
ACE_OS::sleep(small_time);
readers_ready = ACE_OS::fopen(sub_ready_filename.c_str(), ACE_TEXT("r"));
} while (0 == readers_ready);
ACE_OS::fclose(writers_ready);
ACE_OS::fclose(readers_ready);
*/
int num_writers(0);
if (topics & TOPIC_T1)
{
num_writers++;
}
if (topics & TOPIC_T2)
{
num_writers++;
}
if (topics & TOPIC_T3)
{
num_writers++;
}
if (topics & TOPIC_T4)
{
num_writers++;
}
Writer **writers = new Writer* [num_writers];
int idx(0);
if (topics & TOPIC_T1)
{
TypedWriter<T1::Foo1>* tw =
new TypedWriter<T1::Foo1>(dw1, 1, num_ops_per_thread);
tw->init_instance_handler(t1_init);
tw->next_sample_handler(t1_next);
writers[idx++] = tw;
}
if (topics & TOPIC_T2)
{
TypedWriter<T2::Foo2>* tw =
new TypedWriter<T2::Foo2>(dw2, 1, num_ops_per_thread);
tw->init_instance_handler(t2_init);
tw->next_sample_handler(t2_next);
writers[idx++] = tw;
}
if (topics & TOPIC_T3)
{
TypedWriter<T3::Foo3>* tw =
new TypedWriter<T3::Foo3>(dw3, 1, num_ops_per_thread);
tw->init_instance_handler(t3_init);
tw->next_sample_handler(t3_next);
writers[idx++] = tw;
}
if (topics & TOPIC_T4)
{
TypedWriter<T3::Foo3>* tw =
new TypedWriter<T3::Foo3>(dw4, 1, num_ops_per_thread);
tw->init_instance_handler(t3_init);
tw->next_sample_handler(t3_next);
writers[idx++] = tw;
}
ACE_OS::srand((unsigned) ACE_OS::time(NULL));
for (int i = 0; i < num_writers; i++)
{
writers[i]->start();
}
bool writers_finished = false;
while ( !writers_finished )
{
writers_finished = true;
for (int m = 0; m < num_writers; m++)
{
writers_finished =
writers_finished && writers[m]->is_finished();
}
}
if (topics & TOPIC_T1)
{
// Indicate that the publisher is done
ACE_TString t1_filename = ACE_TEXT(MY_TOPIC1) +
pub_finished_filename;
FILE* writers_completed =
ACE_OS::fopen(t1_filename.c_str(), ACE_TEXT("w"));
if (writers_completed == 0)
{
ACE_ERROR((LM_ERROR,
ACE_TEXT("(%P|%t) ERROR: Unable to create publisher completed file\n")));
}
ACE_OS::fclose(writers_completed);
}
if (topics & TOPIC_T2)
{
// Indicate that the publisher is done
ACE_TString t2_filename = ACE_TEXT(MY_TOPIC2) +
pub_finished_filename;
FILE* writers_completed =
ACE_OS::fopen(t2_filename.c_str(), ACE_TEXT("w"));
if (writers_completed == 0)
{
ACE_ERROR((LM_ERROR,
ACE_TEXT("(%P|%t) ERROR: Unable to create publisher completed file\n")));
}
ACE_OS::fclose(writers_completed);
}
if (topics & TOPIC_T3)
{
// Indicate that the publisher is done
ACE_TString t3_filename = ACE_TEXT(MY_TOPIC3) +
pub_finished_filename;
FILE* writers_completed =
ACE_OS::fopen(t3_filename.c_str(), ACE_TEXT("w"));
if (writers_completed == 0)
{
ACE_ERROR((LM_ERROR,
ACE_TEXT("(%P|%t) ERROR: Unable to create publisher completed file\n")));
}
ACE_OS::fclose(writers_completed);
}
// Wait for the subscriber to finish.
if (topics & TOPIC_T1)
{
FILE* readers_completed = 0;
ACE_TString t1_filename = ACE_TEXT(MY_TOPIC1) +
sub_finished_filename;
do
{
ACE_Time_Value small_time(0,250000);
ACE_OS::sleep(small_time);
readers_completed =
ACE_OS::fopen(t1_filename.c_str(), ACE_TEXT("r"));
} while (0 == readers_completed);
ACE_OS::fclose(readers_completed);
}
if (topics & TOPIC_T2)
{
FILE* readers_completed = 0;
ACE_TString t2_filename = ACE_TEXT(MY_TOPIC2) +
sub_finished_filename;
do
{
ACE_Time_Value small_time(0,250000);
ACE_OS::sleep(small_time);
readers_completed =
ACE_OS::fopen(t2_filename.c_str(), ACE_TEXT("r"));
} while (0 == readers_completed);
ACE_OS::fclose(readers_completed);
}
if (topics & TOPIC_T3)
{
FILE* readers_completed = 0;
ACE_TString t3_filename = ACE_TEXT(MY_TOPIC3) +
sub_finished_filename;
do
{
ACE_Time_Value small_time(0,250000);
ACE_OS::sleep(small_time);
readers_completed =
ACE_OS::fopen(t3_filename.c_str(), ACE_TEXT("r"));
} while (0 == readers_completed);
ACE_OS::fclose(readers_completed);
}
// Clean up publisher objects
pub->delete_contained_entities();
for (int n = 0; n < num_writers; n++)
{
delete writers[n];
}
delete [] writers;
dp->delete_contained_entities();
dpf->delete_participant(dp.in());
TheServiceParticipant->shutdown();
}
catch (const TestException&)
{
ACE_ERROR((LM_ERROR,
ACE_TEXT("(%P|%t) TestException caught in main.cpp. ")));
return 1;
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception("Exception caught in main.cpp:");
return 1;
}
return status;
}
int ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
int status = 0;
try
{
ACE_DEBUG((LM_INFO,"(%P|%t) %T publisher main\n"));
::DDS::DomainParticipantFactory_var dpf = TheParticipantFactoryWithArgs(argc, argv);
// let the Service_Participant (in above line) strip out -DCPSxxx parameters
// and then get application specific parameters.
parse_args (argc, argv);
::Xyz::FooTypeSupport_var fts(new ::Xyz::FooTypeSupportImpl);
::DDS::DomainParticipant_var dp =
dpf->create_participant(MY_DOMAIN,
PARTICIPANT_QOS_DEFAULT,
::DDS::DomainParticipantListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (dp.in ()))
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT("(%P|%t) create_participant failed.\n")));
return 1 ;
}
if (::DDS::RETCODE_OK != fts->register_type(dp.in (), MY_TYPE))
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("Failed to register the FooTypeSupport.")));
return 1;
}
::DDS::TopicQos topic_qos;
dp->get_default_topic_qos(topic_qos);
topic_qos.resource_limits.max_samples_per_instance =
max_samples_per_instance ;
topic_qos.history.depth = history_depth;
::DDS::Topic_var topic =
dp->create_topic (MY_TOPIC,
MY_TYPE,
topic_qos,
::DDS::TopicListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (topic.in ()))
{
return 1 ;
}
// Create the publisher
::DDS::Publisher_var pub =
dp->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("(%P|%t) create_publisher failed.\n")),
1);
}
// Create the datawriters
::DDS::DataWriterQos dw_qos;
pub->get_default_datawriter_qos (dw_qos);
dw_qos.history.depth = history_depth ;
dw_qos.resource_limits.max_samples_per_instance =
max_samples_per_instance ;
dw_qos.liveliness.lease_duration.sec = LEASE_DURATION_SEC ;
dw_qos.liveliness.lease_duration.nanosec = 0 ;
::DDS::DataWriter_var dw = pub->create_datawriter(topic.in (),
dw_qos,
::DDS::DataWriterListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (dw.in ()))
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT("(%P|%t) create_datawriter failed.\n")));
return 1 ;
}
// ensure that the connection and association has been fully established
ACE_OS::sleep(2); //TBD remove this kludge when the transport is fixed.
// Indicate that the publisher is ready
FILE* writers_ready = ACE_OS::fopen (pub_ready_filename.c_str (), ACE_TEXT("w"));
if (writers_ready == 0)
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT("(%P|%t) ERROR: Unable to create publisher ready file\n")));
}
// Wait for the subscriber to be ready.
FILE* readers_ready = 0;
do
{
ACE_Time_Value small_time(0,250000);
ACE_OS::sleep (small_time);
readers_ready = ACE_OS::fopen (sub_ready_filename.c_str (), ACE_TEXT("r"));
} while (0 == readers_ready);
ACE_OS::fclose(writers_ready);
ACE_OS::fclose(readers_ready);
ReactorCtrl rc ;
// stop the Service_Participant reactor so LIVELINESS.kind=AUTOMATIC does not
// send out an automatic liveliness control message when sleeping in the loop
// below.
rc.pause() ;
Writer* writer = new Writer(dw.in (),
1,
num_ops_per_thread);
for (int i = 0 ; i < num_unlively_periods ; i++)
{
writer->run_test (i);
// 3 ensures that we will detect when an DataReader detects
// liveliness lost on an already unliveliy DataReader.
ACE_OS::sleep (3 * LEASE_DURATION_SEC);
}
writer->run_test (num_unlively_periods);
rc.resume() ;
bool writers_finished = false;
ACE_DEBUG((LM_DEBUG,ACE_TEXT("(%P|%t) %T waiting for writers to finish\n") ));
while ( !writers_finished )
{
ACE_OS::sleep(ACE_Time_Value(0,250000));
writers_finished = true;
writers_finished = writers_finished && writer->is_finished();
}
ACE_DEBUG((LM_DEBUG,ACE_TEXT("(%P|%t) %T Writers are finished\n") ));
// Indicate that the publisher is done
FILE* writers_completed = ACE_OS::fopen (pub_finished_filename.c_str (), ACE_TEXT("w"));
if (writers_completed == 0)
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT("(%P|%t) ERROR: Unable to create publisher completed file\n")));
}
ACE_DEBUG((LM_DEBUG,ACE_TEXT("(%P|%t) %T waiting for readers to finish\n") ));
// Wait for the subscriber to finish.
FILE* readers_completed = 0;
do
{
ACE_Time_Value small_time(0,250000);
ACE_OS::sleep (small_time);
readers_completed = ACE_OS::fopen (sub_finished_filename.c_str (), ACE_TEXT("r"));
} while (0 == readers_completed);
ACE_OS::fclose(writers_completed);
ACE_OS::fclose(readers_completed);
ACE_DEBUG((LM_DEBUG,ACE_TEXT("(%P|%t) %T Readers are finished\n") ));
// Clean up publisher objects
pub->delete_contained_entities() ;
delete writer;
dp->delete_publisher(pub.in ());
dp->delete_topic(topic.in ());
dpf->delete_participant(dp.in ());
TheServiceParticipant->shutdown ();
}
catch (const TestException&)
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT("(%P|%t) TestException caught in main.cpp. ")));
return 1;
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Exception caught in main.cpp:");
return 1;
}
return status;
}
int ACE_TMAIN(int argc, ACE_TCHAR *argv[]) {
try
{
ACE_DEBUG ((LM_DEBUG, "(%P|%t) publisher main\n"));
DDS::DomainParticipantFactory_var dpf =
TheParticipantFactoryWithArgs(argc, argv);
if (parse_args (argc, argv) == -1) {
return -1;
}
DDS::DomainParticipantQos partQos;
dpf->get_default_participant_qos(partQos);
// set up user data in DP qos
CORBA::ULong part_user_data_len
= static_cast<CORBA::ULong>(ACE_OS::strlen (PART_USER_DATA));
partQos.user_data.value.length (part_user_data_len);
partQos.user_data.value.replace (part_user_data_len,
part_user_data_len,
reinterpret_cast<CORBA::Octet*>(PART_USER_DATA));
DDS::DomainParticipant_var participant =
dpf->create_participant(411,
partQos,
DDS::DomainParticipantListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (participant.in ())) {
cerr << "publisher: create_participant failed." << endl;
return 1;
}
::Messenger::MessageTypeSupport_var ts = new ::Messenger::MessageTypeSupportImpl();
if (DDS::RETCODE_OK != ts->register_type(participant.in (), "Messenger")) {
cerr << "publisher: register_type failed." << endl;
exit(1);
}
CORBA::String_var type_name = ts->get_type_name ();
DDS::TopicQos topic_qos;
participant->get_default_topic_qos(topic_qos);
// set up topic data in topic qos
CORBA::ULong topic_data_len = static_cast<CORBA::ULong>(ACE_OS::strlen (TOPIC_DATA));
topic_qos.topic_data.value.length (topic_data_len);
topic_qos.topic_data.value.replace (topic_data_len, topic_data_len, reinterpret_cast<CORBA::Octet*>(TOPIC_DATA));
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 << "publisher: create_topic failed." << endl;
exit(1);
}
DDS::PublisherQos pub_qos;
participant->get_default_publisher_qos (pub_qos);
// set up group data in group qos
CORBA::ULong group_data_len = static_cast<CORBA::ULong> (ACE_OS::strlen (GROUP_DATA));
pub_qos.group_data.value.length (group_data_len);
pub_qos.group_data.value.replace (group_data_len, group_data_len, reinterpret_cast<CORBA::Octet*>(GROUP_DATA));
DDS::Publisher_var pub =
participant->create_publisher(pub_qos,
DDS::PublisherListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (pub.in ())) {
cerr << "publisher: create_publisher failed." << endl;
exit(1);
}
// Create the datawriter
DDS::DataWriterQos dw_qos;
pub->get_default_datawriter_qos (dw_qos);
dw_qos.durability.kind = DDS::TRANSIENT_LOCAL_DURABILITY_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;
// set up user data in DW qos
CORBA::ULong dw_user_data_len = static_cast<CORBA::ULong>(ACE_OS::strlen (DW_USER_DATA));
dw_qos.user_data.value.length (dw_user_data_len);
dw_qos.user_data.value.replace (dw_user_data_len,
dw_user_data_len,
reinterpret_cast<CORBA::Octet*>(DW_USER_DATA));
DDS::DataWriter_var dw =
pub->create_datawriter(topic.in (),
dw_qos,
DDS::DataWriterListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (dw.in ())) {
cerr << "publisher: create_datawriter failed." << endl;
exit(1);
}
// wait for Monitor 1 done
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 monitor1 done ...\n")));
ACE_OS::sleep (1);
++ i;
fp = ACE_OS::fopen (synch_fname, ACE_TEXT("r"));
}
if (fp != 0)
ACE_OS::fclose (fp);
// Now change the changeable qos. The second monitor should get the updated qos from BIT.
part_user_data_len = static_cast<CORBA::ULong>(ACE_OS::strlen (UPDATED_PART_USER_DATA));
partQos.user_data.value.length (part_user_data_len);
partQos.user_data.value.replace (part_user_data_len,
part_user_data_len,
reinterpret_cast<CORBA::Octet*>(UPDATED_PART_USER_DATA));
participant->set_qos (partQos);
dw_user_data_len = static_cast<CORBA::ULong>(ACE_OS::strlen (UPDATED_DW_USER_DATA));
dw_qos.user_data.value.length (dw_user_data_len);
dw_qos.user_data.value.replace (dw_user_data_len,
dw_user_data_len,
reinterpret_cast<CORBA::Octet*>(UPDATED_DW_USER_DATA));
dw->set_qos (dw_qos);
group_data_len = static_cast<CORBA::ULong> (ACE_OS::strlen (UPDATED_GROUP_DATA));
pub_qos.group_data.value.length (group_data_len);
pub_qos.group_data.value.replace (group_data_len,
group_data_len,
reinterpret_cast<CORBA::Octet*>(UPDATED_GROUP_DATA));
pub->set_qos (pub_qos);
topic_data_len = static_cast<CORBA::ULong>(ACE_OS::strlen (UPDATED_TOPIC_DATA));
topic_qos.topic_data.value.length (topic_data_len);
topic_qos.topic_data.value.replace (topic_data_len,
topic_data_len,
reinterpret_cast<CORBA::Octet*>(UPDATED_TOPIC_DATA));
topic->set_qos (topic_qos);
Writer* writer = new Writer(dw.in());
writer->start ();
while ( !writer->is_finished()) {
ACE_Time_Value small_time(0,250000);
ACE_OS::sleep (small_time);
}
// Cleanup
writer->end ();
delete writer;
participant->delete_contained_entities();
dpf->delete_participant(participant.in ());
TheServiceParticipant->shutdown ();
}
catch (CORBA::Exception& e)
{
cerr << "publisher: PUB: Exception caught in main.cpp:" << endl
<< e << endl;
exit(1);
}
return 0;
}
