int ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
DDS::DomainParticipantFactory_var dpf = DDS::DomainParticipantFactory::_nil();
DDS::DomainParticipant_var participant = DDS::DomainParticipant::_nil();
try
{
QuantLibAddinCpp::initializeAddin();
QuantLib::Calendar calendar = QuantLib::TARGET();
QuantLib::Date settlementDate(22, QuantLib::September, 2004);
settlementDate = calendar.adjust(settlementDate);
QuantLib::Integer fixingDays = 2;
QuantLib::Date todaysDate = calendar.advance(settlementDate, -fixingDays, QuantLib::Days);
QuantLibAddinCpp::qlSettingsSetEvaluationDate( todaysDate.serialNumber(), OH_NULL );
std::cout << "Today: " << todaysDate.weekday() << ", " << todaysDate << std::endl;
std::cout << "Settlement date: " << settlementDate.weekday() << ", " << settlementDate << std::endl;
// Initialize, and create a DomainParticipant
dpf = TheParticipantFactoryWithArgs(argc, argv);
qldds_utils::BasicDomainParticipant irs_participant( dpf, IRS_DOMAIN_ID );
irs_participant.createPublisher();
irs_participant.createSubscriber();
std::string term_structure;
std::vector<std::string> rate_helpers;
ACE_Get_Opt cmd_opts( argc, argv, ":c:n:i:" );
int option;
while ( (option = cmd_opts()) != EOF )
{
switch( option )
{
case 'c' :
{
std::istringstream f( cmd_opts.opt_arg() );
std::string s;
while (std::getline(f, s, '|')) {
rate_helpers.push_back(s);
}
break;
}
case 'n' :
{
term_structure = cmd_opts.opt_arg();
break;
}
}
}
QuantLibAddinCpp::qlLibor("Libor", "USD", "6M", "", false, false, true);
// Topics for Swap Components
// Setting up schedule topic
DDS::Topic_var schedule_topic =
irs_participant.createTopicAndRegisterType
< schedule::qlScheduleTypeSupport_var, schedule::qlScheduleTypeSupportImpl >
( SCHEDULE_TOPIC_NAME );
// setting up vanilla swap topic
DDS::Topic_var vanilla_swap_topic =
irs_participant.createTopicAndRegisterType
< vanillaswap::qlVanillaSwapTypeSupport_var, vanillaswap::qlVanillaSwapTypeSupportImpl >
( VANILLA_SWAP_TOPIC_NAME );
// Topics for curve components
// setting up deposit rate helper
DDS::Topic_var deposit_rate_helper2_topic = irs_participant.createTopicAndRegisterType
< ratehelpers::qlDepositRateHelper2TypeSupport_var, ratehelpers::qlDepositRateHelper2TypeSupportImpl >
( DEPOSIT_RATE_HELPER2_TOPIC_NAME );
// setting up FRA Rate helper
DDS::Topic_var fra_rate_helper2_topic = irs_participant.createTopicAndRegisterType
< ratehelpers::qlFraRateHelper2TypeSupport_var, ratehelpers::qlFraRateHelper2TypeSupportImpl >
( FRA_RATE_HELPER2_TOPIC_NAME );
// setting up Swap Rate helper
DDS::Topic_var swap_rate_helper2_topic = irs_participant.createTopicAndRegisterType
< ratehelpers::qlSwapRateHelper2TypeSupport_var, ratehelpers::qlSwapRateHelper2TypeSupportImpl >
( SWAP_RATE_HELPER2_TOPIC_NAME );
irs_participant.createDataReaderListener< schedule::qlScheduleDataReaderListenerImpl> ( qldds_lock, schedule_topic );
irs_participant.createDataReaderListener< VanillaSwapDataReaderListenerImpl > ( qldds_lock, vanilla_swap_topic );
irs_participant.createDataReaderListener< DepositRateHelper2DataReaderListenerImpl > ( qldds_lock,deposit_rate_helper2_topic );
irs_participant.createDataReaderListener< FraRateHelper2DataReaderListenerImpl > ( qldds_lock, fra_rate_helper2_topic );
irs_participant.createDataReaderListener< SwapRateHelper2DataReaderListenerImpl > ( qldds_lock, swap_rate_helper2_topic );
// setting up IRS Portfolio. Priced portfolios will be published on this topic
DDS::Topic_var irs_portfolio_topic = irs_participant.createTopicAndRegisterType
< IRS::PortfolioTypeSupport_var, IRS::PortfolioTypeSupportImpl >
( IRS_PORTFOLIO_TOPIC_NAME );
IRS::PortfolioDataWriter_var irs_portfolio_dw = irs_participant.createDataWriter
< IRS::PortfolioDataWriter_var, IRS::PortfolioDataWriter >
( irs_portfolio_topic );
curves.insert( std::pair < std::string, std::vector< std::string > > ( term_structure, rate_helpers ) );
int calculation_performed = 0;
while ( calculation_performed < 30 )
{
IRS::Portfolio irs_portfolio_out;
if ( computeNPVs( term_structure, irs_portfolio_out ) == false )
{
ACE_Time_Value sleep_100ms( 0, 100000 );
ACE_OS::sleep( sleep_100ms );
continue;
} else {
calculation_performed++;
ACE_OS::sleep(1);
}
std::cout << "Calculator ["<< term_structure << "] publishing NPVs for "<< irs_portfolio_out.swaps.length() << " interest rate swaps."<< std::endl;
int ret = irs_portfolio_dw->write( irs_portfolio_out, DDS::HANDLE_NIL );
if (ret != DDS::RETCODE_OK) {
ACE_ERROR ((LM_ERROR, ACE_TEXT("(%P|%t) ERROR: IRS Portfolio write returned %d.\n"), ret));
}
}
} catch (CORBA::Exception& e)
{
cerr << "Exception caught in main.cpp:" << endl << e << endl;
ACE_OS::exit(1);
}
TheServiceParticipant->shutdown();
return 0;
}
int
main (int argc, char *argv[])
{
// Try to set real-time scheduling class. Requires login as
// superuser or administrator.
//set_rt ();
int status = 0;
try
{
::DDS::DomainParticipantFactory_var dpf =
TheParticipantFactoryWithArgs (argc, argv);
// let the Service_Participant (in above line) strip out
// -DCPSxxx parameters and then get application specific parameters.
status = parse_args (argc, argv);
if (0 != status)
{
return status;
}
::DDS::DomainParticipant_var dp =
dpf->create_participant (TEST_DOMAIN,
PARTICIPANT_QOS_DEFAULT,
::DDS::DomainParticipantListener::_nil ());
if (CORBA::is_nil (dp.in ()))
{
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("%P|%t ERROR: create_participant ")
ACE_TEXT ("failed.\n")),
1);
}
DDS::ReturnCode_t ret_code = ::DDS::RETCODE_OK;
BytesTypeSupportImpl* bytes_ts_servant =
new BytesTypeSupportImpl ();
PortableServer::ServantBase_var safe_servant =
bytes_ts_servant;
BytesTypeSupport_var bytes_ts =
TAO::DCPS::servant_to_reference_2<BytesTypeSupport> (
bytes_ts_servant);
ret_code = bytes_ts->register_type (dp.in (), TEST_TYPE);
if (::DDS::RETCODE_OK != ret_code)
{
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("%P|%t ERROR: Failed to register ")
ACE_TEXT ("type support.")
ACE_TEXT ("for data size %d\n"),
DATA_SIZE),
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.resource_limits.max_instances = MAX_INSTANCES;
topic_qos.resource_limits.max_samples = MAX_SAMPLES;
if (isReliable)
{
topic_qos.reliability.kind = ::DDS::RELIABLE_RELIABILITY_QOS;
topic_qos.reliability.max_blocking_time.sec = max_mili_sec_blocking / 1000;
topic_qos.reliability.max_blocking_time.nanosec =
(max_mili_sec_blocking % 1000) * 1000*1000;
}
else
{
topic_qos.reliability.kind = ::DDS::BEST_EFFORT_RELIABILITY_QOS;
}
if (QoS_KEEP_ALL)
{
topic_qos.history.kind = ::DDS::KEEP_ALL_HISTORY_QOS;
}
::DDS::Topic_var topic =
dp->create_topic (test_topic_name.c_str (),
TEST_TYPE,
topic_qos,
::DDS::TopicListener::_nil ());
ACE_DEBUG ((LM_DEBUG, "(%P|%t)The current topic is %s\n",
test_topic_name.c_str()));
if (CORBA::is_nil (topic.in ()))
{
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("%P|%t ERROR: ")
ACE_TEXT ("create_topic failed.\n")),
1);
}
// Create the publisher
::DDS::Publisher_var pub =
dp->create_publisher (PUBLISHER_QOS_DEFAULT,
::DDS::PublisherListener::_nil ());
if (CORBA::is_nil (pub.in ()))
{
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("%P|%t ERROR: ")
ACE_TEXT ("create_publisher failed.\n")),
1);
}
// Initialize the transport
if (0 != ::init_writer_tranport ())
{
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT("%P|%t ERROR: ")
ACE_TEXT ("init_transport failed!\n")),
1);
}
// Attach the publisher to the transport.
::TAO::DCPS::PublisherImpl* pub_impl =
::TAO::DCPS::reference_to_servant< ::TAO::DCPS::PublisherImpl,
::DDS::Publisher_ptr> (
pub.in ());
if (0 == pub_impl)
{
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("%P|%t ERROR: Failed ")
ACE_TEXT ("to obtain servant ")
ACE_TEXT ("::TAO::DCPS::PublisherImpl\n")),
1);
}
TAO::DCPS::AttachStatus attach_status =
pub_impl->attach_transport (writer_transport_impl.in ());
if (attach_status != TAO::DCPS::ATTACH_OK)
{
// We failed to attach to the transport for some reason.
std::string status_str;
switch (attach_status)
{
case TAO::DCPS::ATTACH_BAD_TRANSPORT:
status_str = "ATTACH_BAD_TRANSPORT";
break;
case TAO::DCPS::ATTACH_ERROR:
status_str = "ATTACH_ERROR";
break;
case TAO::DCPS::ATTACH_INCOMPATIBLE_QOS:
status_str = "ATTACH_INCOMPATIBLE_QOS";
break;
default:
status_str = "Unknown Status";
break;
}
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("%P|%t ERROR: Failed to ")
ACE_TEXT ("attach to the transport. ")
ACE_TEXT ("AttachStatus == %s\n"),
status_str.c_str()),
1);
}
// Create the datawriters
::DDS::DataWriterQos dw_qos;
pub->get_default_datawriter_qos (dw_qos);
pub->copy_from_topic_qos (dw_qos, topic_qos);
::DDS::DataWriter_var * dws =
new ::DDS::DataWriter_var[num_datawriters];
// Create one or multiple datawriters belonging to the same
// publisher.
for (int k = 0; k < num_datawriters; ++k)
{
dws[k] = pub->create_datawriter (topic.in () ,
dw_qos,
::DDS::DataWriterListener::_nil ());
if (CORBA::is_nil (dws[k].in ()))
{
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("%P|%t ERROR: ")
ACE_TEXT ("create_datawriter failed.\n")),
1);
}
}
Writer** writers = new Writer* [num_datawriters] ;
// If we're using UDP then oversend the number of samples
if (usingUdp)
{
// Using the precedence here from NDDS publisher for determining
// oversampling value.
STATS_SAMPLES = (STATS_SAMPLES + PRIMER_SAMPLES) * OVERSAMPLEMULTIPLIER;
}
for (int p = 0; p < num_datawriters; ++p)
{
writers[p] = new Writer (dws[p].in (),
pub_output_file.c_str (),
PRIMER_SAMPLES,
STATS_SAMPLES,
DATA_SIZE,
num_datareaders,
id + p);
writers[p]->start ();
}
bool writers_finished = false;
while (!writers_finished)
{
ACE_Guard<ACE_Recursive_Thread_Mutex> just_me (done_lock_);
// wait for a writer to signal so we done spin
// waiting to see if the publisher is done.
done_condition_.wait ();
writers_finished = true;
for (int m = 0; m < num_datawriters; ++m)
{
writers_finished =
writers_finished && writers[m]->is_finished ();
}
}
ACE_OS::sleep (1);
// Clean up publisher objects
pub->delete_contained_entities ();
delete [] dws;
for (int q = 0; q < num_datawriters; ++q)
{
delete writers[q];
}
delete [] writers;
dp->delete_publisher (pub.in ());
dp->delete_topic (topic.in ());
dpf->delete_participant (dp.in ());
ACE_OS::sleep (2);
TheTransportFactory->release ();
TheServiceParticipant->shutdown ();
writer_transport_impl = 0;
}
catch (CORBA::Exception &ex)
{
ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION,
"Exception caught in main.cpp:");
return 1;
}
return status;
}
int main (int argc, char *argv[]) {
try
{
DDS::DomainParticipantFactory_var dpf =
TheParticipantFactoryWithArgs(argc, argv);
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;
}
if (parse_args (argc, argv) == -1) {
return -1;
}
{
// At this point we are connected to the Info Repo.
// Trigger the driver
std::ofstream ior_stream (driver_trigger.c_str());
if (!ior_stream) {
std::cerr << "Unable to open internal trigger file: "
<< driver_trigger << std::endl;
return -1;
}
ior_stream << "junk";
}
int max_wait_time = 30; //seconds
int count = 0;
while (true)
{
if (count > max_wait_time) {
std::cerr << "Timed out waiting for external file: "
<< publisher_trigger << std::endl;
return -1;
}
// check for file
ACE_stat my_stat;
if (ACE_OS::stat (publisher_trigger.c_str(), &my_stat) == 0) {
// found the trigger file.
break;
}
ACE_OS::sleep (1);
}
MessageTypeSupportImpl* servant = new MessageTypeSupportImpl();
PortableServer::ServantBase_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);
}
TAO::DCPS::TransportImpl_rch tcp_impl =
TheTransportFactory->create_transport_impl (transport_impl_id,
::TAO::DCPS::AUTO_CONFIG);
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.
TAO::DCPS::PublisherImpl* pub_impl =
::TAO::DCPS::reference_to_servant< TAO::DCPS::PublisherImpl,
DDS::Publisher_ptr>(pub.in ());
if (0 == pub_impl) {
cerr << "Failed to obtain publisher servant" << endl;
exit(1);
}
TAO::DCPS::AttachStatus status = pub_impl->attach_transport(tcp_impl.in());
if (status != TAO::DCPS::ATTACH_OK) {
std::string status_str;
switch (status) {
case TAO::DCPS::ATTACH_BAD_TRANSPORT:
status_str = "ATTACH_BAD_TRANSPORT";
break;
case TAO::DCPS::ATTACH_ERROR:
status_str = "ATTACH_ERROR";
break;
case TAO::DCPS::ATTACH_INCOMPATIBLE_QOS:
status_str = "ATTACH_INCOMPATIBLE_QOS";
break;
default:
status_str = "Unknown Status";
break;
}
cerr << "Failed to attach to the transport. Status == "
<< status_str.c_str() << endl;
exit(1);
}
// 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,
DDS::DataWriterListener::_nil());
if (CORBA::is_nil (dw.in ())) {
cerr << "create_datawriter failed." << endl;
exit(1);
}
Writer* writer = new Writer(dw.in());
writer->start ();
while ( !writer->is_finished()) {
ACE_Time_Value small(0,250000);
ACE_OS::sleep (small);
}
// Cleanup
writer->end ();
delete writer;
participant->delete_contained_entities();
dpf->delete_participant(participant.in ());
TheTransportFactory->release();
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[])
{
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.
status = parse_args (argc, argv);
if (status)
return status;
::DDS::DomainParticipant_var dp =
dpf->create_participant(TEST_DOMAIN,
PARTICIPANT_QOS_DEFAULT,
::DDS::DomainParticipantListener::_nil());
if (CORBA::is_nil (dp.in() ))
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT(" %P|%t ERROR: create_participant failed.\n")));
return 1 ;
}
// Register the type supports
switch (DATA_SIZE)
{
case 128:
{
::Xyz::Pt128TypeSupportImpl* pt128ts_servant = new ::Xyz::Pt128TypeSupportImpl();
TAO::DCPS::LocalObject_var safe_servant = pt128ts_servant;
::Xyz::Pt128TypeSupport_var pt128ts =
TAO::DCPS::servant_to_reference (pt128ts_servant);
if (::DDS::RETCODE_OK != pt128ts->register_type(dp.in() , TEST_TYPE))
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT (" %P|%t ERROR: Failed to register the Pt128TypeSupport.")));
return 1;
}
}
break;
case 512:
{
::Xyz::Pt512TypeSupportImpl* pt512ts_servant = new ::Xyz::Pt512TypeSupportImpl();
TAO::DCPS::LocalObject_var safe_servant = pt512ts_servant;
::Xyz::Pt512TypeSupport_var pt512ts =
TAO::DCPS::servant_to_reference (pt512ts_servant);
if (::DDS::RETCODE_OK != pt512ts->register_type(dp.in() , TEST_TYPE))
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT (" %P|%t ERROR: Failed to register the Pt512TypeSupport.")));
return 1;
}
}
break;
case 2048:
{
::Xyz::Pt2048TypeSupportImpl* pt2048ts_servant = new ::Xyz::Pt2048TypeSupportImpl();
TAO::DCPS::LocalObject_var safe_servant = pt2048ts_servant;
::Xyz::Pt2048TypeSupport_var pt2048ts =
TAO::DCPS::servant_to_reference (pt2048ts_servant);
if (::DDS::RETCODE_OK != pt2048ts->register_type(dp.in() , TEST_TYPE))
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT (" %P|%t ERROR: Failed to register the Pt2048TypeSupport.")));
return 1;
}
}
break;
case 8192:
{
::Xyz::Pt8192TypeSupportImpl* pt8192ts_servant = new ::Xyz::Pt8192TypeSupportImpl();
TAO::DCPS::LocalObject_var safe_servant = pt8192ts_servant;
::Xyz::Pt8192TypeSupport_var pt8192ts =
TAO::DCPS::servant_to_reference (pt8192ts_servant);
if (::DDS::RETCODE_OK != pt8192ts->register_type(dp.in() , TEST_TYPE))
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT (" %P|%t ERROR: Failed to register the Pt8192TypeSupport.")));
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.resource_limits.max_instances = MAX_INSTANCES;
topic_qos.resource_limits.max_samples = MAX_SAMPLES;
topic_qos.reliability.kind = ::DDS::RELIABLE_RELIABILITY_QOS;
topic_qos.reliability.max_blocking_time.sec = max_mili_sec_blocking / 1000;
topic_qos.reliability.max_blocking_time.nanosec =
(max_mili_sec_blocking % 1000) * 1000*1000;
topic_qos.history.kind = ::DDS::KEEP_ALL_HISTORY_QOS;
::DDS::Topic_var topic =
dp->create_topic (TEST_TOPIC,
TEST_TYPE,
topic_qos,
::DDS::TopicListener::_nil());
if (CORBA::is_nil (topic.in() ))
{
return 1 ;
}
// Create the publisher
::DDS::Publisher_var pub =
dp->create_publisher(PUBLISHER_QOS_DEFAULT,
::DDS::PublisherListener::_nil());
if (CORBA::is_nil (pub.in() ))
{
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT(" %P|%t ERROR: create_publisher failed.\n")),
1);
}
// Initialize the transport
if (0 != ::init_writer_tranport() )
{
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT(" %P|%t ERROR: init_transport failed!\n")),
1);
}
// Attach the publisher to the transport.
TAO::DCPS::PublisherImpl* pub_impl
= TAO::DCPS::reference_to_servant<TAO::DCPS::PublisherImpl> (pub.in());
if (0 == pub_impl)
{
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT(" %P|%t ERROR: Failed to obtain servant ::TAO::DCPS::PublisherImpl\n")),
1);
}
TAO::DCPS::AttachStatus attach_status =
pub_impl->attach_transport(writer_transport_impl.in());
if (attach_status != TAO::DCPS::ATTACH_OK)
{
// We failed to attach to the transport for some reason.
ACE_TString status_str;
switch (attach_status)
{
case TAO::DCPS::ATTACH_BAD_TRANSPORT:
status_str = "ATTACH_BAD_TRANSPORT";
break;
case TAO::DCPS::ATTACH_ERROR:
status_str = "ATTACH_ERROR";
break;
case TAO::DCPS::ATTACH_INCOMPATIBLE_QOS:
status_str = "ATTACH_INCOMPATIBLE_QOS";
break;
default:
status_str = "Unknown Status";
break;
}
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT(" %P|%t ERROR: Failed to attach to the transport. ")
ACE_TEXT("AttachStatus == %s\n"),
status_str.c_str()),
1);
}
// Create the datawriters
::DDS::DataWriterQos dw_qos;
pub->get_default_datawriter_qos (dw_qos);
pub->copy_from_topic_qos (dw_qos, topic_qos);
::DDS::DataWriter_var * dws = new ::DDS::DataWriter_var[num_datawriters];
// Create one or multiple datawriters belonging to the same
// publisher.
for (int k = 0; k < num_datawriters; k ++)
{
dws[k] = pub->create_datawriter(topic.in() ,
dw_qos,
::DDS::DataWriterListener::_nil());
if (CORBA::is_nil (dws[k].in ()))
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT(" %P|%t ERROR: create_datawriter failed.\n")));
return 1 ;
}
}
Writer** writers = new Writer* [num_datawriters] ;
for (int p = 0; p < num_datawriters; p ++)
{
writers[p] = new Writer(dws[p].in (),
NUM_SAMPLES,
DATA_SIZE,
num_datareaders,
id + p);
writers[p]->start ();
}
bool writers_finished = false;
while ( !writers_finished )
{
ACE_Guard<ACE_Recursive_Thread_Mutex> just_me(done_lock_);
// wait for a writer to signal so we done spin
// waiting to see if the publisher is done.
//ACE_Time_Value timeout(5,0);
done_condition_.wait();
writers_finished = true;
for (int m = 0; m < num_datawriters; m ++)
{
writers_finished = writers_finished && writers[m]->is_finished();
}
}
// Clean up publisher objects
pub->delete_contained_entities() ;
delete [] dws;
for (int q = 0; q < num_datawriters; q ++)
{
delete writers[q];
}
delete [] writers;
dp->delete_publisher(pub.in());
dp->delete_topic(topic.in());
dpf->delete_participant(dp.in());
TheTransportFactory->release();
TheServiceParticipant->shutdown ();
writer_transport_impl = 0;
}
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 {
// Initialize DomainParticipantFactory
DDS::DomainParticipantFactory_var dpf =
TheParticipantFactoryWithArgs(argc, argv);
int error;
if ((error = parse_args(argc, argv)) != 0) {
return error;
}
// Create DomainParticipant
DDS::DomainParticipant_var participant =
dpf->create_participant(4,
PARTICIPANT_QOS_DEFAULT,
0,
OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (!participant) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("ERROR: %N:%l: main() -")
ACE_TEXT(" create_participant failed!\n")),
-1);
}
ACE_DEBUG((LM_DEBUG, "(%P|%t) Start publisher\n"));
{
// Register TypeSupport (Messenger::Message)
Messenger::MessageTypeSupport_var ts =
new Messenger::MessageTypeSupportImpl;
if (ts->register_type(participant, "Messenger") != DDS::RETCODE_OK) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("ERROR: %N:%l: main() -")
ACE_TEXT(" register_type failed!\n")),
-1);
}
// Create Topic (Movie Discussion List)
CORBA::String_var type_name = ts->get_type_name();
ACE_DEBUG((LM_DEBUG, "registered type name = %s\n", type_name.in()));
DDS::Topic_var topic =
participant->create_topic("Movie Discussion List",
type_name,
TOPIC_QOS_DEFAULT,
0,
OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (!topic) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("ERROR: %N:%l: main() -")
ACE_TEXT(" create_topic failed!\n")),
-1);
}
// setup partition
DDS::PublisherQos pub_qos;
participant->get_default_publisher_qos(pub_qos);
DDS::StringSeq my_partition;
my_partition.length(1);
my_partition[0] = "One";
pub_qos.partition.name = my_partition;
// Create Publisher
DDS::Publisher_var publisher =
participant->create_publisher(pub_qos,
0,
OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (!publisher) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("ERROR: %N:%l: main() -")
ACE_TEXT(" create_publisher failed!\n")),
-1);
}
// Create DataWriter
DDS::DataWriter_var writer =
publisher->create_datawriter(topic,
DATAWRITER_QOS_DEFAULT,
0,
OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (!writer) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("ERROR: %N:%l: main() -")
ACE_TEXT(" create_datawriter failed!\n")),
-1);
}
Messenger::MessageDataWriter_var message_writer =
Messenger::MessageDataWriter::_narrow(writer);
if (!message_writer) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("ERROR: %N:%l: main() -")
ACE_TEXT(" _narrow failed!\n")),
-1);
}
// Block until Subscriber is available
DDS::StatusCondition_var condition = writer->get_statuscondition();
condition->set_enabled_statuses(DDS::PUBLICATION_MATCHED_STATUS);
DDS::WaitSet_var ws = new DDS::WaitSet;
ws->attach_condition(condition);
while (true) {
DDS::PublicationMatchedStatus matches;
if (writer->get_publication_matched_status(matches) != ::DDS::RETCODE_OK) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("ERROR: %N:%l: main() -")
ACE_TEXT(" get_publication_matched_status failed!\n")),
-1);
}
if (matches.current_count >= 1) {
break;
}
DDS::ConditionSeq conditions;
DDS::Duration_t timeout = { 60, 0 };
if (ws->wait(conditions, timeout) != DDS::RETCODE_OK) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("ERROR: %N:%l: main() -")
ACE_TEXT(" wait failed!\n")),
-1);
}
}
ws->detach_condition(condition);
// Write samples
Messenger::Message message;
message.subject_id = 99;
message.from = "Comic Book Guy";
message.subject = "Review";
message.text = "Worst. Movie. Ever.";
message.count = 0;
for (int i = 0; i < 10; ++i) {
DDS::ReturnCode_t error = message_writer->write(message, DDS::HANDLE_NIL);
++message.count;
++message.subject_id;
if (error != DDS::RETCODE_OK) {
ACE_ERROR((LM_ERROR,
ACE_TEXT("ERROR: %N:%l: main() -")
ACE_TEXT(" write returned %d!\n"), error));
}
}
}
ACE_DEBUG((LM_DEBUG, "(%P|%t) Stop publisher\n"));
// Clean-up!
participant->delete_contained_entities();
dpf->delete_participant(participant);
TheServiceParticipant->shutdown();
} catch (const CORBA::Exception& e) {
e._tao_print_exception("Exception caught in main():");
return -1;
}
ACE_DEBUG((LM_DEBUG, "(%P|%t) Publisher exiting\n"));
return 0;
}
int ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
int status = 0;
try
{
::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);
::DDS::Topic_var topic =
dp->create_topic (MY_TOPIC,
MY_TYPE,
TOPIC_QOS_DEFAULT,
::DDS::TopicListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (topic.in ())) {
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT("(%P|%t) create_topic failed!\n")),
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.liveliness.lease_duration.sec = LEASE_DURATION_SEC;
dw_qos.liveliness.lease_duration.nanosec = 0;
::DDS::DataWriterListener_var dwl (new DataWriterListenerImpl);
::DDS::DataWriter_var dw = pub->create_datawriter(topic.in (),
dw_qos,
dwl.in(),
::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 ;
}
// Writer writer(dw.in ());
// ACE_Time_Value duration(10);
// writer.run_test(duration);
ACE_OS::sleep(test_duration);
// Clean up publisher objects
pub->delete_contained_entities() ;
dp->delete_publisher(pub.in ());
dp->delete_topic(topic.in ());
dpf->delete_participant(dp.in ());
TheServiceParticipant->shutdown ();
// check to see if the publisher worked
{
DataWriterListenerImpl* dwl_servant =
dynamic_cast<DataWriterListenerImpl*>(dwl.in());
if(!dwl_servant->valid())
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT("(%P|%t) publisher didn't connect with subscriber. test_duration=%d\n"),
test_duration));
return 1 ;
}
}
}
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
{
DDS::DomainParticipant_var participant1;
DDS::DomainParticipant_var participant2;
DDS::DomainParticipantFactory_var dpf = TheParticipantFactoryWithArgs(argc, argv);
{
OpenDDS::DCPS::TypeSupport_var typsup = new Xyz::FooTypeSupportImpl;
Options configopt(argc, argv);
Factory fc(configopt, typsup);
Options plainopt;
Factory fp(plainopt, typsup);
DDS::DataWriterListener_var dwl1(new DataWriterListenerImpl);
DDS::DataWriterListener_var dwl2(new DataWriterListenerImpl);
if (configopt.collocation_str == "none")
{
participant1 = fc.participant(dpf);
Pusher w(fc, dpf, participant1, dwl1);
TEST_ASSERT(assert_supported(configopt, w.writer_));
w.push(ACE_Time_Value(configopt.test_duration));
if (!configopt.negotiated_str.empty())
{
TEST_ASSERT(assert_negotiated(configopt, w.writer_));
}
}
else if (configopt.collocation_str == "process")
{
participant1 = fc.participant(dpf);
Pusher w1(fc, dpf, participant1, dwl1);
// TEST_ASSERT(wait_publication_matched_status(configopt, w1.writer_));
participant2 = fp.participant(dpf);
Pusher w2(fp, dpf, participant2, dwl2);
// TEST_ASSERT(wait_publication_matched_status(configopt, w2.writer_));
TEST_ASSERT(assert_supported(configopt, w1.writer_));
if (configopt.entity_str == "none")
{
TEST_ASSERT(assert_supported(configopt, w2.writer_));
}
else
{
TEST_ASSERT(!assert_supported(configopt, w2.writer_));
TEST_ASSERT(assert_supported(plainopt, w2.writer_));
}
w1.push(ACE_Time_Value(1));
if (!configopt.negotiated_str.empty())
{
TEST_ASSERT(assert_negotiated(configopt, w1.writer_));
}
}
else if (configopt.collocation_str == "participant")
{
participant1 = fc.participant(dpf);
participant2 = participant1;
DDS::Publisher_var publisher1(fc.publisher(participant1));
Pusher w1(fc, dpf, participant1, publisher1, dwl1);
DDS::Publisher_var publisher2(fp.publisher(participant2));
Pusher w2(fp, dpf, participant2, publisher2, dwl2);
TEST_ASSERT(assert_supported(configopt, w1.writer_));
TEST_ASSERT(assert_supported(configopt, w2.writer_));
w1.push(ACE_Time_Value(1));
if (!configopt.negotiated_str.empty())
{
TEST_ASSERT(assert_negotiated(configopt, w1.writer_));
}
}
else if (configopt.collocation_str == "pubsub")
{
participant1 = fc.participant(dpf);
participant2 = participant1;
DDS::Publisher_var publisher1(fc.publisher(participant1));
DDS::Publisher_var publisher2(publisher1);
Pusher w1(fc, dpf, participant1, publisher1, dwl1);
Pusher w2(fp, dpf, participant2, publisher2, dwl2);
TEST_ASSERT(assert_supported(configopt, w1.writer_));
TEST_ASSERT(assert_supported(configopt, w2.writer_));
w1.push(ACE_Time_Value(1));
if (!configopt.negotiated_str.empty())
{
TEST_ASSERT(assert_negotiated(configopt, w1.writer_));
}
}
if (configopt.collocation_str == "none")
{
TEST_ASSERT(assert_publication_matched(configopt, dwl1));
}
else if (configopt.collocation_str == "process")
{
TEST_ASSERT(assert_publication_matched(configopt, dwl1)
&& assert_publication_matched(configopt, dwl2));
}
else if (configopt.collocation_str == "participant")
{
TEST_ASSERT(assert_publication_matched(configopt, dwl1)
&& assert_publication_matched(configopt, dwl2));
}
else if (configopt.collocation_str == "pubsub")
{
TEST_ASSERT(assert_publication_matched(configopt, dwl1)
&& assert_publication_matched(configopt, dwl2));
}
}
// only want to clean up participant2 if it isn't just pointing to
// participant1
if (participant1.in() == participant2.in()) {
participant2 = 0;
}
// Clean up
if (participant1) {
ACE_DEBUG((LM_INFO, ACE_TEXT("(%P|%t) deleting entities1\n")));
participant1->delete_contained_entities();
ACE_DEBUG((LM_INFO, ACE_TEXT("(%P|%t) deleting participant1\n")));
dpf->delete_participant(participant1);
}
if (participant2) {
ACE_DEBUG((LM_INFO, ACE_TEXT("(%P|%t) deleting entities2\n")));
participant2->delete_contained_entities();
ACE_DEBUG((LM_INFO, ACE_TEXT("(%P|%t) deleting participant2\n")));
dpf->delete_participant(participant2);
}
ACE_DEBUG((LM_INFO, ACE_TEXT("(%P|%t) Shutting publisher down ...\n")));
TheServiceParticipant->shutdown();
ACE_DEBUG((LM_INFO, ACE_TEXT("(%P|%t) Publisher shutdown complete.\n")));
}
catch (char const *ex)
{
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("(%P|%t) Assertion failed.\n"), ex), -1);
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception("Exception caught in main.cpp:");
return 1;
}
catch (const std::runtime_error& rte)
{
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("(%P|%t) main() exception: %s\n"), rte.what()), -1);
}
ACE_ERROR_RETURN((LM_INFO,
ACE_TEXT("(%P|%t) done.\n")), 0);
}
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(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(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(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(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(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(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;
}
int
ACE_TMAIN(int argc, ACE_TCHAR** argv)
{
parse_args(argc, argv);
ACE_DEBUG((LM_INFO, ACE_TEXT("(%P|%t) -> SUBSCRIBER STARTED\n")));
::CORBA::Long sec = deadline_msec / 1000;
::CORBA::ULong remainder_msec = (deadline_msec - 1000*sec);
::CORBA::ULong nanosec = remainder_msec * 1000000;
DDS::Duration_t const DEADLINE_PERIOD =
{
sec,
nanosec
};
bool deadline_used = DEADLINE_PERIOD.sec > 0 || DEADLINE_PERIOD.nanosec > 0;
try
{
DDS::DomainParticipantFactory_var dpf =
TheParticipantFactoryWithArgs(argc, argv);
SubscriberListenerImpl * subscriberListener =
new SubscriberListenerImpl(received_samples, missed_samples);
DDS::SubscriberListener_var subscriberListener_var = subscriberListener;
// Create Participant
DDS::DomainParticipant_var participant =
dpf->create_participant(42,
PARTICIPANT_QOS_DEFAULT,
DDS::DomainParticipantListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil(participant.in()))
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l: main()")
ACE_TEXT(" create_participant failed!\n")), 1);
ACE_Time_Value delay_between_cycles(0, delay_between_cycles_msec * 1000);
bool expected_samples_received = false;
int i = 0;
do
{
++i;
ACE_DEBUG((LM_INFO, ACE_TEXT("(%P|%t) -> Subscriber cycle %d\n"), i));
// Create Subscriber
DDS::Subscriber_var subscriber =
participant->create_subscriber(SUBSCRIBER_QOS_DEFAULT,
subscriberListener,
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil(subscriber.in()))
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l: main()")
ACE_TEXT(" create_subscriber failed!\n")), 2);
// Register Type (FooType)
FooTypeSupport_var ts = new FooTypeSupportImpl;
if (ts->register_type(participant.in(), "") != DDS::RETCODE_OK)
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l: main()")
ACE_TEXT(" register_type failed!\n")), 5);
// Create Topic (FooTopic)
DDS::Topic_var topic =
participant->create_topic("FooTopic",
ts->get_type_name(),
TOPIC_QOS_DEFAULT,
DDS::TopicListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
DDS::TopicDescription_ptr topic_used = topic.in();
DDS::ContentFilteredTopic_ptr cft = 0;
if (use_cft)
{
// Topic name must be unique.
ACE_CString topic_name = "FooTopic-Filtered-" + toStr(i);
cft =
participant->create_contentfilteredtopic(topic_name.c_str(),
topic,
"key > 0",
DDS::StringSeq());
if (CORBA::is_nil(cft))
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l: main()")
ACE_TEXT(" create_contentfilteredtopic failed!\n")), 8);
topic_used = cft;
}
if (CORBA::is_nil(topic.in()))
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l: main()")
ACE_TEXT(" create_topic failed!\n")), 6);
// Create DataReader
DDS::DataReaderQos reader_qos;
subscriber->get_default_datareader_qos(reader_qos);
reader_qos.history.kind = DDS::KEEP_ALL_HISTORY_QOS;
if (deadline_used)
{
reader_qos.deadline.period.sec = DEADLINE_PERIOD.sec;
reader_qos.deadline.period.nanosec = DEADLINE_PERIOD.nanosec;
}
DDS::DataReader_var reader =
subscriber->create_datareader(topic_used,
reader_qos,
DDS::DataReaderListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil(reader.in()))
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l: main()")
ACE_TEXT(" create_datareader failed!\n")), 7);
ACE_Time_Value sample_count_sleep(0, sample_count_sleep_msec * 1000);
std::size_t sample_count;
std::size_t sample_count_start = subscriberListener->samples_processed();
do
{
ACE_OS::sleep(sample_count_sleep);
sample_count =
subscriberListener->samples_processed();
expected_samples_received = sample_count >= expected_samples;
// ACE_DEBUG((LM_DEBUG, "(%P|%t) sample_count = %d\n", sample_count));
}
while (!expected_samples_received &&
(sample_count - sample_count_start) < samples_per_cycle);
subscriber->delete_datareader(reader.in());
if (use_cft)
CORBA::release(cft);
participant->delete_subscriber(subscriber.in());
ACE_OS::sleep(delay_between_cycles);
}
while (!expected_samples_received);
participant->delete_contained_entities();
dpf->delete_participant(participant.in());
TheServiceParticipant->shutdown();
ACE_DEBUG ((LM_INFO,
ACE_TEXT("INFO: %d samples received\n"),
subscriberListener->received_samples()));
if (deadline_used)
ACE_DEBUG ((LM_INFO,
ACE_TEXT("INFO: deadline missed %d times\n"),
subscriberListener->missed_samples()));
}
catch (const CORBA::Exception& e)
{
e._tao_print_exception("caught in main()");
return 9;
}
ACE_DEBUG((LM_INFO, ACE_TEXT("(%P|%t) <- SUBSCRIBER FINISHED\n")));
return 0;
}
int ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
bool ok = true;
bool generated_config = false;
int mypid = ACE_OS::getpid();
try {
//Look to see if the config file (.ini) was generated
//for rtps participant processing
for(int i = 0; i < argc; ++i) {
if(ACE_OS::strstr(argv[i], ACE_TEXT("generated"))) {
generated_config = true;
} else if (0 == ACE_OS::strcmp(ACE_TEXT("-p"), argv[i]) && i < argc - 1) {
mypid = ACE_OS::atoi(argv[i + 1]);
}
}
// Initialize DomainParticipantFactory
DDS::DomainParticipantFactory_var dpf =
TheParticipantFactoryWithArgs(argc, argv);
// handle test performance issue on one platform
#if defined (sun)
const char* udpTransName = "udp";
OpenDDS::DCPS::TransportInst_rch inst = OpenDDS::DCPS::TransportRegistry::instance()->get_inst(udpTransName);
if (inst != 0) {
OpenDDS::DCPS::UdpInst_rch udp_inst = OpenDDS::DCPS::dynamic_rchandle_cast<OpenDDS::DCPS::UdpInst>(inst);
if (udp_inst == 0) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l main()")
ACE_TEXT(" ERROR: retrieving transport config for: %C failed!\n"),
udpTransName), -1);
}
udp_inst->rcv_buffer_size_ = 0x40000;
}
#endif
const Options options(argc, argv);
// Create DomainParticipant
typedef std::vector<DDS::DomainParticipant_var> Participants;
Participants participants(options.num_sub_participants);
// Register Type (Messenger::Message)
Messenger::MessageTypeSupport_var ts =
new Messenger::MessageTypeSupportImpl();
CORBA::String_var type_name = ts->get_type_name();
typedef std::vector<DataReaderListenerImpl*> ListenerServants;
ListenerServants listener_servants;
std::vector<DDS::DataReaderListener_var> listeners;
std::stringstream ss;
ss << std::setw(5) << mypid;
const std::string pid = ss.str();
ACE_DEBUG((LM_DEBUG, ACE_TEXT("%T (%P|%t) Created dpf\n")));
unsigned int part_index = 0;
for (Participants::iterator part = participants.begin();
part != participants.end();
++part, ++part_index) {
ACE_DEBUG((LM_DEBUG, ACE_TEXT("%T (%P|%t) Creating participant\n")));
*part =
dpf->create_participant(411,
PARTICIPANT_QOS_DEFAULT,
DDS::DomainParticipantListener::_nil(),
OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil(part->in())) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l main()")
ACE_TEXT(" ERROR: create_participant() failed!\n")), -1);
}
if (generated_config) {
std::stringstream domain_config_stream;
std::string config_name = "domain_part_";
domain_config_stream << config_name << part_index;
OPENDDS_STRING config;
config = domain_config_stream.str().c_str();
TheTransportRegistry->bind_config(config, *part);
}
if (ts->register_type(part->in(), "") != DDS::RETCODE_OK) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l main()")
ACE_TEXT(" ERROR: register_type() failed!\n")), -1);
}
// Create Topic (Movie Discussion List)
DDS::Topic_var topic =
(*part)->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 Subscriber
DDS::Subscriber_var sub =
(*part)->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("%N:%l main()")
ACE_TEXT(" ERROR: create_subscriber() failed!\n")), -1);
}
DDS::DataReaderQos qos;
sub->get_default_datareader_qos(qos);
qos.liveliness.kind = DDS::AUTOMATIC_LIVELINESS_QOS;
qos.liveliness.lease_duration.sec = 10;
qos.liveliness.lease_duration.nanosec = 0;
qos.history.kind = DDS::KEEP_ALL_HISTORY_QOS;
if (options.reliable) {
qos.reliability.kind = DDS::RELIABLE_RELIABILITY_QOS;
}
for (unsigned int reader = 0; reader < options.num_readers; ++reader) {
ACE_DEBUG((LM_DEBUG, ACE_TEXT("%T (%P|%t) Creating reader\n")));
// Create DataReader
listener_servants.push_back(new DataReaderListenerImpl(options, pid, part_index, reader));
listeners.push_back(DDS::DataReaderListener_var(listener_servants.back()));
DDS::DataReader_var data_reader =
sub->create_datareader(topic.in(),
qos,
listeners.back().in(),
OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil(data_reader.in())) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l main()")
ACE_TEXT(" ERROR: create_datareader() failed!\n")), -1);
}
}
}
const unsigned int sleep_delay_msec = 500;
unsigned int delay = 0;
while (delay < options.total_duration_msec) {
bool complete = true;
for (ListenerServants::const_iterator listener = listener_servants.begin();
listener != listener_servants.end();
++listener) {
if (!(*listener)->done()) {
complete = false;
}
}
if (complete)
break;
delay += sleep_delay_msec;
ACE_OS::sleep(ACE_Time_Value(0, sleep_delay_msec * 1000));
}
ACE_DEBUG((LM_DEBUG, ACE_TEXT("%T (%P|%t) Listeners done (ran for %d msec)\n"), delay));
if (delay >= options.total_duration_msec) {
for (ListenerServants::const_iterator listener = listener_servants.begin();
listener != listener_servants.end();
++listener) {
(*listener)->report_errors();
}
if (options.reliable) {
ok = false;
}
}
// Clean-up!
for (Participants::iterator part = participants.begin();
part != participants.end();
++part) {
(*part)->delete_contained_entities();
dpf->delete_participant(*part);
}
TheServiceParticipant->shutdown();
ACE_Thread_Manager::instance()->wait();
} catch (const CORBA::Exception& e) {
e._tao_print_exception("Exception caught in main():");
return -1;
} catch (const OpenDDS::DCPS::Transport::Exception&) {
ACE_DEBUG((LM_ERROR, "Transport exception caught in subscriber main\n"));
return -1;
}
ACE_DEBUG((LM_DEBUG, ACE_TEXT("%T (%P|%t) Subscriber exiting\n")));
return ok ? EXIT_SUCCESS : EXIT_FAILURE;
}
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());
if (!listener_servant) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l main()")
ACE_TEXT(" ERROR: listener_servant is nil (dynamic_cast failed)!\n")), -1);
}
// 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[])
{
int status = EXIT_SUCCESS;
try {
// Initialize DomainParticipantFactory
DDS::DomainParticipantFactory_var dpf =
TheParticipantFactoryWithArgs(argc, argv);
// handle test performance issue on one platform
#if defined (sun)
const char* udpTransName = "udp";
OpenDDS::DCPS::TransportInst_rch inst = OpenDDS::DCPS::TransportRegistry::instance()->get_inst(udpTransName);
if (inst != 0) {
OpenDDS::DCPS::UdpInst_rch udp_inst = OpenDDS::DCPS::dynamic_rchandle_cast<OpenDDS::DCPS::UdpInst>(inst);
if (udp_inst == 0) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l main()")
ACE_TEXT(" ERROR: retrieving transport config for: %C failed!\n"),
udpTransName), -1);
}
udp_inst->rcv_buffer_size_ = 0x40000;
}
#endif
// 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 Type (Messenger::Message)
Messenger::MessageTypeSupport_var ts =
new Messenger::MessageTypeSupportImpl();
if (ts->register_type(participant.in(), "") != DDS::RETCODE_OK) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l main()")
ACE_TEXT(" ERROR: register_type() failed!\n")), -1);
}
// Create Topic (Movie Discussion List)
CORBA::String_var type_name = ts->get_type_name();
DDS::Topic_var topic =
participant->create_topic("Movie Discussion List",
type_name.in(),
TOPIC_QOS_DEFAULT,
DDS::TopicListener::_nil(),
OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil(topic.in())) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l main()")
ACE_TEXT(" ERROR: create_topic() failed!\n")), -1);
}
// Create Subscriber
DDS::Subscriber_var sub =
participant->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("%N:%l main()")
ACE_TEXT(" ERROR: create_subscriber() failed!\n")), -1);
}
// Create DataReader
DataReaderListenerImpl* listener_svt = new DataReaderListenerImpl;
DDS::DataReaderListener_var listener(listener_svt);
DDS::DataReaderQos qos;
sub->get_default_datareader_qos(qos);
qos.liveliness.kind = DDS::AUTOMATIC_LIVELINESS_QOS;
qos.liveliness.lease_duration.sec = 10;
qos.liveliness.lease_duration.nanosec = 0;
qos.history.kind = DDS::KEEP_ALL_HISTORY_QOS;
bool reliable = true;
parse_args(argc, argv, reliable);
if (reliable) {
qos.reliability.kind = DDS::RELIABLE_RELIABILITY_QOS;
}
DDS::DataReader_var reader =
sub->create_datareader(topic.in(),
qos,
listener.in(),
OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil(reader.in())) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l main()")
ACE_TEXT(" ERROR: create_datareader() failed!\n")), -1);
}
for (int delay = 0; listener_svt->num_samples() != num_messages_expected
&& delay < 60; ++delay) {
ACE_OS::sleep(1);
}
const long received = listener_svt->num_samples();
const bool data_consistent = listener_svt->data_consistent();
if (reliable && data_consistent && received < num_messages_expected) {
std::cout << "ERROR: data loss (" << received << "/"
<< num_messages_expected << " received)\n";
status = EXIT_FAILURE;
}
else if (!data_consistent) {
status = EXIT_FAILURE;
}
else {
const unsigned int percent = ((num_messages_expected - received) * 100) / num_messages_expected;
std::cout << "data loss == " << percent << "% (" << received << "/"
<< num_messages_expected << " received)\n";
}
// Clean-up!
ACE_DEBUG((LM_DEBUG, "Subscriber delete contained entities\n"));
participant->delete_contained_entities();
ACE_DEBUG((LM_DEBUG, "Subscriber delete participant\n"));
dpf->delete_participant(participant);
ACE_DEBUG((LM_DEBUG, "Subscriber shutdown\n"));
TheServiceParticipant->shutdown();
ACE_DEBUG((LM_DEBUG, "Subscriber wait for thread manager\n"));
ACE_Thread_Manager::instance()->wait();
ACE_DEBUG((LM_DEBUG, "Subscriber vars going out of scope\n"));
} catch (const CORBA::Exception& e) {
e._tao_print_exception("Exception caught in main():");
status = EXIT_FAILURE;
}
ACE_DEBUG((LM_DEBUG, "Subscriber exiting with status=%d\n", status));
return status;
}
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);
std::string participant_id;
std::vector<std::string> readers;
std::vector<std::string> writers;
bool reliable = false;
int total_readers = 0, total_writers = 0;
{
// New scope.
ACE_Arg_Shifter shifter (argc, argv);
while (shifter.is_anything_left ()) {
const ACE_TCHAR* x;
x = shifter.get_the_parameter (ACE_TEXT("-participant"));
if (x != NULL) {
participant_id = ACE_TEXT_ALWAYS_CHAR(x);
}
x = shifter.get_the_parameter (ACE_TEXT("-reader"));
if (x != NULL) {
readers.push_back(ACE_TEXT_ALWAYS_CHAR(x));
}
x = shifter.get_the_parameter (ACE_TEXT("-writer"));
if (x != NULL) {
writers.push_back(ACE_TEXT_ALWAYS_CHAR(x));
}
x = shifter.get_the_parameter (ACE_TEXT("-reliable"));
if (x != NULL) {
reliable = ACE_OS::atoi(x);
}
x = shifter.get_the_parameter (ACE_TEXT("-total_readers"));
if (x != NULL) {
total_readers = ACE_OS::atoi(x);
}
x = shifter.get_the_parameter (ACE_TEXT("-total_writers"));
if (x != NULL) {
total_writers = ACE_OS::atoi(x);
}
shifter.consume_arg ();
}
}
participant_id.resize(12);
// Create DomainParticipant
DDS::DomainParticipantQos dp_qos;
dpf->get_default_participant_qos(dp_qos);
dp_qos.user_data.value.length(6);
dp_qos.user_data.value[0] = fromhex(participant_id, 0);
dp_qos.user_data.value[1] = fromhex(participant_id, 1);
dp_qos.user_data.value[2] = fromhex(participant_id, 2);
dp_qos.user_data.value[3] = fromhex(participant_id, 3);
dp_qos.user_data.value[4] = fromhex(participant_id, 4);
dp_qos.user_data.value[5] = fromhex(participant_id, 5);
DDS::DomainParticipant_var participant =
dpf->create_participant(DOMAIN_ID,
dp_qos,
0,
OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (!participant) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("ERROR: %N:%l: main() -")
ACE_TEXT(" create_participant failed!\n")),
-1);
}
// Register TypeSupport
TestMsgTypeSupport_var ts =
new TestMsgTypeSupportImpl;
if (ts->register_type(participant, "") != DDS::RETCODE_OK) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("ERROR: %N:%l: main() -")
ACE_TEXT(" register_type failed!\n")),
-1);
}
// Create Topic
CORBA::String_var type_name = ts->get_type_name();
DDS::Topic_var topic =
participant->create_topic("TheTopic",
type_name,
TOPIC_QOS_DEFAULT,
0,
OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (!topic) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("ERROR: %N:%l: main() -")
ACE_TEXT(" create_topic failed!\n")),
-1);
}
// Create Subscriber
DDS::Subscriber_var subscriber =
participant->create_subscriber(SUBSCRIBER_QOS_DEFAULT,
0,
OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (!subscriber) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("ERROR: %N:%l: main() -")
ACE_TEXT(" create_subscriber failed!\n")), -1);
}
const int n_msgs = reliable ? MSGS_PER_WRITER * total_writers : 0;
// Create DataReaders
for (std::vector<std::string>::iterator pos = readers.begin(), limit = readers.end();
pos != limit;
++pos) {
pos->resize(6);
DDS::DataReaderListener_var listener(new DataReaderListenerImpl(*pos, n_msgs, reader_done_callback));
DDS::DataReaderQos qos;
subscriber->get_default_datareader_qos(qos);
qos.user_data.value.length(3);
qos.user_data.value[0] = fromhex(*pos, 0);
qos.user_data.value[1] = fromhex(*pos, 1);
qos.user_data.value[2] = fromhex(*pos, 2);
qos.reliability.kind = reliable ? DDS::RELIABLE_RELIABILITY_QOS : DDS::BEST_EFFORT_RELIABILITY_QOS;
DDS::DataReader_var reader =
subscriber->create_datareader(topic,
qos,
listener,
OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (!reader) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("ERROR: %N:%l: main() -")
ACE_TEXT(" create_datareader failed!\n")), -1);
}
TestMsgDataReader_var reader_i =
TestMsgDataReader::_narrow(reader);
if (!reader_i) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("ERROR: %N:%l: main() -")
ACE_TEXT(" _narrow failed!\n")),
-1);
}
}
WriterTask task(writers, participant, topic, reliable, total_readers);
task.activate(DEFAULT_FLAGS, writers.size());
task.wait();
if (!reliable)
ACE_OS::sleep(10);
else {
ACE_Guard<ACE_Thread_Mutex> g(readers_done_lock);
while (readers_done != static_cast<int>(readers.size()))
readers_done_cond.wait();
// Sleep allows an ACKNACK to be generated.
ACE_OS::sleep(3);
}
// Clean-up!
participant->delete_contained_entities();
dpf->delete_participant(participant);
TheServiceParticipant->shutdown();
} catch (const CORBA::Exception& e) {
e._tao_print_exception("Exception caught in main():");
return -1;
}
return 0;
}
int main (int argc, char *argv[])
{
int status = 0;
try
{
ACE_DEBUG((LM_INFO," %P|%t %T subscriber 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.
status = parse_args (argc, argv);
if (status)
return status;
::DDS::DomainParticipant_var dp =
dpf->create_participant(TEST_DOMAIN,
PARTICIPANT_QOS_DEFAULT,
::DDS::DomainParticipantListener::_nil());
if (CORBA::is_nil (dp.in ()))
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT(" %P|%t ERROR: create_participant failed.\n")));
return 1 ;
}
// Register the type supports
switch (DATA_SIZE)
{
case 128:
{
::Xyz::Pt128TypeSupportImpl* pt128ts_servant = new ::Xyz::Pt128TypeSupportImpl();
TAO::DCPS::LocalObject_var safe_servant = pt128ts_servant;
::Xyz::Pt128TypeSupport_var pt128ts =
TAO::DCPS::servant_to_reference (pt128ts_servant);
if (::DDS::RETCODE_OK != pt128ts->register_type(dp.in (), TEST_TYPE))
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT (" %P|%t ERROR: Failed to register the Pt128TypeSupport.")));
return 1;
}
}
break;
case 512:
{
::Xyz::Pt512TypeSupportImpl* pt512ts_servant = new ::Xyz::Pt512TypeSupportImpl();
TAO::DCPS::LocalObject_var safe_servant = pt512ts_servant;
::Xyz::Pt512TypeSupport_var pt512ts =
TAO::DCPS::servant_to_reference (pt512ts_servant);
if (::DDS::RETCODE_OK != pt512ts->register_type(dp.in (), TEST_TYPE))
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT (" %P|%t ERROR:Failed to register the Pt512TypeSupport.")));
return 1;
}
}
break;
case 2048:
{
::Xyz::Pt2048TypeSupportImpl* pt2048ts_servant = new ::Xyz::Pt2048TypeSupportImpl();
TAO::DCPS::LocalObject_var safe_servant = pt2048ts_servant;
::Xyz::Pt2048TypeSupport_var pt2048ts =
TAO::DCPS::servant_to_reference (pt2048ts_servant);
if (::DDS::RETCODE_OK != pt2048ts->register_type(dp.in (), TEST_TYPE))
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT (" %P|%t ERROR: Failed to register the Pt2048TypeSupport.")));
return 1;
}
}
break;
case 8192:
{
::Xyz::Pt8192TypeSupportImpl* pt8192ts_servant = new ::Xyz::Pt8192TypeSupportImpl();
TAO::DCPS::LocalObject_var safe_servant = pt8192ts_servant;
::Xyz::Pt8192TypeSupport_var pt8192ts =
TAO::DCPS::servant_to_reference (pt8192ts_servant);
if (::DDS::RETCODE_OK != pt8192ts->register_type(dp.in (), TEST_TYPE))
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT (" %P|%t ERROR: Failed to register the Pt8192TypeSupport.")));
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.resource_limits.max_instances = MAX_INSTANCES;
topic_qos.resource_limits.max_samples = MAX_SAMPLES;
topic_qos.history.kind = ::DDS::KEEP_ALL_HISTORY_QOS;
::DDS::Topic_var topic =
dp->create_topic (TEST_TOPIC,
TEST_TYPE,
topic_qos,
::DDS::TopicListener::_nil());
if (CORBA::is_nil (topic.in ()))
{
return 1 ;
}
::DDS::TopicDescription_var description =
dp->lookup_topicdescription(TEST_TOPIC);
if (CORBA::is_nil (description.in() ))
{
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT(" %P|%t ERROR: lookup_topicdescription failed.\n")),
1);
}
// Create the subscriber
::DDS::Subscriber_var sub =
dp->create_subscriber(SUBSCRIBER_QOS_DEFAULT,
::DDS::SubscriberListener::_nil());
if (CORBA::is_nil (sub.in() ))
{
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT(" %P|%t ERROR: create_subscriber failed.\n")),
1);
}
// Initialize the transport
if (0 != ::init_reader_tranport() )
{
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT(" %P|%t ERROR: init_transport failed!\n")),
1);
}
// Attach the subscriber to the transport.
TAO::DCPS::SubscriberImpl* sub_impl
= TAO::DCPS::reference_to_servant<TAO::DCPS::SubscriberImpl>(sub.in());
if (0 == sub_impl)
{
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT(" %P|%t ERROR: Failed to obtain servant ::TAO::DCPS::SubscriberImpl\n")),
1);
}
TAO::DCPS::AttachStatus attach_status =
sub_impl->attach_transport(reader_transport_impl.in());
if (attach_status != TAO::DCPS::ATTACH_OK)
{
// We failed to attach to the transport for some reason.
const char* status_str = "";
switch (attach_status)
{
case TAO::DCPS::ATTACH_BAD_TRANSPORT:
status_str = "ATTACH_BAD_TRANSPORT";
break;
case TAO::DCPS::ATTACH_ERROR:
status_str = "ATTACH_ERROR";
break;
case TAO::DCPS::ATTACH_INCOMPATIBLE_QOS:
status_str = "ATTACH_INCOMPATIBLE_QOS";
break;
default:
status_str = "Unknown Status";
break;
}
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT(" %P|%t ERROR: Failed to attach to the transport. ")
ACE_TEXT("AttachStatus == %s\n"),
status_str),
1);
}
// Create the Datareader
::DDS::DataReaderQos dr_qos;
sub->get_default_datareader_qos (dr_qos);
sub->copy_from_topic_qos (dr_qos, topic_qos);
DataReaderListenerImpl* dr_listener_impl =
new DataReaderListenerImpl(num_datawriters,
NUM_SAMPLES,
DATA_SIZE,
RECVS_BTWN_READS);
TAO::DCPS::LocalObject_var safe_servant = dr_listener_impl;
::DDS::DataReaderListener_var dr_listener =
TAO::DCPS::servant_to_reference (dr_listener_impl);
if (CORBA::is_nil (dr_listener.in()))
{
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT(" %P|%t ERROR: get listener reference failed.\n")),
1);
}
::DDS::DataReader_var the_dr
= sub->create_datareader(description.in() ,
dr_qos,
dr_listener.in());
if (CORBA::is_nil (the_dr.in() ))
{
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT(" %P|%t ERROR: create_datareader failed.\n")),
1);
}
while (! dr_listener_impl->is_finished ())
{
ACE_OS::sleep(2);
}
// Wait for the publisher to finish sending the end messages
ACE_OS::sleep(2);
// clean up subscriber objects
sub->delete_contained_entities() ;
dp->delete_subscriber(sub.in());
dp->delete_topic(topic.in ());
dpf->delete_participant(dp.in ());
TheTransportFactory->release();
TheServiceParticipant->shutdown ();
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Exception caught in main.cpp:");
return 1;
}
// Note: The TransportImpl reference SHOULD be deleted before exit from
// main if the concrete transport libraries are loaded dynamically.
// Otherwise cleanup after main() will encount access vilation.
reader_transport_impl = 0;
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: -s1 -s2 -s3 -s4 -s5 -p6 -p7\n")));
return 1;
}
::T1::Foo1TypeSupport_var fts1;
::T4::Foo4TypeSupport_var fts4;
if (topics & (TOPIC_T1 | TOPIC_T3 | TOPIC_T4| TOPIC_T5)) {
fts1 = new ::T1::Foo1TypeSupportImpl;
}
if (topics & TOPIC_T2) {
fts4 = new ::T4::Foo4TypeSupportImpl;
}
::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)) {
ACE_ERROR((LM_ERROR,
ACE_TEXT("(%P|%t) create_participant failed.\n")));
return 1;
}
if (topics & (TOPIC_T1 | TOPIC_T3 | TOPIC_T4 | TOPIC_T5)) {
if (::DDS::RETCODE_OK != fts1->register_type(dp, MY_TYPE1)) {
ACE_ERROR((LM_ERROR,
ACE_TEXT("Failed to register the Foo1TypeSupport.")));
return 1;
}
}
if (topics & TOPIC_T2) {
if (::DDS::RETCODE_OK != fts4->register_type(dp, MY_TYPE4)) {
ACE_ERROR((LM_ERROR,
ACE_TEXT("Failed to register the Foo4TypeSupport.")));
return 1;
}
}
::DDS::Topic_var topic1;
::DDS::Topic_var topic2;
::DDS::Topic_var topic3;
::DDS::Topic_var topic4;
::DDS::Topic_var topic5;
::DDS::Topic_var topic6;
::DDS::Topic_var topic7;
if (topics & TOPIC_T1) {
topic1 = dp->create_topic(MY_TOPIC1, MY_TYPE1, TOPIC_QOS_DEFAULT,
::DDS::TopicListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil(topic1)) {
return 1;
}
}
if (topics & TOPIC_T2) {
topic2 = dp->create_topic(MY_TOPIC2, MY_TYPE4, TOPIC_QOS_DEFAULT,
::DDS::TopicListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil(topic2)) {
return 1;
}
}
if (topics & TOPIC_T3) {
topic3 = dp->create_topic(MY_TOPIC3, MY_TYPE1, TOPIC_QOS_DEFAULT,
::DDS::TopicListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil(topic3)) {
return 1;
}
}
if (topics & TOPIC_T4) {
topic4 = dp->create_topic(MY_TOPIC4, MY_TYPE1, TOPIC_QOS_DEFAULT,
::DDS::TopicListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil(topic4)) {
return 1;
}
}
if (topics & TOPIC_T5) {
topic5 = dp->create_topic(MY_TOPIC5, MY_TYPE1, TOPIC_QOS_DEFAULT,
::DDS::TopicListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil(topic5)) {
return 1;
}
}
if (publish_topics & TOPIC_T6) {
topic6 = dp->create_topic(MY_TOPIC6, MY_TYPE1, TOPIC_QOS_DEFAULT,
::DDS::TopicListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil(topic6)) {
return 1;
}
}
if (publish_topics & TOPIC_T7) {
topic7 = dp->create_topic(MY_TOPIC7, MY_TYPE1, TOPIC_QOS_DEFAULT,
::DDS::TopicListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil(topic7)) {
return 1;
}
}
////////////////////////////////////////////////////////////////////////////
// Create the publisher and datawriter
////////////////////////////////////////////////////////////////////////////
::DDS::Publisher_var pub =
dp->create_publisher(PUBLISHER_QOS_DEFAULT,
::DDS::PublisherListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil(pub)) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("(%P|%t) create_publisher failed.\n")),
1);
}
::DDS::DataWriterQos dw_qos;
pub->get_default_datawriter_qos(dw_qos);
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;
int num_writers(0);
::DDS::DataWriter_var dw1;
::DDS::DataWriter_var dw2;
if (publish_topics & TOPIC_T6) {
dw1 = pub->create_datawriter(topic6, dw_qos,
::DDS::DataWriterListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil(dw1)) {
ACE_ERROR((LM_ERROR, ACE_TEXT("(%P|%t) create_datawriter failed.\n")));
return 1;
}
++num_writers;
}
if (publish_topics & TOPIC_T7) {
dw2 = pub->create_datawriter(topic7, dw_qos,
::DDS::DataWriterListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil(dw2)) {
ACE_ERROR((LM_ERROR, ACE_TEXT("(%P|%t) create_datawriter failed.\n")));
return 1;
}
++num_writers;
}
Writer** writers = new Writer*[num_writers];
int idx(0);
if (publish_topics & TOPIC_T6) {
writers[idx++] = new Writer(dw1, 1, num_ops_per_thread);
}
if (publish_topics & TOPIC_T7) {
writers[idx++] = new Writer(dw2, 1, num_ops_per_thread);
}
for (int i = 0; i < num_writers; ++i) {
writers[i]->start();
}
////////////////////////////////////////////////////////////////////////////
// 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)) {
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.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;
dr_qos.reliability.kind = DDS::RELIABLE_RELIABILITY_QOS;
::DDS::DataReader_var dr1;
::DDS::DataReader_var dr2_1;
::DDS::DataReader_var dr2_2;
::DDS::DataReader_var dr2_3;
::DDS::DataReader_var dr3;
::DDS::DataReader_var dr4;
::DDS::DataReader_var dr5;
::DDS::DataReaderListener_var drl1 =
new DataReaderListenerImpl1(num_ops_per_thread);
::DDS::DataReaderListener_var drl2_1 =
new DataReaderListenerImpl4(num_ops_per_thread);
::DDS::DataReaderListener_var drl2_2 =
new DataReaderListenerImpl4(num_ops_per_thread);
::DDS::DataReaderListener_var drl2_3 =
new DataReaderListenerImpl4(num_ops_per_thread);
::DDS::DataReaderListener_var drl3 =
new DataReaderListenerImpl1(num_ops_per_thread);
::DDS::DataReaderListener_var drl4 =
new DataReaderListenerImpl1(num_ops_per_thread);
::DDS::DataReaderListener_var drl5 =
new DataReaderListenerImpl1(num_ops_per_thread);
if (topics & TOPIC_T1) {
dr1 = sub->create_datareader(topic1, dr_qos, drl1,
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
}
if (topics & TOPIC_T2) {
dr2_1 = sub->create_datareader(topic2, dr_qos, drl2_1,
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
dr2_2 = sub->create_datareader(topic2, dr_qos, drl2_2,
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
dr2_3 = sub->create_datareader(topic2, dr_qos, drl2_3,
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
}
if (topics & TOPIC_T3) {
dr3 = sub->create_datareader(topic3, dr_qos, drl3,
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
}
if (topics & TOPIC_T4) {
dr4 = sub->create_datareader(topic4, dr_qos, drl4,
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
}
if (topics & TOPIC_T5) {
dr5 = sub->create_datareader(topic5, dr_qos, drl5,
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
}
if (topics & TOPIC_T1) {
const DataReaderListenerImpl* const drl_servant =
dynamic_cast<const DataReaderListenerImpl*>(drl1.in());
if (!check_listener(drl_servant, num_ops_per_thread, ACE_TEXT(MY_TOPIC1)))
status = 1;
}
if (topics & TOPIC_T2) {
const DataReaderListenerImpl* const drl2_1srv =
dynamic_cast<const DataReaderListenerImpl*>(drl2_1.in());
if (!check_listener(drl2_1srv, num_ops_per_thread, ACE_TEXT(MY_TOPIC2)))
status = 1;
const DataReaderListenerImpl* const drl2_2srv =
dynamic_cast<const DataReaderListenerImpl*>(drl2_2.in());
if (!check_listener(drl2_2srv, num_ops_per_thread, ACE_TEXT(MY_TOPIC2)))
status = 1;
const DataReaderListenerImpl* const drl2_3srv =
dynamic_cast<const DataReaderListenerImpl*>(drl2_3.in());
if (!check_listener(drl2_3srv, num_ops_per_thread, ACE_TEXT(MY_TOPIC2)))
status = 1;
}
if (topics & TOPIC_T3) {
const DataReaderListenerImpl* const drl_servant =
dynamic_cast<const DataReaderListenerImpl*>(drl3.in());
if (!check_listener(drl_servant, num_ops_per_thread, ACE_TEXT(MY_TOPIC3)))
status = 1;
}
if (topics & TOPIC_T4) {
const DataReaderListenerImpl* const drl_servant =
dynamic_cast<const DataReaderListenerImpl*>(drl4.in());
if (!check_listener(drl_servant, num_ops_per_thread, ACE_TEXT(MY_TOPIC4)))
status = 1;
}
if (topics & TOPIC_T5) {
const DataReaderListenerImpl* const drl_servant =
dynamic_cast<const DataReaderListenerImpl*>(drl5.in());
if (!check_listener(drl_servant, num_ops_per_thread, ACE_TEXT(MY_TOPIC5)))
status = 1;
}
if (topics & TOPIC_T1) {
wait_for_file(ACE_TEXT(MY_TOPIC1), pub_finished_filename);
}
if (topics & TOPIC_T2) {
wait_for_file(ACE_TEXT(MY_TOPIC2), pub_finished_filename);
}
if (topics & TOPIC_T3) {
wait_for_file(ACE_TEXT(MY_TOPIC3), pub_finished_filename);
}
if (topics & TOPIC_T4) {
wait_for_file(ACE_TEXT(MY_TOPIC4), pub_finished_filename);
}
if (topics & TOPIC_T5) {
wait_for_file(ACE_TEXT(MY_TOPIC5), pub_finished_filename);
}
if (publish_topics) {
bool writers_finished = false;
while (!writers_finished && num_writers) {
writers_finished = true;
for (int m = 0; m < num_writers; m++) {
writers_finished = writers_finished && writers[m]->is_finished();
}
if (!writers_finished) ACE_OS::sleep(small_time);
}
}
if (publish_topics & TOPIC_T6) {
ACE_TString t6_filename = ACE_TEXT(MY_TOPIC6) + pub_finished_filename;
FILE* writers_completed =
ACE_OS::fopen(t6_filename.c_str(), ACE_TEXT("w"));
if (writers_completed == 0) {
ACE_ERROR((LM_ERROR,
ACE_TEXT("(%P|%t) ERROR: Unable to create publisher ")
ACE_TEXT("completed file\n")));
status = 1;
} else {
ACE_OS::fclose(writers_completed);
}
}
if (publish_topics & TOPIC_T7) {
ACE_TString t7_filename = ACE_TEXT(MY_TOPIC7) + pub_finished_filename;
FILE* writers_completed =
ACE_OS::fopen(t7_filename.c_str(), ACE_TEXT("w"));
if (writers_completed == 0) {
ACE_ERROR((LM_ERROR,
ACE_TEXT("(%P|%t) ERROR: Unable to create publisher ")
ACE_TEXT("completed file\n")));
status = 1;
} else {
ACE_OS::fclose(writers_completed);
}
}
ACE_DEBUG((LM_DEBUG, "(%P|%t) delete contained entities on pub\n"));
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);
TheServiceParticipant->shutdown();
} catch (const TestException&) {
ACE_ERROR ((LM_ERROR,
ACE_TEXT("(%P|%t) TestException caught in main.cpp.\n")));
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 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 main (int argc, char *argv[])
{
try
{
::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);
::Mine::FooTypeSupportImpl* fts_servant = new ::Mine::FooTypeSupportImpl();
PortableServer::ServantBase_var safe_servant = fts_servant;
::Mine::FooTypeSupport_var fts =
TAO::DCPS::servant_to_reference (fts_servant);
::DDS::DomainParticipant_var dp =
dpf->create_participant(MY_DOMAIN,
PARTICIPANT_QOS_DEFAULT,
::DDS::DomainParticipantListener::_nil());
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());
if (CORBA::is_nil (topic.in ()))
{
return 1 ;
}
::DDS::Subscriber_var sub =
dp->create_subscriber(SUBSCRIBER_QOS_DEFAULT,
::DDS::SubscriberListener::_nil());
if (CORBA::is_nil (sub.in ()))
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT("(%P|%t) create_subscriber failed.\n")));
return 1 ;
}
// Attach the subscriber to the transport.
::TAO::DCPS::SubscriberImpl* sub_impl
= ::TAO::DCPS::reference_to_servant< ::TAO::DCPS::SubscriberImpl,
::DDS::Subscriber_ptr>
(sub.in ());
if (0 == sub_impl)
{
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT("(%P|%t) Failed to obtain servant ::TAO::DCPS::SubscriberImpl\n")),
1);
}
TAO::DCPS::TransportImpl_rch transport_impl
= TheTransportFactory->create_transport_impl (ALL_TRAFFIC, "SimpleTcp", TAO::DCPS::DONT_AUTO_CONFIG);
TAO::DCPS::TransportConfiguration_rch config
= TheTransportFactory->create_configuration (ALL_TRAFFIC, "SimpleTcp");
if (transport_impl->configure(config.in ()) != 0)
{
ACE_ERROR((LM_ERROR,
"(%P|%t) Failed to configure the transport impl\n"));
return 1 ;
}
TAO::DCPS::AttachStatus status
= sub_impl->attach_transport(transport_impl.in());
if (status != TAO::DCPS::ATTACH_OK)
{
// We failed to attach to the transport for some reason.
ACE_CString status_str;
switch (status)
{
case TAO::DCPS::ATTACH_BAD_TRANSPORT:
status_str = "ATTACH_BAD_TRANSPORT";
break;
case TAO::DCPS::ATTACH_ERROR:
status_str = "ATTACH_ERROR";
break;
case TAO::DCPS::ATTACH_INCOMPATIBLE_QOS:
status_str = "ATTACH_INCOMPATIBLE_QOS";
break;
default:
status_str = "Unknown Status";
break;
}
ACE_ERROR((LM_ERROR,
"(%P|%t) Failed to attach to the transport. "
"AttachStatus == %s\n", status_str.c_str()));
return 1;
}
::DDS::ReturnCode_t ret = ::DDS::RETCODE_OK;
//---------------------------------------------------------------------
// Test Subscriber unit tests
//
::DDS::SubscriberQos sub_qos_got;
sub->get_qos (sub_qos_got);
::DDS::SubscriberQos default_sub_qos;
dp->get_default_subscriber_qos (default_sub_qos);
//The SunOS compiler had problem resolving operator in a namespace.
//To resolve the compilation errors, the operator is called explicitly.
if (! (sub_qos_got == default_sub_qos))
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT("(%P|%t) Subscriber get_default_qos failed.\n")));
return 1 ;
}
::DDS::SubscriberQos new_sub_qos = sub_qos_got;
// This qos is not supported, so it's invalid qos.
new_sub_qos.presentation.access_scope = ::DDS::GROUP_PRESENTATION_QOS;
ret = sub->set_qos (new_sub_qos);
if (ret != ::DDS::RETCODE_INCONSISTENT_POLICY)
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT("(%P|%t) Subscriber set_qos failed.\n")));
return 1 ;
}
::DDS::DomainParticipant_var participant
= sub->get_participant ();
if (dp.in () != participant.in ())
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT("(%P|%t) Subscriber get_participant failed.\n")));
return 1 ;
}
::DDS::DataReaderQos default_dr_qos;
sub->get_default_datareader_qos (default_dr_qos);
::DDS::DataReaderQos new_default_dr_qos = default_dr_qos;
new_default_dr_qos.reliability.kind = ::DDS::RELIABLE_RELIABILITY_QOS;
if (sub->set_default_datareader_qos(new_default_dr_qos) !=
::DDS::RETCODE_OK)
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT("(%P|%t) Subscriber set_default_datareader_qos failed.\n")));
return 1 ;
}
::DDS::TopicDescription_var description =
dp->lookup_topicdescription(MY_TOPIC);
if (CORBA::is_nil (description.in ()))
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT("(%P|%t) lookup_topicdescription failed.\n")));
return 1 ;
}
// Create datareeder to test copy_from_topic_qos.
::DDS::DataReader_var datareader =
sub->create_datareader(description.in (),
DATAREADER_QOS_USE_TOPIC_QOS,
::DDS::DataReaderListener::_nil()) ;
if (CORBA::is_nil (datareader.in ()))
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT("(%P|%t) Subscriber create_datareader failed.\n")));
return 1 ;
}
::DDS::DataReaderQos dr_qos_use_topic_qos;
datareader->get_qos (dr_qos_use_topic_qos);
::DDS::DataReaderQos copied_from_topic;
sub->get_default_datareader_qos(copied_from_topic) ;
ret = sub->copy_from_topic_qos (copied_from_topic, topic_qos);
if (ret != ::DDS::RETCODE_OK)
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT("(%P|%t) Subscriber copy_from_topic_qos failed.\n")));
return 1 ;
}
//The SunOS compiler had problem resolving operator in a namespace.
//To resolve the compilation errors, the operator is called explicitly.
if (!(dr_qos_use_topic_qos == copied_from_topic))
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT("(%P|%t) Subscriber copy_from_topic_qos failed.\n")));
return 1 ;
}
::DDS::TopicDescription_var topic_description_got
= datareader->get_topicdescription ();
if (topic_description_got.in () != description.in ())
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT("(%P|%t) datareader get_topicdescription failed.\n")));
return 1 ;
}
::DDS::Subscriber_var sub_got
= datareader->get_subscriber ();
if (sub_got.in () != sub.in ())
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT("(%P|%t) datareader get_subscriber failed.\n")));
return 1 ;
}
::DDS::DataReaderQos dr_qos_got;
datareader->get_qos (dr_qos_got);
::DDS::DataReaderQos new_dr_qos = dr_qos_got;
new_dr_qos.reliability.kind = ::DDS::RELIABLE_RELIABILITY_QOS;
new_dr_qos.resource_limits.max_samples_per_instance = 2;
new_dr_qos.history.kind = ::DDS::KEEP_ALL_HISTORY_QOS;
ret = datareader->set_qos (new_dr_qos);
if (ret != ::DDS::RETCODE_INCONSISTENT_POLICY)
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT("(%P|%t) datareader set_qos failed.\n")));
return 1 ;
}
// Delete the datareader.
sub->delete_datareader (datareader.in ());
//---------------------------------------------------------------------
::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 ;
::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 ++)
{
drs[i] = sub->create_datareader(description.in (),
dr_qos,
::DDS::DataReaderListener::_nil());
if (CORBA::is_nil (drs[i].in ()))
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT("(%P|%t) create_datareader failed.\n")));
return 1 ;
}
}
Reader** readers = new Reader* [num_datareaders];
Writer** writers = new Writer* [num_datareaders] ;
//---------------------------------------------------------------------
//
// read/take_next_sample
//
{ // make VC6 buid - avoid error C2374: 'i' : redefinition; multiple initialization
// Do the "writes"
for (int i = 0; i < num_datareaders; i ++)
{
writers[i] = new Writer(drs[i].in (),
num_reads_per_thread,
multiple_instances,
i + 1);
writers[i]->start ();
}
}
{ // make VC6 buid - avoid error C2374: 'i' : redefinition; multiple initialization
// now - do the reads
for (int i = 0; i < num_datareaders; i ++)
{
readers[i] = new Reader(drs[i].in (),
use_take,
num_reads_per_thread,
multiple_instances,
i);
readers[i]->start ();
}
}
sub->delete_contained_entities() ;
{ // make VC6 buid - avoid error C2374: 'i' : redefinition; multiple initialization
for (int i = 0; i < num_datareaders; i ++)
{
drs[i] = sub->create_datareader(description.in (),
dr_qos,
::DDS::DataReaderListener::_nil());
if (CORBA::is_nil (drs[i].in ()))
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT("(%P|%t) create_datareader failed.\n")));
return 1 ;
}
}
}
{
for (int i = 0; i < num_datareaders; i ++)
{
delete writers[i];
}
}
{
for (int i = 0; i < num_datareaders; i ++)
{
delete readers[i];
}
}
//---------------------------------------------------------------------
//
// read/take_instance
//
{ // make VC6 buid - avoid error C2374: 'i' : redefinition; multiple initialization
// write again
for (int i = 0; i < num_datareaders; i ++)
{
writers[i] = new Writer(drs[i].in (),
num_reads_per_thread,
multiple_instances,
i + 1);
writers[i]->start ();
}
}
{ // make VC6 buid - avoid error C2374: 'i' : redefinition; multiple initialization
// now - do the reads
for (int i = 0; i < num_datareaders; i ++)
{
readers[i] = new Reader(drs[i].in (),
use_take,
num_reads_per_thread,
multiple_instances,
i);
readers[i]->start1 ();
}
}
sub->delete_contained_entities() ;
{ // make VC6 buid - avoid error C2374: 'i' : redefinition; multiple initialization
for (int i = 0; i < num_datareaders; i ++)
{
drs[i] = sub->create_datareader(description.in (),
dr_qos,
::DDS::DataReaderListener::_nil());
if (CORBA::is_nil (drs[i].in ()))
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT("(%P|%t) create_datareader failed.\n")));
return 1 ;
}
}
}
{
for (int i = 0; i < num_datareaders; i ++)
{
delete writers[i];
}
}
{
for (int i = 0; i < num_datareaders; i ++)
{
delete readers[i];
}
}
//---------------------------------------------------------------------
//
// loan (via read)/return_loan
//
{ // make VC6 buid - avoid error C2374: 'i' : redefinition; multiple initialization
// write again
for (int i = 0; i < num_datareaders; i ++)
{
writers[i] = new Writer(drs[i].in (),
num_reads_per_thread,
0,
i + 1);
writers[i]->start ();
}
}
{ // make VC6 buid - avoid error C2374: 'i' : redefinition; multiple initialization
// now - do the reads
for (int i = 0; i < num_datareaders; i ++)
{
readers[i] = new Reader(drs[i].in (),
0,
num_reads_per_thread,
0,
i);
readers[i]->start2 ();
}
}
delete [] drs;
{
for (int i = 0; i < num_datareaders; i ++)
{
delete writers[i];
}
}
delete [] writers;
{
for (int i = 0; i < num_datareaders; i ++)
{
delete readers[i];
}
}
delete [] readers;
sub->delete_contained_entities() ;
dp->delete_subscriber(sub.in ());
dp->delete_topic(topic.in ());
dpf->delete_participant(dp.in ());
TheTransportFactory->release();
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 0;
}
/**
* @brief Construct a test system from the command line.
*/
Publisher::Publisher( int argc, char** argv, char** envp)
: config_( argc, argv, envp)
{
// Grab a local reference to the factory
ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) INFO: initializing the publisher.\n")));
::DDS::DomainParticipantFactory_var factory = TheParticipantFactoryWithArgs( argc, argv);
if( OpenDDS::DCPS::DCPS_debug_level > 0) {
ACE_DEBUG((LM_DEBUG,
ACE_TEXT("(%P|%t) COMMANDLINE: Verbose == %s\n")
ACE_TEXT("(%P|%t) COMMANDLINE: Samples == %d\n"),
(this->config_.verbose()? "true": "false"),
this->config_.samples()
));
}
//
// Establish DomainParticipant
//
if( OpenDDS::DCPS::DCPS_debug_level > 0) {
ACE_DEBUG((LM_DEBUG,
ACE_TEXT("(%P|%t) INFO: creating publisher participant in domain %d.\n"),
this->config_.domain()
));
}
this->participant_ = factory->create_participant(
this->config_.domain(),
PARTICIPANT_QOS_DEFAULT,
::DDS::DomainParticipantListener::_nil()
);
if( CORBA::is_nil( this->participant_.in())) {
ACE_ERROR ((LM_ERROR,
ACE_TEXT("(%P|%t) ERROR: create_participant failed for ")
ACE_TEXT("publisher in domain %d.\n"),
this->config_.domain()
));
throw BadParticipantException ();
}
//
// Grab and install the transport implementation.
//
// Establish debug level.
if( this->config_.verbose()) {
TURN_ON_VERBOSE_DEBUG;
}
if( OpenDDS::DCPS::DCPS_debug_level > 0) {
ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) INFO: creating a SimpleTCP transport.\n")));
}
this->transport_ = TheTransportFactory->create_transport_impl(
0,
"SimpleTcp",
OpenDDS::DCPS::DONT_AUTO_CONFIG
);
OpenDDS::DCPS::TransportConfiguration_rch transport_config
= TheTransportFactory->create_configuration(
0,
ACE_TString("SimpleTcp")
);
#if 0
OpenDDS::DCPS::SimpleTcpConfiguration* tcp_config
= static_cast <OpenDDS::DCPS::SimpleTcpConfiguration*>( transport_config.in() );
std::string address;
if( address.length() > 0) {
ACE_INET_Addr reader_address( address.c_str());
tcp_config->local_address_ = reader_address;
}
#endif
if( this->transport_->configure( transport_config.in()) != 0) {
ACE_ERROR((LM_ERROR,
ACE_TEXT("(%P|%t) ERROR: TCP ")
ACE_TEXT("failed to configure the transport.\n")
));
throw BadTransportException ();
}
//
// Establish the Type Support for the data
//
if( OpenDDS::DCPS::DCPS_debug_level > 0) {
ACE_DEBUG((LM_DEBUG,
ACE_TEXT("(%P|%t) INFO: Installing type %s support into domain %d.\n"),
this->config_.typeName().c_str(),
this->config_.domain()
));
}
::Xyz::FooNoKeyTypeSupportImpl* publisher_data = new ::Xyz::FooNoKeyTypeSupportImpl();
if(::DDS::RETCODE_OK != publisher_data->register_type(
this->participant_.in(),
this->config_.typeName().c_str()
)
) {
ACE_ERROR((LM_ERROR,
ACE_TEXT("(%P|%t) ERROR: Unable to install type %s support for domain %d.\n"),
this->config_.typeName().c_str(),
this->config_.domain()
));
throw TestException ();
}
//
// Establish the Topic
//
this->topic_ = this->participant_->create_topic(
this->config_.topicName().c_str(),
this->config_.typeName().c_str(),
TOPIC_QOS_DEFAULT,
::DDS::TopicListener::_nil()
);
if( CORBA::is_nil( this->topic_.in()) ) {
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("(%P|%t) ERROR: Failed to create topic %s for publisher.\n"),
this->config_.topicName().c_str()
));
throw BadTopicException ();
}
//
// Establish the Publisher
//
this->publisher_ = this->participant_->create_publisher(
PUBLISHER_QOS_DEFAULT,
::DDS::PublisherListener::_nil()
);
if( CORBA::is_nil (this->publisher_.in ())) {
ACE_ERROR ((LM_ERROR, ACE_TEXT ("(%P|%t) ERROR: Failed to create_publisher.\n")));
throw BadPublisherException ();
}
// Attach the publisher to the transport.
OpenDDS::DCPS::PublisherImpl* pub_impl
= dynamic_cast<OpenDDS::DCPS::PublisherImpl*>(
this->publisher_.in()
);
if (0 == pub_impl) {
ACE_ERROR((LM_ERROR, ACE_TEXT("(%P|%t) ERROR: Failed to obtain publisher servant\n")));
throw BadPublisherException ();
}
OpenDDS::DCPS::AttachStatus attach_status;
if( OpenDDS::DCPS::DCPS_debug_level > 0) {
ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) INFO: attaching publisher to transport \n")));
}
attach_status = pub_impl->attach_transport( this->transport_.in());
if (attach_status != OpenDDS::DCPS::ATTACH_OK) {
// We failed to attach to the transport for some reason.
ACE_TString status_str;
switch (attach_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;
}
ACE_ERROR ((LM_ERROR,
ACE_TEXT("(%P|%t) ERROR: Failed to attach to the transport. ")
ACE_TEXT("AttachStatus == %s\n"),
status_str.c_str()));
throw BadTransportException ();
}
//
// Establish and install the DataWriter.
//
if( OpenDDS::DCPS::DCPS_debug_level > 0) {
ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) INFO: creating datawriter.\n")));
}
//
// Keep all data samples to allow us to establish connections in an
// arbitrary order, with samples being buffered at the first writer
// that has not yet had a subscription match.
//
::DDS::DataWriterQos writerQos;
this->publisher_->get_default_datawriter_qos( writerQos);
writerQos.durability.kind = ::DDS::TRANSIENT_LOCAL_DURABILITY_QOS;
writerQos.history.kind = ::DDS::KEEP_ALL_HISTORY_QOS;
writerQos.resource_limits.max_samples_per_instance = ::DDS::LENGTH_UNLIMITED;
writerQos.reliability.kind = ::DDS::RELIABLE_RELIABILITY_QOS;
writerQos.reliability.max_blocking_time.sec = 0;
writerQos.reliability.max_blocking_time.nanosec = 0;
this->dataWriter_
= this->publisher_->create_datawriter(
this->topic_.in(),
writerQos,
::DDS::DataWriterListener::_nil()
);
if( CORBA::is_nil( this->dataWriter_.in()) ) {
ACE_ERROR((LM_ERROR, ACE_TEXT("(%P|%t) ERROR: create datawriter failed.\n")));
throw BadWriterException ();
}
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
try {
// Initialize DomainParticipantFactory
DDS::DomainParticipantFactory_var dpf =
TheParticipantFactoryWithArgs(argc, argv);
enum {
READER,
WRITER
} mode = READER;
bool toggle = false;
{
// New scope.
ACE_Arg_Shifter shifter (argc, argv);
while (shifter.is_anything_left ()) {
const ACE_TCHAR* x = shifter.get_current();
if (ACE_OS::strcmp(x, ACE_TEXT("-reader")) == 0) {
mode = READER;
}
if (ACE_OS::strcmp(x, ACE_TEXT("-writer")) == 0) {
mode = WRITER;
}
if (ACE_OS::strcmp(x, ACE_TEXT("-toggle")) == 0) {
toggle = true;
}
shifter.consume_arg ();
}
}
// Create DomainParticipant
DDS::DomainParticipantQos dp_qos;
dpf->get_default_participant_qos(dp_qos);
dp_qos.user_data.value.length(6);
dp_qos.user_data.value[0] = 0;
dp_qos.user_data.value[1] = 0;
dp_qos.user_data.value[2] = 0;
dp_qos.user_data.value[3] = 0;
dp_qos.user_data.value[4] = 0;
dp_qos.user_data.value[5] = (mode == READER) ? 0 : 1;
DDS::DomainParticipant_var participant =
dpf->create_participant(DOMAIN_ID,
dp_qos,
0,
OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (!participant) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("ERROR: %N:%l: main() -")
ACE_TEXT(" create_participant failed!\n")),
-1);
}
// Register TypeSupport
TestMsgTypeSupport_var ts =
new TestMsgTypeSupportImpl;
if (ts->register_type(participant, "") != DDS::RETCODE_OK) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("ERROR: %N:%l: main() -")
ACE_TEXT(" register_type failed!\n")),
-1);
}
// Create Topic
CORBA::String_var type_name = ts->get_type_name();
DDS::Topic_var topic =
participant->create_topic("TheTopic",
type_name,
TOPIC_QOS_DEFAULT,
0,
OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (!topic) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("ERROR: %N:%l: main() -")
ACE_TEXT(" create_topic failed!\n")),
-1);
}
int return_code = 1;
switch (mode) {
case READER:
return_code = do_reader(participant, topic, toggle);
break;
case WRITER:
return_code = do_writer(participant, topic, toggle);
break;
}
// Clean-up!
participant->delete_contained_entities();
dpf->delete_participant(participant);
TheServiceParticipant->shutdown();
return return_code;
} catch (const CORBA::Exception& e) {
e._tao_print_exception("Exception caught in main():");
return -1;
}
return 0;
}
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
{
::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);
::DDS::Topic_var topic =
dp->create_topic (MY_TOPIC,
MY_TYPE,
TOPIC_QOS_DEFAULT,
::DDS::TopicListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (topic.in ())) {
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT("(%P|%t) create_topic failed!\n")),
1);
}
OpenDDS::DCPS::TransportImpl_rch writer_transport_impl;
// Initialize the transport
if (0 != ::init_writer_tranport(writer_transport_impl) )
{
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT("(%P|%t) init_transport failed!\n")),
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);
}
// Attach the publisher to the transport.
OpenDDS::DCPS::PublisherImpl* pub_impl
= dynamic_cast<OpenDDS::DCPS::PublisherImpl*> (pub.in ());
if (0 == pub_impl)
{
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT("(%P|%t) Failed to obtain servant ::OpenDDS::DCPS::PublisherImpl\n")),
1);
}
OpenDDS::DCPS::AttachStatus attach_status =
pub_impl->attach_transport(writer_transport_impl.in());
if (attach_status != OpenDDS::DCPS::ATTACH_OK)
{
// We failed to attach to the transport for some reason.
ACE_TString status_str;
switch (attach_status)
{
case OpenDDS::DCPS::ATTACH_BAD_TRANSPORT:
status_str = ACE_TEXT("ATTACH_BAD_TRANSPORT");
break;
case OpenDDS::DCPS::ATTACH_ERROR:
status_str = ACE_TEXT("ATTACH_ERROR");
break;
case OpenDDS::DCPS::ATTACH_INCOMPATIBLE_QOS:
status_str = ACE_TEXT("ATTACH_INCOMPATIBLE_QOS");
break;
default:
status_str = ACE_TEXT("Unknown Status");
break;
}
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT("(%P|%t) Failed to attach to the transport. ")
ACE_TEXT("AttachStatus == %s\n"),
status_str.c_str()),
1);
}
// Create the datawriters
::DDS::DataWriterQos dw_qos;
pub->get_default_datawriter_qos (dw_qos);
dw_qos.durability.kind = durability_kind;
dw_qos.liveliness.kind = liveliness_kind;
dw_qos.liveliness.lease_duration = LEASE_DURATION;
dw_qos.reliability.kind = reliability_kind;
::DDS::DataWriterListener_var dwl (new DataWriterListenerImpl);
::DDS::DataWriter_var dw = pub->create_datawriter(topic.in (),
dw_qos,
dwl.in(),
::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 ;
}
// Writer writer(dw.in ());
// ACE_Time_Value duration(10);
// writer.run_test(duration);
ACE_OS::sleep(test_duration);
// Clean up publisher objects
pub->delete_contained_entities() ;
dp->delete_publisher(pub.in ());
dp->delete_topic(topic.in ());
dpf->delete_participant(dp.in ());
TheTransportFactory->release();
TheServiceParticipant->shutdown ();
{
DataWriterListenerImpl* dwl_servant =
dynamic_cast<DataWriterListenerImpl*>(dwl.in());
// check to see if the publisher worked
if(dwl_servant->publication_matched() != compatible)
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT("(%P|%t) Expected publication_matched to be %C, but it wasn't.")
ACE_TEXT("durability_kind=%s,liveliness_kind=%s,liveliness_duration=%s,")
ACE_TEXT("reliability_kind=%s\n"),
(compatible) ? "true" : "false",
durability_kind_str.c_str(),
liveliness_kind_str.c_str(),
LEASE_DURATION_STR.c_str(),
reliability_kind_str.c_str()));
return 1 ;
}
}
}
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 {
// Initialize DomainParticipantFactory
DDS::DomainParticipantFactory_var dpf =
TheParticipantFactoryWithArgs(argc, argv);
// Create DomainParticipant
DDS::DomainParticipant_var participant =
dpf->create_participant(42,
PARTICIPANT_QOS_DEFAULT,
DDS::DomainParticipantListener::_nil(),
OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil(participant.in())) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("ERROR: %N:%l: main() -")
ACE_TEXT(" create_participant failed!\n")), -1);
}
// Register Type (Messenger::Message)
Messenger::MessageTypeSupport_var ts =
new Messenger::MessageTypeSupportImpl();
if (ts->register_type(participant.in(), "") != DDS::RETCODE_OK) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("ERROR: %N:%l: main() -")
ACE_TEXT(" register_type failed!\n")), -1);
}
// Create Topic (Movie Discussion List)
CORBA::String_var type_name = ts->get_type_name();
DDS::Topic_var topic =
participant->create_topic("Movie Discussion List",
type_name.in(),
TOPIC_QOS_DEFAULT,
DDS::TopicListener::_nil(),
OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil(topic.in())) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("ERROR: %N:%l: main() -")
ACE_TEXT(" create_topic failed!\n")), -1);
}
// Create Subscriber
DDS::Subscriber_var subscriber =
participant->create_subscriber(SUBSCRIBER_QOS_DEFAULT,
DDS::SubscriberListener::_nil(),
OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil(subscriber.in())) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("ERROR: %N:%l: main() -")
ACE_TEXT(" create_subscriber failed!\n")), -1);
}
// Create DataReader
DDS::DataReaderListener_var listener(new DataReaderListenerImpl);
DDS::DataReader_var reader =
subscriber->create_datareader(topic.in(),
DATAREADER_QOS_DEFAULT,
listener.in(),
OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil(reader.in())) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("ERROR: %N:%l: main() -")
ACE_TEXT(" create_datareader failed!\n")), -1);
}
Messenger::MessageDataReader_var reader_i =
Messenger::MessageDataReader::_narrow(reader);
if (CORBA::is_nil(reader_i.in())) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("ERROR: %N:%l: main() -")
ACE_TEXT(" _narrow failed!\n")),
-1);
}
// Block until Publisher completes
DDS::StatusCondition_var condition = reader->get_statuscondition();
condition->set_enabled_statuses(DDS::SUBSCRIPTION_MATCHED_STATUS);
DDS::WaitSet_var ws = new DDS::WaitSet;
ws->attach_condition(condition);
DDS::ConditionSeq conditions;
DDS::SubscriptionMatchedStatus matches = { 0, 0, 0, 0, 0 };
DDS::Duration_t timeout = { 30, 0 }; // 30 seconds
do {
if (ws->wait(conditions, timeout) != DDS::RETCODE_OK) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("ERROR: %N:%l: main() -")
ACE_TEXT(" wait failed!\n")), -1);
}
if (reader->get_subscription_matched_status(matches) != DDS::RETCODE_OK) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("ERROR: %N:%l: main() -")
ACE_TEXT(" get_subscription_matched_status() failed!\n")), -1);
}
} while (matches.current_count > 0);
ws->detach_condition(condition);
// Clean-up!
participant->delete_contained_entities();
dpf->delete_participant(participant.in());
TheServiceParticipant->shutdown();
} catch (const CORBA::Exception& e) {
e._tao_print_exception("Exception caught in main():");
return -1;
}
return 0;
}
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);
::DDS::DomainParticipant_var dp =
dpf->create_participant(TEST_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) ERROR: create_participant failed.\n")));
return 1 ;
}
::Xyz::Pt128TypeSupport_var pt128ts;
::Xyz::Pt512TypeSupport_var pt512ts;
::Xyz::Pt2048TypeSupport_var pt2048ts;
::Xyz::Pt8192TypeSupport_var pt8192ts;
// Register the type supports
switch (1 << DATA_SIZE)
{
case 128:
{
pt128ts = new ::Xyz::Pt128TypeSupportImpl();
if (::DDS::RETCODE_OK != pt128ts->register_type(dp.in (), TEST_TYPE))
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("(%P|%t) ERROR: Failed to register the Pt128TypeSupport.")));
return 1;
}
}
break;
case 512:
{
pt512ts = new ::Xyz::Pt512TypeSupportImpl();
if (::DDS::RETCODE_OK != pt512ts->register_type(dp.in (), TEST_TYPE))
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("(%P|%t) ERROR: Failed to register the Pt512TypeSupport.")));
return 1;
}
}
break;
case 2048:
{
pt2048ts = new ::Xyz::Pt2048TypeSupportImpl();
if (::DDS::RETCODE_OK != pt2048ts->register_type(dp.in (), TEST_TYPE))
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("(%P|%t) ERROR: Failed to register the Pt2048TypeSupport.")));
return 1;
}
}
break;
case 8192:
{
pt8192ts = new ::Xyz::Pt8192TypeSupportImpl();
if (::DDS::RETCODE_OK != pt8192ts->register_type(dp.in (), TEST_TYPE))
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("(%P|%t) ERROR: Failed to register the Pt8192TypeSupport.")));
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.resource_limits.max_instances = MAX_INSTANCES;
topic_qos.resource_limits.max_samples = MAX_SAMPLES;
topic_qos.history.kind = ::DDS::KEEP_ALL_HISTORY_QOS;
::DDS::Topic_var topic =
dp->create_topic (TEST_TOPIC,
TEST_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) ERROR: create_publisher failed.\n")),
1);
}
// Create the datawriters
::DDS::DataWriterQos dw_qos;
pub->get_default_datawriter_qos (dw_qos);
pub->copy_from_topic_qos (dw_qos, topic_qos);
::DDS::DataWriter_var * dws = new ::DDS::DataWriter_var[num_datawriters];
// Create one or multiple datawriters belonging to the same
// publisher.
for (int k = 0; k < num_datawriters; k ++)
{
dws[k] = pub->create_datawriter(topic.in (),
dw_qos,
::DDS::DataWriterListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (dws[k].in ()))
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT("(%P|%t) ERROR: create_datawriter failed.\n")));
return 1 ;
}
}
Writer** writers = new Writer* [num_datawriters] ;
for (int p = 0; p < num_datawriters; p ++)
{
writers[p] = new Writer(dws[p].in (),
NUM_SAMPLES,
DATA_SIZE,
id + p,
num_datareaders,
throttle_factor);
writers[p]->start ();
}
bool writers_finished = false;
while ( !writers_finished )
{
writers_finished = true;
for (int m = 0; m < num_datawriters; m ++)
{
writers_finished = writers_finished && writers[m]->is_finished();
}
}
ACE_OS::sleep(10);
// Clean up publisher objects
pub->delete_contained_entities() ;
delete [] dws;
delete [] writers;
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) ERROR: 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
main (int argc, char *argv[])
{
if (parse_args (argc, argv) != 0)
{
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("(%P|%t) Failed to parse the arguments!\n")),
1);
}
try
{
// --
// Check the Service_Participant
// --
::DDS::DomainParticipantFactory_var dpFactory;
::DDS::DomainParticipantFactory_var dpFactory_noargs;
dpFactory = TheParticipantFactoryWithArgs(argc, argv);
if ( CORBA::is_nil (dpFactory.in()) )
{
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("(%P|%t) Nil DomainParticipantFactory returned!\n")),
2);
}
dpFactory_noargs = TheParticipantFactory;
if ( CORBA::is_nil (dpFactory_noargs.in()) )
{
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("(%P|%t) Nil DomainParticipantFactory returned when no args given!\n")),
2);
}
if (dpFactory.in() != dpFactory_noargs.in() )
{
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("(%P|%t) Different DomainParticipantFactories returned!\n")),
2);
}
// --
// Check the DomainParticipantFactory
// --
TAO_DCPS_DomainParticipantListener_i* dpListenerImpl = new TAO_DCPS_DomainParticipantListener_i;
PortableServer::ServantBase_var safe_dpListenerImpl = dpListenerImpl;
::DDS::DomainParticipantListener_var dpListener =
::TAO::DCPS::servant_to_reference (dpListenerImpl);
if ( CORBA::is_nil (dpListener.in()) )
{
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("(%P|%t) Nil DomainParticipantListener returned!\n")),
3);
}
::DDS::DomainParticipantQos dPQosInitialDefault;
dpFactory->get_default_participant_qos (dPQosInitialDefault);
// change the Entity Factory's auto enable value
::DDS::DomainParticipantQos dPQosChangedEntityFactory;
dPQosChangedEntityFactory.entity_factory.autoenable_created_entities =
! dPQosInitialDefault.entity_factory.autoenable_created_entities;
::DDS::ReturnCode_t setFactoryReturnCode =
dpFactory->set_default_participant_qos(dPQosChangedEntityFactory);
if (::DDS::RETCODE_INCONSISTENT_POLICY != setFactoryReturnCode)
{
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("(%P|%t) Was able to set invalid default Participant QOS!\n")),
3);
}
::DDS::DomainParticipantQos dPQosNewDefault;
dpFactory->get_default_participant_qos (dPQosNewDefault);
if (dPQosNewDefault.entity_factory.autoenable_created_entities
!= dPQosInitialDefault.entity_factory.autoenable_created_entities)
{
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("(%P|%t) Incorrect default Participant QOS was returned in the get!\n")),
3);
}
::DDS::DomainParticipant_var testParticipant;
// Try to create a participant with a bad QOS
testParticipant =
dpFactory->create_participant(TEST_DOMAIN_NUMBER,
dPQosChangedEntityFactory,
dpListener.in());
if ( ! CORBA::is_nil (testParticipant.in ()) )
{
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("(%P|%t) Invalid QOS returned a DomainParticipant!\n")),
4);
}
::DDS::ReturnCode_t deleteParticipantReturnCode =
dpFactory->delete_participant(testParticipant.in ());
if (::DDS::RETCODE_BAD_PARAMETER != deleteParticipantReturnCode)
{
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("(%P|%t) Invalid Participant was deleted!\n")),
4);
}
testParticipant =
dpFactory->create_participant(TEST_DOMAIN_NUMBER,
PARTICIPANT_QOS_DEFAULT,
dpListener.in());
if ( CORBA::is_nil (testParticipant.in ()) )
{
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("(%P|%t) Nil DomainParticipant returned!\n")),
5);
}
deleteParticipantReturnCode =
dpFactory->delete_participant(testParticipant.in ());
if (::DDS::RETCODE_OK != deleteParticipantReturnCode)
{
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("(%P|%t) Valid Participant was not deleted!\n")),
5);
}
/* Cant do the below because the delete_participant doesnt handle it
deleteParticipantReturnCode =
dpFactory->delete_participant(testParticipant.in ());
if (::DDS::RETCODE_BAD_PARAMETER != deleteParticipantReturnCode)
{
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("(%P|%t) Participant was deleted twice!\n")),
5);
}
*/
::DDS::DomainParticipantFactory_var firstInstance =
dpFactory->get_instance();
if ( CORBA::is_nil (firstInstance.in ()) )
{
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("(%P|%t) Nil DomainParticipantFactory returned on first call!\n")),
6);
}
::DDS::DomainParticipantFactory_var secondInstance =
dpFactory->get_instance();
if ( CORBA::is_nil (secondInstance.in ()) )
{
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("(%P|%t) Nil DomainParticipantFactory returned on second call!\n")),
6);
}
if (firstInstance.in() != secondInstance.in())
{
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("(%P|%t) DomainParticipantFactory instances don't match!\n")),
6);
}
// --
// Check the DomainParticipant
// --
::DDS::DomainParticipant_var participant;
participant =
dpFactory->create_participant(TEST_DOMAIN_NUMBER,
PARTICIPANT_QOS_DEFAULT,
dpListener.in());
if ( CORBA::is_nil (participant.in ()) )
{
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("(%P|%t) Nil DomainParticipant returned in DomainParticipant test!\n")),
7);
}
::DDS::DomainParticipantQos participantInitialQOS;
participant->get_qos(participantInitialQOS);
if (participantInitialQOS.entity_factory.autoenable_created_entities
!= dPQosInitialDefault.entity_factory.autoenable_created_entities)
{
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("(%P|%t) Participant has incorrect QOS!\n")),
7);
}
::DDS::ReturnCode_t setQosReturnCode =
participant->set_qos(dPQosChangedEntityFactory);
if (::DDS::RETCODE_INCONSISTENT_POLICY != setQosReturnCode)
{
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("(%P|%t) Was able to set invalid Participant QOS!\n")),
7);
}
::DDS::DomainParticipantListener_var participantInitialListener;
participantInitialListener = participant->get_listener();
if ( CORBA::is_nil (participantInitialListener.in ()) )
{
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("(%P|%t) DomainParticipant returned a nil listener when expected a valid!\n")),
7);
}
::DDS::ReturnCode_t setListenerReturnCode =
participant->set_listener(dpListener.in(),
::DDS::INCONSISTENT_TOPIC_STATUS | ::DDS::SUBSCRIPTION_MATCH_STATUS);
if (::DDS::RETCODE_OK != setListenerReturnCode)
{
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("(%P|%t) Was unable to set valid Participant listener!\n")),
7);
}
::DDS::DomainParticipantListener_var participantListener;
participantListener = participant->get_listener();
if (CORBA::is_nil (participantListener.in ()) )
{
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("(%P|%t) DomainParticipant returned a nil listener!\n")),
7);
}
if (participantListener.in() != dpListener.ptr())
{
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("(%P|%t) DomainParticipant listener returned is not the listener set!\n")),
7);
}
if (participant->get_domain_id() != TEST_DOMAIN_NUMBER)
{
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("(%P|%t) DomainParticipant returned the incorrect domain id!\n")),
7);
}
::DDS::PublisherQos pubInitialQos;
participant->get_default_publisher_qos(pubInitialQos);
::DDS::PublisherQos pubQosChangedEntityFactory;
pubQosChangedEntityFactory.entity_factory.autoenable_created_entities =
! pubInitialQos.entity_factory.autoenable_created_entities;
::DDS::ReturnCode_t pubChangeQosReturnCode =
participant->set_default_publisher_qos(pubQosChangedEntityFactory);
if (::DDS::RETCODE_INCONSISTENT_POLICY != pubChangeQosReturnCode)
{
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("(%P|%t) Was able to set invalid default Publisher QOS!\n")),
8);
}
::DDS::PublisherQos pubQosNewDefault;
participant->get_default_publisher_qos (pubQosNewDefault);
if (pubInitialQos.entity_factory.autoenable_created_entities
!= pubQosNewDefault.entity_factory.autoenable_created_entities)
{
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("(%P|%t) Incorrect default Publisher QOS was returned in the get!\n")),
8);
}
::DDS::Publisher_var publisher = ::DDS::Publisher::_nil();
publisher = participant->create_publisher (pubInitialQos,
::DDS::PublisherListener::_nil());
if (CORBA::is_nil (publisher.in ()) )
{
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("(%P|%t) DomainParticipant returned a nil publisher!\n")),
8);
}
::DDS::ReturnCode_t deletePubReturnCode =
participant->delete_publisher(publisher.in ());
if (::DDS::RETCODE_OK != deletePubReturnCode)
{
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("(%P|%t) Publisher was NOT deleted!\n")),
8);
}
::DDS::SubscriberQos subInitialQos;
participant->get_default_subscriber_qos(subInitialQos);
::DDS::SubscriberQos subQosChangedEntityFactory;
subQosChangedEntityFactory.entity_factory.autoenable_created_entities =
! subInitialQos.entity_factory.autoenable_created_entities;
::DDS::ReturnCode_t subChangeQosReturnCode =
participant->set_default_subscriber_qos(subQosChangedEntityFactory);
if (::DDS::RETCODE_INCONSISTENT_POLICY != subChangeQosReturnCode)
{
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("(%P|%t) Was able to set invalid default Subscriber QOS!\n")),
9);
}
::DDS::SubscriberQos subQosNewDefault;
participant->get_default_subscriber_qos (subQosNewDefault);
if (subInitialQos.entity_factory.autoenable_created_entities
!= subQosNewDefault.entity_factory.autoenable_created_entities)
{
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("(%P|%t) Incorrect default Subscriber QOS was returned in the get!\n")),
9);
}
::DDS::Subscriber_var subscriber = ::DDS::Subscriber::_nil();
subscriber = participant->create_subscriber (subInitialQos,
::DDS::SubscriberListener::_nil());
if (CORBA::is_nil (subscriber.in ()) )
{
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("(%P|%t) DomainParticipant returned a nil Subscriber!\n")),
9);
}
::DDS::ReturnCode_t deleteSubReturnCode =
participant->delete_subscriber(subscriber.in ());
if (::DDS::RETCODE_OK != deleteSubReturnCode)
{
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("(%P|%t) Subscriber was NOT deleted!\n")),
9);
}
publisher = participant->create_publisher (pubInitialQos,
::DDS::PublisherListener::_nil());
if (CORBA::is_nil (publisher.in ()) )
{
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("(%P|%t) DomainParticipant returned a nil publisher!\n")),
10);
}
subscriber = participant->create_subscriber (subInitialQos,
::DDS::SubscriberListener::_nil());
if (CORBA::is_nil (subscriber.in ()) )
{
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("(%P|%t) DomainParticipant returned a nil Subscriber!\n")),
10);
}
::DDS::ReturnCode_t deleteEntriesReturnCode =
participant->delete_contained_entities();
if (::DDS::RETCODE_OK != deleteEntriesReturnCode)
{
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("(%P|%t) DomainParticipant failed to delete_contained_entities!\n")),
10);
}
deleteParticipantReturnCode =
dpFactory->delete_participant(participant.in ());
if (::DDS::RETCODE_OK != deleteParticipantReturnCode)
{
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("(%P|%t) Valid Participant was not deleted!\n")),
7);
}
TheTransportFactory->release();
TheServiceParticipant->shutdown();
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Exception caught in client.cpp:");
return 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(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);
}
::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;
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 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;
}
bool
AbstractionLayer::init_DDS(int& argc, ACE_TCHAR *argv[])
{
// Initialize the Participant Factory
dpf_ = TheParticipantFactoryWithArgs (argc, argv);
if (CORBA::is_nil (dpf_.in ()) ) {
ACE_ERROR((LM_ERROR,
ACE_TEXT("ERROR - Create participant factory failed.\n") ));
return false;
}
// Create participant
dp_ = dpf_->create_participant (DOMAINID,
PARTICIPANT_QOS_DEFAULT,
DDS::DomainParticipantListener::_nil (),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (dp_.in ()) ) {
ACE_ERROR((LM_ERROR,
ACE_TEXT("ERROR - Create participant failed.\n") ));
return false;
}
// Create publisher
pub_ = dp_->create_publisher (PUBLISHER_QOS_DEFAULT,
DDS::PublisherListener::_nil (),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (pub_.in ()) ) {
ACE_ERROR((LM_ERROR,
ACE_TEXT("ERROR - Create publisher failed.\n") ));
return false;
}
// Create topic for datawriter and datareader
DistributedContent::FileDiffTypeSupportImpl* fileinfo_dt =
new DistributedContent::FileDiffTypeSupportImpl();
fileinfo_dt->register_type (dp_.in (),
"DistributedContent::FileDiff");
topic_ = dp_->create_topic ("fileinfo_topic", // topic name
"DistributedContent::FileDiff", // topic type
TOPIC_QOS_DEFAULT,
DDS::TopicListener::_nil (),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (topic_.in ()) ) {
ACE_ERROR((LM_ERROR,
ACE_TEXT("ERROR - Create topic failed.\n") ));
return false;
}
// Create the subscriber
sub_ = dp_->create_subscriber(SUBSCRIBER_QOS_DEFAULT,
DDS::SubscriberListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (sub_.in ()) ) {
ACE_ERROR((LM_ERROR,
ACE_TEXT("ERROR - Create subscriber failed.\n") ));
return false;
}
// Create the listener for datareader
listener_ = new FileInfoListener(this);
// Create the datareader
dr_ = sub_->create_datareader (topic_.in (),
DATAREADER_QOS_DEFAULT,
listener_.in (),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (dr_.in ()) ) {
ACE_ERROR((LM_ERROR, "ERROR - Create data reader failed.\n"));
return false;
}
// Setup the ignores so the data writer for this node will not associate with
// the data reader of this node.
// We need the servants of the Domain Participant and the Data Reader to
// get information to set up the ignore.
::OpenDDS::DCPS::DomainParticipantImpl* dp_servant =
dynamic_cast< ::OpenDDS::DCPS::DomainParticipantImpl*>(dp_.in());
if (0 == dp_servant ) {
ACE_ERROR((LM_ERROR,
ACE_TEXT("ERROR - Servant dereference of domain participant failed.\n") ));
return false;
}
::OpenDDS::DCPS::DataReaderImpl* dr_servant =
dynamic_cast< ::OpenDDS::DCPS::DataReaderImpl*>(dr_.in());
if (0 == dr_servant ) {
ACE_ERROR((LM_ERROR,
ACE_TEXT("ERROR - Servant dereference of data reader failed.\n") ));
return false;
}
// Get the repo id for the subscription
::OpenDDS::DCPS::RepoId ignore_id = dr_servant->get_subscription_id ();
// Get the instance handle for the subscription
::DDS::InstanceHandle_t handle = dp_servant->id_to_handle(ignore_id);
// tell the domain participant to ignore the subscription
DDS::ReturnCode_t ret = dp_->ignore_subscription (handle);
if (ret != ::DDS::RETCODE_OK)
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT("ERROR - Failed to ignore_publication %d return error %d\n"),
handle, ret));
return false;
}
// Create the datawriter
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((LM_ERROR,
ACE_TEXT("ERROR - Create data writer failed.\n") ));
return false;
}
// Narrow down the data writer to the FileDiffDataWriter
filediff_writer_ = DistributedContent::FileDiffDataWriter::_narrow (dw_.in());
if (CORBA::is_nil (filediff_writer_.in ()) ) {
ACE_ERROR((LM_ERROR,
ACE_TEXT("ERROR - Narrow of data writer failed.\n") ));
return false;
}
return true;
}
