DDS::DataReader_var
createDataReader(
DDS::Subscriber_var subscriber,
DDS::Topic_var topic,
DDS::DataReaderListener_var listener,
bool keep_last_one)
{
// Set qos
DDS::DataReaderQos dr_qos;
// RELIABLE/KEEP_LAST/10 works
subscriber->get_default_datareader_qos(dr_qos);
dr_qos.reliability.kind = DDS::RELIABLE_RELIABILITY_QOS;
if (keep_last_one) {
dr_qos.history.kind = DDS::KEEP_LAST_HISTORY_QOS;
dr_qos.history.depth = 1;
std::cout << "Datareader QOS keep last one" << std::endl;
} else {
dr_qos.history.kind = DDS::KEEP_LAST_HISTORY_QOS;
dr_qos.history.depth = 10;
}
// Create DataReader
DDS::DataReader_var reader =
subscriber->create_datareader(topic,
dr_qos,
listener,
OpenDDS::DCPS::DEFAULT_STATUS_MASK);
// Check for failure
if (!reader) {
throw std::string("failed to create data reader");
}
return reader;
}
DDS::DataReader_var
create_reader(const DDS::Subscriber_var& sub, const char* topicName,
const DDS::DataReaderQos& qos = DATAREADER_QOS_DEFAULT,
const DDS::DataReaderListener_var& listener = 0,
const DDS::StatusMask& mask = OpenDDS::DCPS::DEFAULT_STATUS_MASK)
{
const DDS::TypeSupport_var ts = new ::OpenDDS::DCPS::TypeSupportImpl_T<MessageType>();
const DDS::DomainParticipant_var dp = sub->get_participant();
const CORBA::String_var typeName = ts->get_type_name();
(void) ts->register_type(dp, typeName); // may have been registered before
const DDS::Topic_var topic =
dp->create_topic(topicName, typeName, TOPIC_QOS_DEFAULT, 0, 0);
if (!topic) return 0;
const DDS::DataReader_var dr =
sub->create_datareader(topic, qos, listener, mask);
return OpenDDS::DCPS::DDSTraits<MessageType>::DataReaderType::_narrow(dr);
}
DDS::DataReader_var
Factory::reader(const DDS::Subscriber_var& sub, const DDS::Topic_var& topic, const DDS::DataReaderListener_var& drl) const
{
// Create the data readers
DDS::DataReaderQos dr_qos;
sub->get_default_datareader_qos(dr_qos);
dr_qos.durability.kind = opts_.durability_kind;
dr_qos.liveliness.kind = opts_.liveliness_kind;
dr_qos.liveliness.lease_duration = opts_.LEASE_DURATION;
dr_qos.reliability.kind = opts_.reliability_kind;
DDS::DomainParticipant_var dp = sub->get_participant();
CORBA::String_var tn = topic->get_name();
DDS::TopicDescription_var description = dp->lookup_topicdescription(tn);
TEST_ASSERT(!CORBA::is_nil(description.in()));
DDS::DataReader_var rd(sub->create_datareader(description.in(),
dr_qos,
drl.in(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK));
// Initialize the transport configuration for the appropriate entity
TEST_ASSERT(!opts_.configuration_str.empty());
if (opts_.configuration_str != "none" && opts_.entity_str == "rw")
{
OpenDDS::DCPS::TransportRegistry::instance()->bind_config(opts_.configuration_str,
rd.in());
if (!opts_.entity_autoenable)
{
TEST_ASSERT(DDS::RETCODE_OK == rd->enable());
}
}
return rd;
}
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;
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,
"(%P|%t) create_participant failed.\n")
, -1);
}
MessageTypeSupportImpl* mts_servant = new MessageTypeSupportImpl;
if (DDS::RETCODE_OK != mts_servant->register_type(participant.in (),
"")) {
ACE_ERROR_RETURN ((LM_ERROR,
"(%P|%t) Failed to register the MessageTypeTypeSupport.\n")
, -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 ())) {
ACE_ERROR_RETURN ((LM_ERROR,
"(%P|%t) Failed to create_topic.\n")
, -1);
}
// Indicate that the subscriber is about to become ready
FILE* readers_ready = ACE_OS::fopen (sub_ready_filename, ACE_TEXT("w"));
if (readers_ready == 0) {
ACE_ERROR_RETURN ((LM_ERROR,
"(%P|%t) ERROR: Unable to create subscriber ready file.\n")
, -1);
}
ACE_OS::fclose(readers_ready);
// Check if the publisher is up and running
ACE_stat stats;
while (ACE_OS::stat (pub_ready_filename, &stats) == -1)
{
ACE_Time_Value small_time(0,250000);
ACE_OS::sleep (small_time);
}
for (int count = 1; count <= sub_reinit_itr; count++)
{
if (verbose) {
ACE_DEBUG ((LM_DEBUG, "(%P|%t) Reinitializing subscriber.\n"));
}
// 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 ())) {
ACE_ERROR_RETURN ((LM_ERROR,
"(%P|%t) Failed to create_subscriber.\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,
DDS::DataReaderListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (dr.in ())) {
ACE_ERROR_RETURN ((LM_ERROR,
"(%P|%t) create_datareader failed.\n")
, -1);
}
// This is where a speed-bump should be.
while (true)
{
::DDS::InstanceHandleSeq handles;
dr->get_matched_publications (handles);
if (handles.length() > 0) {
break;
}
ACE_Time_Value small_time (0,250000);
ACE_OS::sleep (small_time);
}
// Add sleep to let the fully_associted message arrive datawriter
// before remove_associations is called upon delete_datareader,
// otherwise the datawriter will encounter bit lookup timeout upon
// fully associated.
ACE_Time_Value small_time (0,250000);
ACE_OS::sleep (small_time);
if (verbose) {
ACE_DEBUG ((LM_DEBUG, "(%P|%t) *** Destroying Subscriber\n"));
}
// Delete data reader
sub->delete_datareader(dr.in());
// Delete subscriber
participant->delete_subscriber(sub.in());
dr = DDS::DataReader::_nil ();
sub = DDS::Subscriber::_nil();
}
if (!CORBA::is_nil (participant.in ())) {
participant->delete_contained_entities();
}
if (!CORBA::is_nil (dpf.in ())) {
dpf->delete_participant(participant.in ());
}
TheServiceParticipant->shutdown ();
// Indicate that the subscriber is done
FILE* readers_completed = ACE_OS::fopen (sub_finished_filename, ACE_TEXT("w"));
if (readers_completed == 0) {
ACE_ERROR_RETURN ((LM_ERROR,
"(%P|%t) ERROR: Unable to create subscriber completed file.\n")
, -1);
}
ACE_OS::fclose(readers_completed);
}
catch (CORBA::Exception& e) {
ACE_ERROR_RETURN ((LM_ERROR,
"(%P|%t) Exception caught in main (): %C (%C).\n"
, e._name (), e._rep_id ())
, -1);
}
return 0;
}
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();
boost::gregorian::date date ( boost::gregorian::from_undelimited_string( "20111019" ) );
long evaluationDate = QuantLib::Date( date.day(), QuantLib::Month(date.month().as_number()), date.year() ).serialNumber();
QuantLibAddinCpp::qlSettingsSetEvaluationDate(evaluationDate, OH_NULL);
std::string ticker;
// Initialize, and create a DomainParticipant
dpf = TheParticipantFactoryWithArgs(argc, argv);
qldds_utils::BasicDomainParticipant participant( dpf, EQUITY_OPTIONS_DOMAIN_ID );
participant.createPublisher();
participant.createSubscriber();
DDS::DomainParticipant_var dp = participant.getDomainParticipant();
ACE_Get_Opt cmd_opts( argc, argv, ":s:" );
int option;
while ( (option = cmd_opts()) != EOF )
{
switch( option )
{
case 's' :
ticker = cmd_opts.opt_arg();
break;
}
}
// Topics
// setting up qlBlackConstantVols Topic
DDS::Topic_var ql_black_constant_vols_topic = participant.createTopicAndRegisterType
< qlBlackConstantVolsTypeSupport_var, qlBlackConstantVolsTypeSupportImpl >
( QL_BLACK_CONSTANT_VOLS_TOPIC_NAME );
// setting up qlGeneralizedBlackScholesProcesses Topic
DDS::Topic_var ql_generalized_black_scholes_processes_topic = participant.createTopicAndRegisterType
< qlGeneralizedBlackScholesProcessesTypeSupport_var, qlGeneralizedBlackScholesProcessesTypeSupportImpl >
( QL_GENERALIZED_BLACK_SCHOLES_PROCESSES_TOPIC_NAME );
// setting up qlStrikedTypePayoff Topic
DDS::Topic_var ql_striked_type_payoffs_topic = participant.createTopicAndRegisterType
< qlStrikedTypePayoffsTypeSupport_var, qlStrikedTypePayoffsTypeSupportImpl >
( QL_STRIKED_TYPE_PAYOFFS_TOPIC_NAME );
// setting up qlEuropeanExercises Topic
DDS::Topic_var ql_european_exercises_topic = participant.createTopicAndRegisterType
< qlEuropeanExercisesTypeSupport_var, qlEuropeanExercisesTypeSupportImpl >
( QL_EUROPEAN_EXERCISES_TOPIC_NAME );
StraddleSetupTypeSupport_var ts_res = new StraddleSetupTypeSupportImpl;
if ( ts_res->register_type(dp, "") != DDS::RETCODE_OK )
{
std::cout << "Registration of the Topic FAILED!!!!" << std::endl;
}
CORBA::String_var type_name = ts_res->get_type_name();
std::cout << "Type Name : " << type_name << std::endl;
std::stringstream multi_topic_select;
multi_topic_select << "SELECT ticker, putVols, callVols, putPayoffs, callPayoffs, process, exercises FROM "<<
QL_BLACK_CONSTANT_VOLS_TOPIC_NAME << " NATURAL JOIN " <<
QL_GENERALIZED_BLACK_SCHOLES_PROCESSES_TOPIC_NAME << " NATURAL JOIN " <<
QL_STRIKED_TYPE_PAYOFFS_TOPIC_NAME << " NATURAL JOIN " <<
QL_EUROPEAN_EXERCISES_TOPIC_NAME << " WHERE ticker = '" << ticker << "'";
std::cout << multi_topic_select.str() << std::endl;
DDS::MultiTopic_var mt = dp->create_multitopic("MyMultiTopic", type_name, multi_topic_select.str().c_str(), DDS::StringSeq());
if ( CORBA::is_nil( mt ) )
std::cout << "MultiTopic Subscribtion failed.!!!!" << mt << std::endl;
DDS::Subscriber_var sub = participant.getSubscriber();
std::cout << "Creating Data Reader"<< std::endl;
DDS::DataReader_var dr = sub->create_datareader(mt, DATAREADER_QOS_DEFAULT, 0, ::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
std::cout << "Done..."<< std::endl;
DDS::WaitSet_var ws = new DDS::WaitSet;
DDS::ReadCondition_var rc = dr->create_readcondition( DDS::ANY_SAMPLE_STATE, DDS::ANY_VIEW_STATE, DDS::ANY_INSTANCE_STATE);
ws->attach_condition(rc);
DDS::Duration_t infinite = { DDS::DURATION_INFINITE_SEC, DDS::DURATION_INFINITE_NSEC};
DDS::ConditionSeq active;
int ret = ws->wait(active, infinite);
if (ret != DDS::RETCODE_OK) return false;
ws->detach_condition(rc);
// setting up topic for Straddles
DDS::Topic_var straddles_topic = participant.createTopicAndRegisterType
< StraddlesTypeSupport_var, StraddlesTypeSupportImpl >
( STRADDLES_TOPIC_NAME );
StraddlesDataWriter_var straddles_dw = participant.createDataWriter
< StraddlesDataWriter_var, StraddlesDataWriter >
( straddles_topic );
int calculation_performed = 0;
do {
StraddleSetupDataReader_var res_dr = StraddleSetupDataReader::_narrow(dr);
StraddleSetupSeq data;
DDS::SampleInfoSeq info;
int ret = res_dr->take_w_condition(data, info, DDS::LENGTH_UNLIMITED, rc);
if (ret == DDS::RETCODE_OK)
{
qlBlackConstantVolMatrix& putVols = data[0].putVols;
qlStrikedTypePayoffSeq& putPayoffs = data[0].putPayoffs;
qlBlackConstantVolMatrix& callVols = data[0].callVols;
qlStrikedTypePayoffSeq& callPayoffs = data[0].callPayoffs;
processes::qlGeneralizedBlackScholesProcess& process = data[0].process;
qlEuropeanExerciseSeq& exercises = data[0].exercises;
Straddles straddles;
straddles.ticker = CORBA::string_dup( ticker.c_str() );
straddles.underlying = data[0].process.Underlying;
int strike_count = putPayoffs.length() + callPayoffs.length();
int exercises_count = exercises.length();
straddles.options.length( strike_count * exercises_count );
int priced_options = 0;
price( ticker, putVols, putPayoffs, process, exercises, straddles, priced_options );
price( ticker, callVols, callPayoffs, process, exercises, straddles, priced_options );
ACE_DEBUG( (LM_INFO, "(%T|%P|%t) Publishing Straddles for ticker : %s trading @%f\n", ticker.c_str(), data[0].process.Underlying ) );
int ret = straddles_dw->write( straddles, DDS::HANDLE_NIL );
if (ret != DDS::RETCODE_OK) {
ACE_ERROR ((LM_ERROR, ACE_TEXT("(%P|%t) ERROR: Publishing Straddles for ticker : %s failed %d.\n"), ticker.c_str(), ret));
}
calculation_performed++;
}
} while ( calculation_performed < 30 );
cout << "Exiting..." << endl;
} catch (CORBA::Exception& e)
{
cerr << "Exception caught in main.cpp:" << endl << e << endl;
ACE_OS::exit(1);
}
TheServiceParticipant->shutdown();
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 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)
DDS::Topic_var topic =
participant->create_topic("Movie Discussion List",
ts->get_type_name(),
TOPIC_QOS_DEFAULT,
DDS::TopicListener::_nil(),
OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil(topic.in())) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l main()")
ACE_TEXT(" ERROR: create_topic() failed!\n")), -1);
}
::DDS::SubscriberQos subscriber_qos;
participant->get_default_subscriber_qos (subscriber_qos);
subscriber_qos.presentation.access_scope
= (::DDS::PresentationQosPolicyAccessScopeKind)acess_scope;
subscriber_qos.presentation.coherent_access = true;
subscriber_qos.presentation.ordered_access = true;
SubscriberListenerImpl* subscriber_listener_svt = new SubscriberListenerImpl();
DDS::SubscriberListener_var subscriber_listener(subscriber_listener_svt);
// Create Subscriber
DDS::Subscriber_var sub =
participant->create_subscriber(subscriber_qos,
subscriber_listener.in(),
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);
}
// Initialize Transport
OpenDDS::DCPS::TransportImpl_rch transport_impl =
TheTransportFactory->create_transport_impl(transport_impl_id,
OpenDDS::DCPS::AUTO_CONFIG);
OpenDDS::DCPS::AttachStatus status = transport_impl->attach(sub.in());
if (status != OpenDDS::DCPS::ATTACH_OK) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l main()")
ACE_TEXT(" ERROR: attach() failed!\n")), -1);
}
// Create DataReader
DataReaderListenerImpl* listener_svt1 = new DataReaderListenerImpl("DataReader1");
DataReaderListenerImpl* listener_svt2 = new DataReaderListenerImpl("DataReader2");
DDS::DataReaderListener_var listener1(listener_svt1);
DDS::DataReaderListener_var listener2(listener_svt2);
::DDS::DataReaderQos readerQos;
sub->get_default_datareader_qos( readerQos);
readerQos.history.kind = ::DDS::KEEP_ALL_HISTORY_QOS;
readerQos.resource_limits.max_samples_per_instance = ::DDS::LENGTH_UNLIMITED;
DDS::DataReader_var reader1 =
sub->create_datareader(topic.in(),
readerQos,
listener1.in(),
OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil(reader1.in())) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l main()")
ACE_TEXT(" ERROR: create_datareader() failed!\n")), -1);
}
DDS::DataReader_var reader2 =
sub->create_datareader(topic.in(),
readerQos,
listener2.in(),
OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil(reader2.in())) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l main()")
ACE_TEXT(" ERROR: create_datareader() failed!\n")), -1);
}
// Block until Publisher completes
DDS::StatusCondition_var condition1 = reader1->get_statuscondition();
DDS::StatusCondition_var condition2 = reader2->get_statuscondition();
condition1->set_enabled_statuses(DDS::SUBSCRIPTION_MATCHED_STATUS);
condition2->set_enabled_statuses(DDS::SUBSCRIPTION_MATCHED_STATUS);
DDS::WaitSet_var ws1 = new DDS::WaitSet;
DDS::WaitSet_var ws2 = new DDS::WaitSet;
ws1->attach_condition(condition1);
ws2->attach_condition(condition2);
DDS::Duration_t timeout =
{ DDS::DURATION_INFINITE_SEC, DDS::DURATION_INFINITE_NSEC };
DDS::ConditionSeq conditions1;
DDS::ConditionSeq conditions2;
DDS::SubscriptionMatchedStatus matches1 = { 0, 0, 0, 0, 0 };
DDS::SubscriptionMatchedStatus matches2 = { 0, 0, 0, 0, 0 };
do {
if (matches1.current_count == 0 && ws1->wait(conditions1, timeout) != DDS::RETCODE_OK) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l main()")
ACE_TEXT(" ERROR: wait() failed!\n")), -1);
}
if (matches2.current_count == 0 && ws2->wait(conditions2, timeout) != DDS::RETCODE_OK) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l main()")
ACE_TEXT(" ERROR: wait() failed!\n")), -1);
}
if (reader1->get_subscription_matched_status(matches1) != DDS::RETCODE_OK) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l main()")
ACE_TEXT(" ERROR: get_subscription_matched_status() failed!\n")), -1);
}
if (reader2->get_subscription_matched_status(matches2) != DDS::RETCODE_OK) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l main()")
ACE_TEXT(" ERROR: get_subscription_matched_status() failed!\n")), -1);
}
} while (matches1.current_count > 0 && matches2.current_count > 0);
if (! subscriber_listener_svt->verify_result ()
|| ! listener_svt1->verify_result()
|| ! listener_svt2->verify_result()) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l main()")
ACE_TEXT(" ERROR: failed to verify message!\n")), -1);
}
ws1->detach_condition(condition1);
ws2->detach_condition(condition2);
// Clean-up!
participant->delete_contained_entities();
dpf->delete_participant(participant.in());
TheTransportFactory->release();
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[])
{
bool ok = true;
bool generated_config = false;
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;
}
}
// 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) << ACE_OS::getpid();
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;
std::string config;
config = domain_config_stream.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& e) {
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 {
// Initialize DomainParticipantFactory
DDS::DomainParticipantFactory_var dpf =
TheParticipantFactoryWithArgs(argc, argv);
// Create DomainParticipant
DDS::DomainParticipant_var participant =
dpf->create_participant(42,
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);
}
// Register Type (Messenger::Message)
Messenger::MessageTypeSupport_var ts =
new Messenger::MessageTypeSupportImpl;
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 (Movie Discussion List)
CORBA::String_var type_name = ts->get_type_name();
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);
}
// 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);
}
// Create DataReader
DDS::DataReaderListener_var listener(new DataReaderListenerImpl);
DDS::DataReader_var reader =
subscriber->create_datareader(topic,
DATAREADER_QOS_DEFAULT,
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);
}
Messenger::MessageDataReader_var reader_i =
Messenger::MessageDataReader::_narrow(reader);
if (!reader_i) {
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);
while (true) {
DDS::SubscriptionMatchedStatus matches;
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);
}
if (matches.current_count == 0 && matches.total_count > 0) {
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);
// 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** args){
std::cout << "Welcome to userqos stress test" << std::endl;
enum {PUBLISHER, SUBSCRIBER} mode;
if(argc != 2 || !(*args[1] == 'p' || *args[1] == 's')){
printf("Usage: %s (p|s)\n"
" p - Publisher\n"
" s - Subscriber\n",args[0]);
exit(EXIT_FAILURE);
} else if(*args[1] == 'p'){
mode = PUBLISHER;
} else if(*args[1] == 's'){
mode = SUBSCRIBER;
} else {
printf("Should never reach this state.\n");
exit(EXIT_FAILURE);
}
DDS::ReturnCode_t retval;
DDS::InstanceHandle_t handle;
DDS::DomainParticipantFactory_ptr dpf = DDS::DomainParticipantFactory::get_instance();
assert( NULL != dpf);
DDS::DomainParticipantQos participant_qos;
retval = dpf->get_default_participant_qos(participant_qos);
assert( DDS::RETCODE_OK == retval );
DDS::DomainId_t domain = NULL;
DDS::DomainParticipant_var participant = dpf->create_participant(domain,
PARTICIPANT_QOS_DEFAULT,
NULL,
DDS::STATUS_MASK_NONE);
assert( NULL != participant.in() );
/**
Magical key definitions. If you want the idlpp to generate TypeSupport you MUST,
I repeat, MUST, add #pragma. Why would you ever NOT want the TypeSupport? Who knows.
OpenSplice_PreProcessor_usermanual.pdf , Section: 1.5.1 KeyDefinitions
**/
// Memory leak: I cannot seem to free pid_ts. Delete is blocked nor can I find _release per the docs
PID::PresenceTypeSupport_ptr pid_ts = new PID::PresenceTypeSupport();
assert( NULL != pid_ts );
retval = pid_ts->register_type(participant, pid_ts->get_type_name());
assert ( DDS::RETCODE_OK == retval );
DDS::TopicQos topic_qos;
retval = participant->get_default_topic_qos(topic_qos);
assert( DDS::RETCODE_OK == retval );
DDS::Topic_var presence_topic = participant->create_topic("presence",
pid_ts->get_type_name(),
topic_qos,
NULL,
DDS::STATUS_MASK_NONE);
assert( NULL != presence_topic.in() );
/**
Publisher code
**/
if(mode == PUBLISHER){
DDS::PublisherQos publisher_qos;
retval = participant->get_default_publisher_qos(publisher_qos);
assert( DDS::RETCODE_OK == retval );
DDS::Publisher_var publisher = participant->create_publisher(publisher_qos,
NULL,
DDS::STATUS_MASK_NONE);
assert( NULL != publisher.in() );
/**
PID Data Writer
**/
DDS::DataWriterQos dw_qos;
retval = publisher->get_default_datawriter_qos(dw_qos);
assert( DDS::RETCODE_OK == retval );
const char* msg = "HI THERE COWBOY";
dw_qos.user_data.value = DDS_DCPSUFLSeq<unsigned char, DDS::octSeq_uniq_>(msg);
assert( strlen(msg) == dw_qos.user_data.value.length() );
DDS::DataWriter_var writer = publisher->create_datawriter(presence_topic, dw_qos, NULL, DDS::STATUS_MASK_NONE);
assert( NULL != writer.in() );
PID::PresenceDataWriter_var presence_writer = PID::PresenceDataWriter::_narrow(writer);
assert( NULL != presence_writer.in() );
PID::Presence temp_presence;
temp_presence.pid = 100;
temp_presence.hostname = "my_machine";
//handle = presence_writer->register_instance(temp_presence);
//assert( DDS::HANDLE_NIL != handle );
handle = DDS::HANDLE_NIL;
// std::cout << "LOOPING" << std::endl;
// while(shutdown_flag == 0){
retval = presence_writer->write(temp_presence,handle);
assert( DDS::RETCODE_OK == retval );
// usleep(50);
//}
}
/**
Subscriber
**/
else if(mode == SUBSCRIBER){
DDS::SubscriberQos subscriber_qos;
retval = participant->get_default_subscriber_qos(subscriber_qos);
assert( DDS::RETCODE_OK == retval );
DDS::Subscriber_var subscriber = participant->create_subscriber(subscriber_qos,
NULL,
DDS::STATUS_MASK_NONE);
assert( NULL != subscriber.in() );
/**
PID Data Reader
**/
DDS::DataReaderQos dr_qos;
retval = subscriber->get_default_datareader_qos(dr_qos);
assert( DDS::RETCODE_OK == retval );
PID::PresenceReaderListener *p_r_listener = new PID::PresenceReaderListener();
assert(p_r_listener != NULL);
DDS::DataReader_ptr reader = subscriber->create_datareader(presence_topic, dr_qos, p_r_listener, DDS::DATA_AVAILABLE_STATUS);
assert( NULL != reader );
PID::PresenceDataReader *presence_reader = PID::PresenceDataReader::_narrow(reader);
assert( NULL != presence_reader );
while(shutdown_flag == 0){
usleep(50);
}
}
//retval = dpf->delete_participant(participant);
//assert( DDS::RETCODE_OK == retval );
retval = DDS::RETCODE_PRECONDITION_NOT_MET;
while(retval != DDS::RETCODE_OK){
retval = dpf->delete_contained_entities();
/*
switch(retval){
case DDS::RETCODE_OK:
printf("DDS::RETCODE_OK\n");
break;
case DDS::RETCODE_ERROR:
printf("DDS::RETCODE_ERROR\n");
break;
case DDS::RETCODE_OUT_OF_RESOURCES:
printf("DDS::RETCODE_OUT_OF_RESOURCES\n");
break;
case DDS::RETCODE_PRECONDITION_NOT_MET:
printf("DDS::RETCODE_PRECONDITION_NOT_MET\n");
break;
default:
printf("Default case?\n");
}
*/
usleep(10);
}
assert( DDS::RETCODE_OK == retval );
return 0;
}
int ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
int return_result = 0;
try
{
DDS::DomainParticipantFactory_var dpf;
DDS::DomainParticipant_var participant;
dpf = TheParticipantFactoryWithArgs(argc, argv);
participant =
dpf->create_participant(11,
PARTICIPANT_QOS_DEFAULT,
DDS::DomainParticipantListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (participant.in ())) {
cerr << "create_participant failed." << endl;
return 1 ;
}
Messenger::MessageTypeSupportImpl* mts_servant =
new Messenger::MessageTypeSupportImpl;
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);
}
// Create the listener.
DDS::DataReaderListener_var listener (new DataReaderListenerImpl);
DataReaderListenerImpl* listener_servant =
dynamic_cast<DataReaderListenerImpl*>(listener.in());
if (CORBA::is_nil (listener.in ()))
{
cerr << "ERROR: listener is nil." << endl;
exit(1);
}
DDS::DataReaderQos dr_qos; // Good QoS.
sub->get_default_datareader_qos (dr_qos);
dr_qos.resource_limits.max_samples_per_instance = MAX_SAMPLES_PER_INSTANCES;
dr_qos.resource_limits.max_samples = MAX_SAMPLES;
dr_qos.resource_limits.max_instances = MAX_INSTANCES;
#ifndef OPENDDS_NO_OWNERSHIP_PROFILE
dr_qos.history.kind = ::DDS::KEEP_ALL_HISTORY_QOS;
dr_qos.history.depth = MAX_SAMPLES_PER_INSTANCES;
#endif
DDS::DataReader_var dr1 =
sub->create_datareader (topic.in (),
dr_qos,
listener.in (),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (dr1.in ()) )
{
cerr << "ERROR: create_datareader failed." << endl;
exit(1);
}
DDS::DataReader_var dr2 =
sub->create_datareader (topic.in (),
dr_qos,
DDS::DataReaderListener::_nil (),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (dr2.in ()) )
{
cerr << "ERROR: create_datareader failed." << endl;
exit(1);
}
int max_attempts = 10;
int attempts = 0;
// Synchronize with publisher. Wait until both associate with DataWriter.
while (attempts < max_attempts)
{
::DDS::SubscriptionMatchedStatus status1;
::DDS::SubscriptionMatchedStatus status2;
if (dr1->get_subscription_matched_status (status1) == ::DDS::RETCODE_OK
&& dr2->get_subscription_matched_status (status2) == ::DDS::RETCODE_OK)
{
if (status1.total_count == 2 && status2.total_count == 2)
break;
++ attempts;
ACE_OS::sleep (1);
}
else
{
cerr << "ERROR: Failed to get subscription matched status" << endl;
exit (1);
}
}
if (attempts >= max_attempts)
{
cerr << "ERROR: failed to make associations. " << endl;
exit (1);
}
// ----------------------------------------------
ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%P|%t) Subscriber: sleep for %d milliseconds\n"),
SLEEP_DURATION.msec()));
// Wait for publisher to finish sending
ACE_OS::sleep (SLEEP_DURATION);
long rej_max_samples = listener_servant->num_rejected_for_max_samples();
long rej_max_instances = listener_servant->num_rejected_for_max_instances();
long rej_max_samp_instance = listener_servant->num_rejected_for_max_samples_per_instance();
ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%P|%t) Subscriber: %d rejected for ")
ACE_TEXT ("max_samples\n"),
rej_max_samples));
ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%P|%t) Subscriber: %d rejected for ")
ACE_TEXT ("max_instances\n"),
rej_max_instances));
ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%P|%t) Subscriber: %d rejected for ")
ACE_TEXT ("max_samples_per_instance\n"),
rej_max_samp_instance));
ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%P|%t) Subscriber: received %d ")
ACE_TEXT ("samples\n"),
listener_servant->num_arrived() ));
// 3 instances writing 5 messages each
// expect 2 rejected for max_samples
// expect 6 rejected for max_instances (register_instance + 5 messages)
// expect 1 rejected for max_samples_per_instance
#ifndef OPENDDS_NO_OWNERSHIP_PROFILE
if (rej_max_samples != 2) {
cerr << "ERROR: Failed to reject expected for max_samples" << endl;
return_result = 1;
}
#endif
if (rej_max_instances != 6) {
cerr << "ERROR: Failed to reject expected for max_instances" << endl;
return_result = 1;
}
#ifndef OPENDDS_NO_OWNERSHIP_PROFILE
if (rej_max_samp_instance != 1) {
cerr << "ERROR: Failed to reject expected for max_samples_per_instance" << endl;
return_result = 1;
}
#endif
Messenger::MessageDataReader_var message_dr1 =
Messenger::MessageDataReader::_narrow(dr1.in());
Messenger::MessageDataReader_var message_dr2 =
Messenger::MessageDataReader::_narrow(dr2.in());
message_dr1->set_listener(DDS::DataReaderListener::_nil (),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
message_dr2->set_listener(DDS::DataReaderListener::_nil (),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
listener = DDS::DataReaderListener::_nil ();
ACE_OS::sleep (2);
if (!CORBA::is_nil (participant.in ())) {
participant->delete_contained_entities();
}
if (!CORBA::is_nil (dpf.in ())) {
dpf->delete_participant(participant.in ());
}
ACE_OS::sleep(2);
TheServiceParticipant->shutdown ();
}
catch (CORBA::Exception& e)
{
cerr << "SUB: Exception caught in main ():" << endl << e << endl;
return_result = 1;
}
return return_result;
}
int do_reader(DDS::DomainParticipant_var participant, DDS::Topic_var topic, bool toggle)
{
// 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: do_reader() -")
ACE_TEXT(" create_subscriber failed!\n")), -1);
}
DDS::DataReaderQos qos;
subscriber->get_default_datareader_qos(qos);
qos.user_data.value.length(3);
qos.user_data.value[0] = 0;
qos.user_data.value[1] = 0;
qos.user_data.value[2] = 0;
qos.reliability.kind = DDS::RELIABLE_RELIABILITY_QOS;
if (toggle) {
ACE_DEBUG((LM_DEBUG, "Creating reader\n"));
DDS::DataReader_var reader =
subscriber->create_datareader(topic,
qos,
0,
OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (!reader) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("ERROR: %N:%l: do_reader() -")
ACE_TEXT(" create_datareader failed!\n")), -1);
}
ACE_OS::sleep(SLEEP_SHORT);
// Go away.
ACE_DEBUG((LM_DEBUG, "Deleting reader\n"));
subscriber->delete_datareader(reader);
ACE_OS::sleep(SLEEP_SHORT);
// Come back.
ACE_DEBUG((LM_DEBUG, "Creating reader\n"));
reader = subscriber->create_datareader(topic,
qos,
0,
OpenDDS::DCPS::DEFAULT_STATUS_MASK);
ACE_OS::sleep(SLEEP_SHORT);
return 0;
} else {
struct Listener : public DDS::DataReaderListener {
size_t found, lost;
Listener() : found(0), lost(0) { }
virtual void
on_requested_deadline_missed (::DDS::DataReader_ptr,
const ::DDS::RequestedDeadlineMissedStatus &) { }
virtual void
on_requested_incompatible_qos (::DDS::DataReader_ptr,
const ::DDS::RequestedIncompatibleQosStatus &) { }
virtual void
on_sample_rejected (::DDS::DataReader_ptr,
const ::DDS::SampleRejectedStatus &) { }
virtual void
on_liveliness_changed (::DDS::DataReader_ptr,
const ::DDS::LivelinessChangedStatus &) { }
virtual void
on_data_available (::DDS::DataReader_ptr) { }
virtual void
on_subscription_matched (::DDS::DataReader_ptr,
const ::DDS::SubscriptionMatchedStatus & status) {
if (status.current_count_change > 0) {
ACE_DEBUG((LM_DEBUG, "Reader found writer\n"));
++found;
}
if (status.current_count_change < 0) {
ACE_DEBUG((LM_DEBUG, "Reader lost writer\n"));
++lost;
}
}
virtual void
on_sample_lost (::DDS::DataReader_ptr,
const ::DDS::SampleLostStatus &) { }
} listener;
// Create DataReader
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: do_reader() -")
ACE_TEXT(" create_datareader failed!\n")),
-1);
}
ACE_OS::sleep(SLEEP_LONG);
if (listener.found == 2 && listener.lost == 1) {
reader->set_listener(0, OpenDDS::DCPS::DEFAULT_STATUS_MASK);
return 0;
}
return -1;
}
}
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[])
{
try
{
DDS::DomainParticipantFactory_var dpf;
DDS::DomainParticipant_var participant;
dpf = TheParticipantFactoryWithArgs(argc, argv);
// Default DomainParticipantFactory qos is to auto enable.
::DDS::DomainParticipantFactoryQos fqos;
if (dpf->get_qos (fqos) != ::DDS::RETCODE_OK)
{
cerr << "DomainParticipantFactory get_qos failed." << endl;
return 1;
}
if (fqos.entity_factory.autoenable_created_entities == 0)
{
cerr << "The DomainParticipantFactory defaults to autoenable upon entities creation." << endl;
return 1;
}
// Now disable DomainParticipantFactory autoenable
fqos.entity_factory.autoenable_created_entities = 0;
if (dpf->set_qos (fqos) != ::DDS::RETCODE_OK)
{
cerr << "DomainParticipantFactory set_qos failed." << endl;
return 1;
}
participant = dpf->create_participant(411,
PARTICIPANT_QOS_DEFAULT,
DDS::DomainParticipantListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (participant.in ())) {
cerr << "create_participant failed." << endl;
return 1 ;
}
if (participant->enable () != ::DDS::RETCODE_PRECONDITION_NOT_MET)
{
cerr << "DomainParticipant can not be enabled because factory autoenable is off." << endl;
return 1;
}
MessageTypeSupport_var mts = new MessageTypeSupportImpl();
if (DDS::RETCODE_OK != mts->register_type(participant.in (), "")) {
cerr << "Failed to register the MessageTypeTypeSupport." << endl;
exit(1);
}
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 ())) {
cerr << "Failed to create_topic." << endl;
exit(1);
}
if (topic->enable () != ::DDS::RETCODE_PRECONDITION_NOT_MET)
{
cerr << "Topic can not be enabled because DomainParticipant is not enabled." << endl;
return 1;
}
// Initialize the transport
OpenDDS::DCPS::TransportImpl_rch transport_impl =
TheTransportFactory->create_transport_impl (transport_impl_id,
::OpenDDS::DCPS::AUTO_CONFIG);
// 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);
}
if (sub->enable () != ::DDS::RETCODE_PRECONDITION_NOT_MET)
{
cerr << "Publisher can not be enabled because DomainParticipant is not enabled." << endl;
return 1;
}
// Attach the subscriber to the transport.
OpenDDS::DCPS::SubscriberImpl* sub_impl =
dynamic_cast<OpenDDS::DCPS::SubscriberImpl*> (sub.in ());
if (0 == sub_impl) {
cerr << "Failed to obtain subscriber servant\n" << endl;
exit(1);
}
OpenDDS::DCPS::AttachStatus status = sub_impl->attach_transport(transport_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::DataReaderListener_var listener = new DataReaderListenerImpl;
DataReaderListenerImpl &listener_servant =
*dynamic_cast<DataReaderListenerImpl*>(listener.in());
if (CORBA::is_nil (listener.in ())) {
cerr << "listener is nil." << endl;
exit(1);
}
// Create the Datareaders
DDS::DataReader_var dr = sub->create_datareader(topic.in (),
DATAREADER_QOS_DEFAULT,
listener.in (),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (dr.in ())) {
cerr << "create_datareader failed." << endl;
exit(1);
}
if (dr->enable () != ::DDS::RETCODE_PRECONDITION_NOT_MET)
{
cerr << "DataReader can not be enabled because Subscriber is not enabled." << endl;
return 1;
}
// Now enable DomainParticipantFactory autoenable
fqos.entity_factory.autoenable_created_entities = 1;
if (dpf->set_qos (fqos) != ::DDS::RETCODE_OK)
{
cerr << "DomainParticipantFactory set_qos failed." << endl;
return 1;
}
// Enable every entity from factory to it's entities and it should succeed.
if (participant->enable () != ::DDS::RETCODE_OK
|| topic->enable () != ::DDS::RETCODE_OK
|| sub->enable () != ::DDS::RETCODE_OK)
{
cerr << "Failed to enable factory." << endl;
return 1;
}
// The datareader is not enabled so it will not able to
// communicate with datawriter.
int i = 0;
while (i < 5 && listener_servant.num_reads() == 0)
{
ACE_OS::sleep (1);
++i;
}
if (listener_servant.num_reads() > 0)
{
cerr << "Should not receive any samples since datareader is not enabled." << endl;
return 1;
}
if (dr->enable () != ::DDS::RETCODE_OK)
{
cerr << "Failed to enable DataReader." << endl;
return 1;
}
int expected = 10;
while ( listener_servant.num_reads() < expected ) {
ACE_OS::sleep (1);
}
if (!CORBA::is_nil (participant.in ())) {
participant->delete_contained_entities();
}
if (!CORBA::is_nil (dpf.in ())) {
dpf->delete_participant(participant.in ());
}
ACE_OS::sleep(2);
TheTransportFactory->release();
TheServiceParticipant->shutdown ();
}
catch (CORBA::Exception& e)
{
cerr << "SUB: Exception caught in main ():" << endl << e << endl;
return 1;
}
return 0;
}
int
ACE_TMAIN(int argc, ACE_TCHAR* argv[])
{
try {
DDS::DomainParticipantFactory_var dpf;
DDS::DomainParticipant_var participant;
dpf = TheParticipantFactoryWithArgs(argc, argv);
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 ;
}
MessageTypeSupportImpl* mts_servant = new MessageTypeSupportImpl;
if (DDS::RETCODE_OK != mts_servant->register_type(participant.in (),
"")) {
cerr << "Failed to register the MessageTypeTypeSupport." << endl;
exit(1);
}
CORBA::String_var type_name = mts_servant->get_type_name ();
DDS::TopicQos topic_qos;
participant->get_default_topic_qos(topic_qos);
DDS::Topic_var topic =
participant->create_topic("Movie Discussion List",
type_name.in (),
topic_qos,
DDS::TopicListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (topic.in ())) {
cerr << "Failed to create_topic." << endl;
exit(1);
}
// Create the subscriber and attach to the corresponding
// transport.
DDS::Subscriber_var sub =
participant->create_subscriber(SUBSCRIBER_QOS_DEFAULT,
DDS::SubscriberListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (sub.in ())) {
cerr << "Failed to create_subscriber." << endl;
exit(1);
}
// activate the listener
DDS::DataReaderListener_var listener (new DataReaderListenerImpl);
if (CORBA::is_nil (listener.in ())) {
cerr << "listener is nil." << endl;
exit(1);
}
DataReaderListenerImpl* listener_servant =
dynamic_cast<DataReaderListenerImpl*>(listener.in());
// Create the Datareaders
DDS::DataReaderQos dr_qos;
sub->get_default_datareader_qos (dr_qos);
DDS::DataReader_var dr
= sub->create_datareader(topic.in (),
dr_qos,
listener.in (),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (dr.in ())) {
cerr << "create_datareader failed." << endl;
exit(1);
}
while ( ! listener_servant->received_all ()) {
ACE_OS::sleep (1);
}
if (! listener_servant->passed ()) {
cerr << "test failed - see errors." << endl;
return 1;
}
if (!CORBA::is_nil (participant.in ())) {
participant->delete_contained_entities();
}
if (!CORBA::is_nil (dpf.in ())) {
dpf->delete_participant(participant.in ());
}
::DDS::InstanceHandleSeq handles;
while (1)
{
ACE_OS::sleep(1);
dr->get_matched_publications(handles);
if (handles.length() == 0)
break;
}
ACE_OS::sleep(2);
TheServiceParticipant->shutdown();
} catch (CORBA::Exception& e) {
cerr << "Exception caught in main ():" << endl << e << endl;
return 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[])
{
const int domainId = 411;
const char *topicName = "Stock Quotes";
try {
DDS::DomainParticipantFactory_var dpf;
DDS::DomainParticipant_var participant;
dpf = TheParticipantFactoryWithArgs(argc, argv);
// To Do: Create the participant
participant =
dpf->create_participant(domainId,
PARTICIPANT_QOS_DEFAULT,
DDS::DomainParticipantListener::_nil());
if (CORBA::is_nil (participant.in ())) {
cerr << "create_participant failed." << endl;
return 1 ;
}
// End: Create the participant
QuoterTypeSupportImpl* servant = new QuoterTypeSupportImpl();
PortableServer::ServantBase_var safe_servant = servant;
// To Do: Register the type
if (DDS::RETCODE_OK != servant->register_type(participant.in (),
"")) {
cerr << "Failed to register the QuoterTypeTypeSupport." << endl;
exit(1);
}
// End: Register the type
CORBA::String_var type_name = servant->get_type_name ();
// To Do: Get the (default) topic QoS and create the topic
DDS::TopicQos topic_qos;
participant->get_default_topic_qos(topic_qos);
DDS::Topic_var topic =
participant->create_topic(topicName,
type_name.in (),
topic_qos,
DDS::TopicListener::_nil());
if (CORBA::is_nil (topic.in ())) {
cerr << "Failed to create_topic." << endl;
exit(1);
}
// End: Get the (default) topic QoS and create the topic
// To Do: Create the subscriber
DDS::Subscriber_var sub =
participant->create_subscriber(SUBSCRIBER_QOS_DEFAULT,
DDS::SubscriberListener::_nil());
if (CORBA::is_nil (sub.in ())) {
cerr << "Failed to create_subscriber." << endl;
exit(1);
}
// End: Create the subscriber
// jhoffert
// There seem to be problems using auto configurations with an application
// distributed across different nodes. Take this out for now.
// Initialize the transport
TAO::DCPS::TransportImpl_rch tcp_impl =
TheTransportFactory->create_transport_impl (TCP_IMPL_ID,
//::TAO::DCPS::AUTO_CONFIG);
::TAO::DCPS::DONT_AUTO_CONFIG);
TAO::DCPS::TransportConfiguration_rch reader_config =
//TheTransportFactory->get_configuration (SUB_TRAFFIC);
TheTransportFactory->get_configuration (TCP_IMPL_ID);
TAO::DCPS::SimpleTcpConfiguration* reader_tcp_config =
static_cast <TAO::DCPS::SimpleTcpConfiguration*> (reader_config.in ());
if (0 != ACE_OS::strcmp ("default", reader_address_str)) {
ACE_INET_Addr reader_address (reader_address_str);
reader_tcp_config->local_address_ = reader_address;
}
if (0 != tcp_impl->configure (reader_config.in ())) {
ACE_ERROR ((LM_ERROR,
ACE_TEXT("(%P|%t) ::main: ")
ACE_TEXT("Failed to configure the transport.\n")));
exit(1);
}
// jhoffert - End of transport configuration changes
// 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) {
cerr << "Failed to obtain subscriber servant\n" << endl;
exit(1);
}
TAO::DCPS::AttachStatus status = sub_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);
}
// activate the listener
DataReaderListenerImpl listener_servant;
PortableServer::POA_var poa = TheServiceParticipant->the_poa ();
CORBA::Object_var obj = poa->servant_to_reference(&listener_servant);
DDS::DataReaderListener_var listener =
DDS::DataReaderListener::_narrow (obj.in ());
if (CORBA::is_nil (listener.in ())) {
cerr << "listener is nil." << endl;
exit(1);
}
// To Do: Get default data reader QoS and create the data reader.
DDS::DataReaderQos dr_qos;
sub->get_default_datareader_qos (dr_qos);
DDS::DataReader_var dr = sub->create_datareader(topic.in (),
dr_qos,
listener.in ());
if (CORBA::is_nil (dr.in ())) {
cerr << "create_datareader failed." << endl;
exit(1);
}
// End: Get default data reader QoS and create the data reader.
// To Do: Set up the constraints for when the subscriber is done
// receiving updates.
int expected = 10;
while ( listener_servant.num_reads() < expected) {
ACE_OS::sleep (1);
}
// End: Set up the constraints for how long the subscriber should
// receive updates.
// To Do: Delete the participant's contained entities
if (!CORBA::is_nil (participant.in ())) {
participant->delete_contained_entities();
}
// End: Delete the participant's contained entities
if (!CORBA::is_nil (dpf.in ())) {
dpf->delete_participant(participant.in ());
}
::DDS::InstanceHandleSeq handles;
while (1)
{
ACE_OS::sleep(1);
dr->get_matched_publications(handles);
if (handles.length() == 0)
break;
}
ACE_OS::sleep(2);
TheTransportFactory->release();
TheServiceParticipant->shutdown ();
} catch (CORBA::Exception& e) {
cerr << "Exception caught in main ():" << endl << e << endl;
return 1;
}
return 0;
}
int ACE_TMAIN(int argc, ACE_TCHAR* argv[])
{
try
{
DDS::DomainParticipantFactory_var dpf;
DDS::DomainParticipant_var participant;
dpf = TheParticipantFactoryWithArgs(argc, argv);
participant = dpf->create_participant(411,
PARTICIPANT_QOS_DEFAULT,
DDS::DomainParticipantListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (participant.in ())) {
cerr << "create_participant failed." << endl;
return 1 ;
}
Test::DataTypeSupportImpl * const dts_servant =
new Test::DataTypeSupportImpl;
if (DDS::RETCODE_OK != dts_servant->register_type(participant.in (),
""))
{
cerr << "Failed to register the DataTypeSupport." << endl;
exit(1);
}
CORBA::String_var type_name = dts_servant->get_type_name ();
DDS::TopicQos topic_qos;
participant->get_default_topic_qos(topic_qos);
DDS::Topic_var topic =
participant->create_topic("Data",
type_name.in (),
topic_qos,
DDS::TopicListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (topic.in ())) {
cerr << "Failed to create_topic." << endl;
exit(1);
}
size_t const num_partitions =
sizeof (Test::Requested::PartitionConfigs)
/ sizeof (Test::Requested::PartitionConfigs[0]);
Test::PartitionConfig const * const begin =
Test::Requested::PartitionConfigs;
Test::PartitionConfig const * const end =
begin + num_partitions;
// Keep the readers around long enough for the publications and
// subscriptions to match.
std::vector<DDS::DataReader_var> readers (num_partitions);
for (Test::PartitionConfig const * i = begin; i != end; ++i)
{
DDS::SubscriberQos sub_qos;
participant->get_default_subscriber_qos (sub_qos);
// Specify partitions we're requesting.
CORBA::ULong n = 0;
DDS::StringSeq & names = sub_qos.partition.name;
for (char const * const * s = (*i).partitions;
s != 0 && *s != 0;
++s, ++n)
{
CORBA::ULong const new_len = names.length () + 1;
names.length (new_len);
names[n] = *s;
}
// Create the subscriber and attach to the corresponding
// transport.
DDS::Subscriber_var sub =
participant->create_subscriber (sub_qos,
DDS::SubscriberListener::_nil (),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (sub.in ()))
{
cerr << "Failed to create_subscriber." << endl;
exit(1);
}
DDS::DataReaderListener_var listener (
new Test::DataReaderListener ((*i).expected_matches));
// 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);
}
readers.push_back (dr);
}
ACE_OS::sleep (15);
// {
// // Force contents of writers vector to be destroyed now.
// std::vector<DDS::DataReader_var> tmp;
// tmp.swap (readers);
// }
if (!CORBA::is_nil (participant.in ())) {
participant->delete_contained_entities();
}
if (!CORBA::is_nil (dpf.in ())) {
dpf->delete_participant(participant.in ());
}
ACE_OS::sleep(2);
TheServiceParticipant->shutdown ();
}
catch (CORBA::Exception& e)
{
cerr << "SUB: Exception caught in main ():" << endl << e << endl;
return 1;
}
return 0;
}
int
ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
try
{
DDS::DomainParticipantFactory_var dpf =
TheParticipantFactoryWithArgs(argc, argv);
DDS::DomainParticipant_var participant =
dpf->create_participant (411,
PARTICIPANT_QOS_DEFAULT,
DDS::DomainParticipantListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (participant.in ()))
{
cerr << "create_participant failed." << endl;
return 1 ;
}
Messenger::MessageTypeSupport_var mts_servant =
new Messenger::MessageTypeSupportImpl;
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);
DataReaderListenerImpl* const listener_servant =
dynamic_cast<DataReaderListenerImpl*>(listener.in());
if (CORBA::is_nil (listener.in ()))
{
cerr << "listener is nil." << endl;
exit(1);
}
// Create the Datareader
DDS::DataReaderQos dr_qos;
sub->get_default_datareader_qos(dr_qos);
dr_qos.durability.kind = DDS::PERSISTENT_DURABILITY_QOS;
DDS::DataReader_var dr =
sub->create_datareader(topic, dr_qos, listener,
OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (dr.in ())) {
cerr << "create_datareader failed." << endl;
exit(1);
}
int const expected = 10;
while (listener_servant->num_reads() < expected)
{
ACE_OS::sleep (1);
}
if (!CORBA::is_nil (participant.in ())) {
participant->delete_contained_entities();
}
if (!CORBA::is_nil (dpf.in ())) {
dpf->delete_participant(participant.in ());
}
ACE_OS::sleep(2);
TheServiceParticipant->shutdown ();
}
catch (CORBA::Exception& e)
{
cerr << "SUB: Exception caught in main ():" << endl << e << endl;
return 1;
}
return 0;
}
int ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
try
{
DDS::DomainParticipantFactory_var dpf;
DDS::DomainParticipant_var participant;
dpf = TheParticipantFactoryWithArgs(argc, argv);
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* mts_servant =
new Messenger::MessageTypeSupportImpl;
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());
if (CORBA::is_nil (topic.in ())) {
cerr << "Failed to create_topic." << endl;
exit(1);
}
// Initialize the transport
OpenDDS::DCPS::TransportImpl_rch tcp_impl =
TheTransportFactory->create_transport_impl (
transport_impl_id,
::OpenDDS::DCPS::AUTO_CONFIG);
// Create the subscriber and attach to the corresponding
// transport.
DDS::Subscriber_var sub =
participant->create_subscriber (SUBSCRIBER_QOS_DEFAULT,
DDS::SubscriberListener::_nil());
if (CORBA::is_nil (sub.in ())) {
cerr << "Failed to create_subscriber." << endl;
exit(1);
}
// Attach the subscriber to the transport.
OpenDDS::DCPS::SubscriberImpl* sub_impl =
dynamic_cast<OpenDDS::DCPS::SubscriberImpl*> (sub.in ());
if (0 == sub_impl) {
cerr << "Failed to obtain subscriber servant\n" << endl;
exit(1);
}
OpenDDS::DCPS::AttachStatus const status =
sub_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);
}
// ----------------------------------------------
{
// Attempt to create a DataReader with intentionally
// incompatible QoS.
DDS::DataReaderQos bogus_qos;
sub->get_default_datareader_qos (bogus_qos);
// Set up a 1 second recurring deadline. DataReader creation
// should fail with this QoS since the requested deadline period
// will be less than the test configured offered deadline
// period.
bogus_qos.deadline.period.sec = 2;
bogus_qos.deadline.period.nanosec = 0;
DDS::DataReader_var tmp_dr =
sub->create_datareader (topic.in (),
bogus_qos,
DDS::DataReaderListener::_nil ());
if (CORBA::is_nil (tmp_dr.in ()))
{
cerr << "ERROR: DataReader creation with bogus QoS failed."
<< endl;
exit (1);
}
ACE_OS::sleep (2);
// Check if the incompatible deadline was correctly flagged.
DDS::RequestedIncompatibleQosStatus_var incompatible_status =
tmp_dr->get_requested_incompatible_qos_status ();
DDS::QosPolicyCountSeq const & policies =
incompatible_status->policies;
bool incompatible_deadline = false;
CORBA::ULong const len = policies.length ();
for (CORBA::ULong i = 0; i < len; ++i)
{
if (policies[i].policy_id == DDS::DEADLINE_QOS_POLICY_ID)
{
incompatible_deadline = true;
break;
}
}
if (!incompatible_deadline)
{
cerr << "ERROR: A DataReader/Writer association was created " << endl
<< " despite use of deliberately incompatible deadline "
<< "QoS." << endl;
exit (1);
}
}
// ----------------------------------------------
// Create the listener.
DDS::DataReaderListener_var listener (new DataReaderListenerImpl);
if (CORBA::is_nil (listener.in ()))
{
cerr << "ERROR: listener is nil." << endl;
exit(1);
}
DDS::DataReaderQos dr_qos; // Good QoS.
sub->get_default_datareader_qos (dr_qos);
// Set up a 5 second recurring deadline.
static DDS::Duration_t const DEADLINE_PERIOD =
{
5, // seconds
0 // nanoseconds
};
assert (DEADLINE_PERIOD.sec > 1); // Requirement for the test.
// Time to sleep waiting for deadline periods to expire
long const NUM_EXPIRATIONS = 2;
ACE_Time_Value const SLEEP_DURATION (
OpenDDS::DCPS::duration_to_time_value (DEADLINE_PERIOD)
* 2
+ ACE_Time_Value (1));
dr_qos.deadline.period.sec = DEADLINE_PERIOD.sec;
dr_qos.deadline.period.nanosec = DEADLINE_PERIOD.nanosec;
// First data reader will have a listener to test listener
// callback on deadline expiration.
DDS::DataReader_var dr1 =
sub->create_datareader (topic.in (),
dr_qos,
listener.in ());
// Second data reader will not have a listener to test proper
// handling of a nil listener in the deadline handling code.
DDS::DataReader_var dr2 =
sub->create_datareader (topic.in (),
dr_qos,
DDS::DataReaderListener::_nil ());
if (CORBA::is_nil (dr1.in ()) || CORBA::is_nil (dr2.in ()))
{
cerr << "ERROR: create_datareader failed." << endl;
exit(1);
}
// ----------------------------------------------
// Wait for deadline periods to expire.
ACE_OS::sleep (SLEEP_DURATION);
DDS::RequestedDeadlineMissedStatus deadline_status1 =
dr1->get_requested_deadline_missed_status();
DDS::RequestedDeadlineMissedStatus deadline_status2 =
dr2->get_requested_deadline_missed_status();
if (deadline_status1.total_count != NUM_EXPIRATIONS
|| deadline_status2.total_count != NUM_EXPIRATIONS)
{
cerr << "ERROR: Expected number of missed requested "
<< "deadlines (" << NUM_EXPIRATIONS << ") " << "did " << endl
<< " not occur ("
<< deadline_status1.total_count << " and/or "
<< deadline_status2.total_count << ")." << endl;
exit (1);
}
if (deadline_status1.total_count_change != NUM_EXPIRATIONS
|| deadline_status2.total_count_change != NUM_EXPIRATIONS)
{
cerr << "ERROR: Incorrect missed requested "
<< "deadline count change" << endl
<< " ("
<< deadline_status1.total_count_change
<< " and/or "
<< deadline_status2.total_count_change
<< " instead of " << NUM_EXPIRATIONS << ")."
<< endl;
exit (1);
}
// Wait for another set of deadline periods to expire.
ACE_OS::sleep (SLEEP_DURATION);
deadline_status1 = dr1->get_requested_deadline_missed_status();
deadline_status2 = dr2->get_requested_deadline_missed_status();
if (deadline_status1.total_count != NUM_EXPIRATIONS * 2
|| deadline_status2.total_count != NUM_EXPIRATIONS * 2)
{
cerr << "ERROR: Another expected number of missed requested "
<< "deadlines (" << NUM_EXPIRATIONS * 2 << ")" << endl
<< " did not occur ("
<< deadline_status1.total_count << " and/or "
<< deadline_status2.total_count << ")." << endl;
exit (1);
}
if (deadline_status1.total_count_change != NUM_EXPIRATIONS
|| deadline_status2.total_count_change != NUM_EXPIRATIONS)
{
cerr << "ERROR: Incorrect missed requested "
<< "deadline count" << endl
<< " change ("
<< deadline_status1.total_count_change
<< "and/or "
<< deadline_status2.total_count_change
<< " instead of " << NUM_EXPIRATIONS << ")." << endl;
exit (1);
}
// Create 3rd data reader to trigger the data writers to write.
DDS::DataReader_var dr3 =
sub->create_datareader (topic.in (),
dr_qos,
DDS::DataReaderListener::_nil ());
DataReaderListenerImpl* listener_servant =
dynamic_cast<DataReaderListenerImpl*>(listener.in());
int expected = 10;
while ( listener_servant->num_reads() < expected) {
ACE_OS::sleep (1);
}
// @todo We still need a check proper updating of the
// @c DDS::RequestedDeadlineMissedStatus::last_instance_handle
// field.
if (!CORBA::is_nil (participant.in ())) {
participant->delete_contained_entities();
}
if (!CORBA::is_nil (dpf.in ())) {
dpf->delete_participant(participant.in ());
}
ACE_OS::sleep(2);
TheTransportFactory->release();
TheServiceParticipant->shutdown ();
}
catch (CORBA::Exception& e)
{
cerr << "SUB: Exception caught in main ():" << endl << e << endl;
return 1;
}
return 0;
}
void KVStore::init() {
DDS::DomainId_t myDomain = NULL;
DDS::DomainParticipantFactory_var dpf;
DDS::DomainParticipant_var dp;
DDS::Subscriber_var subscriber;
DDS::Publisher_var publisher;
DDS::DomainParticipantQos dpQos;
DDS::TopicQos tQos;
DDS::SubscriberQos sQos;
DDS::DataReaderQos drQos;
DDS::PublisherQos pQos;
DDS::DataWriterQos dwQos;
DDS::Topic_var topic;
DDSKVStore::TransactionTypeSupport_var ts;
// Create Participants
dpf = DDS::DomainParticipantFactory::get_instance();
dpf->get_default_participant_qos(dpQos);
dp = dpf->create_participant(myDomain, dpQos, NULL, DDS::STATUS_MASK_NONE);
// Create Subscriber
dp->get_default_subscriber_qos(sQos);
sQos.partition.name.length(1);
sQos.partition.name[0] = partition.c_str();
subscriber = dp->create_subscriber(sQos, NULL, DDS::STATUS_MASK_NONE);
// Create Publisher
dp->get_default_publisher_qos(pQos);
pQos.partition.name.length(1);
pQos.partition.name[0] = partition.c_str();
publisher = dp->create_publisher(pQos, NULL, DDS::STATUS_MASK_NONE);
// Set DataReader QoS settings
subscriber->get_default_datareader_qos(drQos);
drQos.reliability.kind = DDS::RELIABLE_RELIABILITY_QOS;
drQos.history.kind = DDS::KEEP_LAST_HISTORY_QOS;
drQos.history.depth = 30;
// Set DataWriter QoS settings
publisher->get_default_datawriter_qos(dwQos);
dwQos.reliability.kind = DDS::RELIABLE_RELIABILITY_QOS;
dwQos.history.kind = DDS::KEEP_LAST_HISTORY_QOS;
dwQos.history.depth = 30;
// Set Topic Qos settings
dp->get_default_topic_qos(tQos);
tQos.reliability.kind = DDS::RELIABLE_RELIABILITY_QOS;
tQos.history.kind = DDS::KEEP_LAST_HISTORY_QOS;
tQos.history.depth = 30;
// Create Topic
ts = new DDSKVStore::TransactionTypeSupport();
ts->register_type(dp, "DDSKVStore::Transaction");
topic = dp->create_topic("Transaction", "DDSKVStore::Transaction", tQos,
NULL, DDS::STATUS_MASK_NONE);
// Create Datareader
dataReader = subscriber->create_datareader(topic, drQos, NULL,
DDS::STATUS_MASK_NONE);
transactionDataReader = DDSKVStore::TransactionDataReader::_narrow(
dataReader);
if (dataReader == NULL)
std::cout << "ERROR: DDS Connection failed" << std::endl;
// Create Datawriter
transactionDataWriter = DDSKVStore::TransactionDataWriter::_narrow(
publisher->create_datawriter(topic, dwQos, NULL,
DDS::STATUS_MASK_NONE));
if (transactionDataWriter == NULL)
std::cout << "ERROR: DDS Connection failed" << std::endl;
// Create Readcondition
readCondition = dataReader->create_readcondition(DDS::ANY_SAMPLE_STATE,
DDS::ANY_VIEW_STATE, DDS::ALIVE_INSTANCE_STATE);
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
int status = EXIT_SUCCESS;
try {
// Initialize DomainParticipantFactory
DDS::DomainParticipantFactory_var dpf =
TheParticipantFactoryWithArgs(argc, argv);
bool reliable = true;
int num_messages_expected = 40;
parse_args(argc, argv, reliable, num_messages_expected);
// 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;
qos.durability.kind = DDS::TRANSIENT_LOCAL_DURABILITY_QOS;
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 = reliable ? listener_svt->data_consistent() : true;
std::string error = "";
bool show_data_loss = true;
if (reliable && data_consistent && received < num_messages_expected) {
error = "ERROR: ";
status = EXIT_FAILURE;
}
else if (!data_consistent) {
status = EXIT_FAILURE;
show_data_loss = false;
}
if (show_data_loss && num_messages_expected) {
const unsigned int missed_msgs = (num_messages_expected - received);
const unsigned int percent = (missed_msgs * 100) / num_messages_expected;
std::cout << error
<< "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
{
DDS::DomainParticipantFactory_var dpf;
DDS::DomainParticipant_var participant;
dpf = TheParticipantFactoryWithArgs(argc, argv);
participant =
dpf->create_participant(11,
PARTICIPANT_QOS_DEFAULT,
DDS::DomainParticipantListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (participant.in ())) {
cerr << "create_participant failed." << endl;
return 1 ;
}
Messenger::MessageTypeSupportImpl* mts_servant =
new Messenger::MessageTypeSupportImpl;
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);
}
DDS::DataReaderQos dr_qos;
sub->get_default_datareader_qos (dr_qos);
// Make reliable
dr_qos.reliability.kind = DDS::RELIABLE_RELIABILITY_QOS;
// Set up a 5 second recurring deadline.
dr_qos.deadline.period.sec = 5;
dr_qos.deadline.period.nanosec = 0;
// Create two listeners. One for each DataReader.
DDS::DataReaderListener_var listener1 (new DataReaderListenerImpl);
if (CORBA::is_nil (listener1.in ()))
{
cerr << "ERROR: listener1 is nil." << endl;
exit(1);
}
DDS::DataReaderListener_var listener2 (new DataReaderListenerImpl);
if (CORBA::is_nil (listener2.in ()))
{
cerr << "ERROR: listener2 is nil." << endl;
exit(1);
}
// First data reader has 5 second deadline period.
DDS::DataReader_var dr1 =
sub->create_datareader (topic.in (),
dr_qos,
listener1.in (),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
// Set up a 3 second recurring deadline.
dr_qos.deadline.period.sec = 3;
dr_qos.deadline.period.nanosec = 0;
// Second data reader has 3 second deadline period which
// is not compatible with DataWriter.
DDS::DataReader_var dr2 =
sub->create_datareader (topic.in (),
dr_qos,
listener2.in (),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (dr1.in ()) || CORBA::is_nil (dr2.in ()))
{
cerr << "ERROR: create_datareader failed." << endl;
exit(1);
}
DataReaderListenerImpl* listener_servant1 =
dynamic_cast<DataReaderListenerImpl*>(listener1.in());
DataReaderListenerImpl* listener_servant2 =
dynamic_cast<DataReaderListenerImpl*>(listener2.in());
int expected = 10;
// Writer of deadline 4 -> Reader of deadline 5
while ( listener_servant1->num_reads() < expected) {
//cout << "subscriber listener1 waiting for " << expected
//<< " reads, got " << listener_servant1->num_reads() << std::endl;
ACE_OS::sleep (1);
}
// Writer of deadline 4 and Reader of deadline 3 is not
// compatible so second DataReader should not receive
// any message from DataWriter.
if (listener_servant2->num_reads() > 0)
{
cerr << "ERROR: second DataReader should not receive message from "
<< "datawriter as their deadline QoS is not compatible" << endl;
exit (1);
}
// Wait for dr1 to be unmatched from the writer (due to writer set_qos).
ACE_DEBUG((LM_DEBUG, "(%P|%t) check for dr1 unmatch\n"));
DDS::WaitSet_var ws = new DDS::WaitSet;
DDS::StatusCondition_var sc = dr1->get_statuscondition();
sc->set_enabled_statuses(DDS::SUBSCRIPTION_MATCHED_STATUS);
ws->attach_condition(sc);
DDS::SubscriptionMatchedStatus matched;
const DDS::Duration_t timeout = {5, 0}; // seconds
while (dr1->get_subscription_matched_status(matched) == DDS::RETCODE_OK
&& matched.current_count == matched.total_count)
{
DDS::ConditionSeq active;
ACE_DEBUG((LM_DEBUG, "(%P|%t) wait for dr1 unmatch\n"));
if (ws->wait(active, timeout) == DDS::RETCODE_TIMEOUT)
{
cerr << "ERROR: timeout expired while waiting for dr1 to be "
"unmatched from the writer which now has a 6 second deadline\n";
exit (1);
}
}
ws->detach_condition(sc);
ACE_DEBUG((LM_DEBUG, "(%P|%t) done dr1 unmatch\n"));
// Now change second DataReader to have deadline period to be 5 seconds. This
// value is compatible with DataWriter so it will be matched.
dr_qos.deadline.period.sec = 5;
if (dr2->set_qos (dr_qos) != ::DDS::RETCODE_OK)
{
cerr << "ERROR: DataReader changed deadline period to make it compatible "
<< "with datawriter" << endl;
exit (1);
}
// second DataReader should receive 20 messages so far.
while ( listener_servant1->num_reads() < 2 * expected) {
//cout << "subscriber listener1 waiting for " << 2 * expected
//<< " reads, got " << listener_servant1->num_reads() << std::endl;
ACE_OS::sleep (1);
}
// second DataReader should receive 10 messages.
while ( listener_servant2->num_reads() < expected) {
//cout << "subscriber listener2 waiting for " << expected
//<< " reads, got " << listener_servant2->num_reads() << std::endl;
ACE_OS::sleep (1);
}
// During this period, the 5 second should have at most 1 missed
// deadline, but with 3 seconds, it should have at least 2 missed
// deadline.
ACE_OS::sleep (9);
if (listener_servant2->num_deadline_missed () > 1)
{
cerr << "ERROR: failed to verify deadline missed count " << endl;
exit (1);
}
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 << "SUB: Exception caught in main ():" << endl << e << endl;
return 1;
}
TheServiceParticipant->shutdown ();
return 0;
}
int ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
try
{
DDS::DomainParticipantFactory_var dpf;
DDS::DomainParticipant_var participant;
dpf = TheParticipantFactoryWithArgs(argc, argv);
participant =
dpf->create_participant(11,
PARTICIPANT_QOS_DEFAULT,
DDS::DomainParticipantListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (participant.in ())) {
cerr << "create_participant failed." << endl;
return 1 ;
}
Messenger::MessageTypeSupportImpl* mts_servant =
new Messenger::MessageTypeSupportImpl;
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);
}
// ----------------------------------------------
{
// Attempt to create a DataReader with intentionally
// incompatible QoS.
DDS::DataReaderQos bogus_qos;
sub->get_default_datareader_qos (bogus_qos);
// Set up a 2 second recurring deadline. DataReader creation
// should fail with this QoS since the requested deadline period
// will be less than the test configured offered deadline
// period.
bogus_qos.deadline.period.sec = 2;
bogus_qos.deadline.period.nanosec = 0;
DDS::DataReader_var tmp_dr =
sub->create_datareader (topic.in (),
bogus_qos,
DDS::DataReaderListener::_nil (),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (tmp_dr.in ()))
{
cerr << "ERROR: DataReader creation with bogus QoS failed."
<< endl;
exit (1);
}
DDS::StatusCondition_var cond = tmp_dr->get_statuscondition();
cond->set_enabled_statuses(DDS::REQUESTED_INCOMPATIBLE_QOS_STATUS);
DDS::WaitSet_var ws = new DDS::WaitSet;
ws->attach_condition(cond);
DDS::Duration_t four_sec = {4, 0};
DDS::ConditionSeq active;
ws->wait(active, four_sec);
// Check if the incompatible deadline was correctly flagged.
if ((active.length() == 0) || (active[0] != cond)) {
cerr << "ERROR: Failed to get requested incompatible qos status" << endl;
exit (1);
}
DDS::RequestedIncompatibleQosStatus incompatible_status;
if (tmp_dr->get_requested_incompatible_qos_status (incompatible_status) != ::DDS::RETCODE_OK)
{
cerr << "ERROR: Failed to get requested incompatible qos status" << endl;
exit (1);
}
DDS::QosPolicyCountSeq const & policies =
incompatible_status.policies;
bool incompatible_deadline = false;
CORBA::ULong const len = policies.length ();
for (CORBA::ULong i = 0; i < len; ++i)
{
if (policies[i].policy_id == DDS::DEADLINE_QOS_POLICY_ID)
{
incompatible_deadline = true;
break;
}
}
if (!incompatible_deadline)
{
cerr << "ERROR: A DataReader/Writer association was created " << endl
<< " despite use of deliberately incompatible deadline "
<< "QoS." << endl;
exit (1);
}
}
// ----------------------------------------------
// Create the listener.
DDS::DataReaderListener_var listener (new DataReaderListenerImpl);
DataReaderListenerImpl* listener_servant =
dynamic_cast<DataReaderListenerImpl*>(listener.in());
if (CORBA::is_nil (listener.in ()))
{
cerr << "ERROR: listener is nil." << endl;
exit(1);
}
DDS::DataReaderQos dr_qos; // Good QoS.
sub->get_default_datareader_qos (dr_qos);
assert (DEADLINE_PERIOD.sec > 1); // Requirement for the test.
// First data reader will have a listener to test listener
// callback on deadline expiration.
DDS::DataReader_var dr1 =
sub->create_datareader (topic.in (),
dr_qos,
listener.in (),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
// Second data reader will not have a listener to test proper
// handling of a nil listener in the deadline handling code.
DDS::DataReader_var dr2 =
sub->create_datareader (topic.in (),
dr_qos,
DDS::DataReaderListener::_nil (),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (dr1.in ()) || CORBA::is_nil (dr2.in ()))
{
cerr << "ERROR: create_datareader failed." << endl;
exit(1);
}
dr_qos.deadline.period.sec = DEADLINE_PERIOD.sec;
dr_qos.deadline.period.nanosec = DEADLINE_PERIOD.nanosec;
// Reset qos to have deadline. The watch dog now starts.
if (dr1->set_qos (dr_qos) != ::DDS::RETCODE_OK
|| dr2->set_qos (dr_qos) != ::DDS::RETCODE_OK)
{
cerr << "ERROR: set deadline qos failed." << endl;
exit(1);
}
Messenger::MessageDataReader_var message_dr1 =
Messenger::MessageDataReader::_narrow(dr1.in());
Messenger::MessageDataReader_var message_dr2 =
Messenger::MessageDataReader::_narrow(dr2.in());
int max_attempts = 10;
int attempts = 0;
// Synchronize with publisher. Wait until both associate with DataWriter.
while (attempts < max_attempts)
{
::DDS::SubscriptionMatchedStatus status1;
::DDS::SubscriptionMatchedStatus status2;
if (dr1->get_subscription_matched_status (status1) == ::DDS::RETCODE_OK
&& dr2->get_subscription_matched_status (status2) == ::DDS::RETCODE_OK)
{
if (status1.total_count == 1 && status2.total_count == 1)
break;
++ attempts;
ACE_OS::sleep (1);
}
else
{
cerr << "ERROR: Failed to get subscription matched status" << endl;
exit (1);
}
}
if (attempts >= max_attempts)
{
cerr << "ERROR: failed to make associations. " << endl;
exit (1);
}
// ----------------------------------------------
ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%P|%t) Subscriber: sleep for %d milliseconds\n"),
SLEEP_DURATION.msec()));
// Wait for deadline periods to expire.
ACE_OS::sleep (SLEEP_DURATION);
ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%P|%t) Subscriber: now verify missed ")
ACE_TEXT ("deadline status \n")));
DDS::RequestedDeadlineMissedStatus deadline_status1;
if (dr1->get_requested_deadline_missed_status(deadline_status1) != ::DDS::RETCODE_OK)
{
cerr << "ERROR: Failed to get requested deadline missed status" << endl;
exit (1);
}
DDS::RequestedDeadlineMissedStatus deadline_status2;
if (dr2->get_requested_deadline_missed_status(deadline_status2) != ::DDS::RETCODE_OK)
{
cerr << "ERROR: Failed to get requested deadline missed status" << endl;
exit (1);
}
ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%P|%t) Subscriber: got missed")
ACE_TEXT ("deadline status \n")));
Messenger::Message message;
message.subject_id = 99;
::DDS::InstanceHandle_t dr1_hd1 = message_dr1->lookup_instance (message);
::DDS::InstanceHandle_t dr2_hd1 = message_dr2->lookup_instance (message);
message.subject_id = 100;
::DDS::InstanceHandle_t dr1_hd2 = message_dr1->lookup_instance (message);
::DDS::InstanceHandle_t dr2_hd2 = message_dr2->lookup_instance (message);
if (deadline_status1.last_instance_handle != dr1_hd1
&& deadline_status1.last_instance_handle != dr1_hd2)
{
cerr << "ERROR: Expected DR1 last instance handle ("
<< dr1_hd1 << " or " << dr1_hd2 << ") did not occur ("
<< deadline_status1.last_instance_handle << ")" << endl;
exit (1);
}
if (deadline_status2.last_instance_handle != dr2_hd1
&& deadline_status2.last_instance_handle != dr2_hd2)
{
cerr << "ERROR: Expected DR2 last instance handle ("
<< dr2_hd1 << " or " << dr2_hd2 << ") did not occur ("
<< deadline_status2.last_instance_handle << endl;
exit (1);
}
//The reader deadline period is 5 seconds and writer writes
//each instance every 9 seconds, so after SLEEP_DURATION(11secs),
//the deadline missed should be 1 per instance
if (deadline_status1.total_count != NUM_INSTANCE
|| deadline_status2.total_count != NUM_INSTANCE)
{
cerr << "ERROR: Expected number of missed requested "
<< "deadlines (" << NUM_INSTANCE << ") " << "did " << endl
<< " not occur ("
<< deadline_status1.total_count << " and/or "
<< deadline_status2.total_count << ")." << endl;
exit (1);
}
if (deadline_status1.total_count_change != NUM_INSTANCE
|| deadline_status2.total_count_change != NUM_INSTANCE)
{
cerr << "ERROR: Incorrect missed requested "
<< "deadline count change" << endl
<< " ("
<< deadline_status1.total_count_change
<< " and/or "
<< deadline_status2.total_count_change
<< " instead of " << NUM_EXPIRATIONS * NUM_INSTANCE << ")."
<< endl;
exit (1);
}
// Here the writers should continue writes all samples with
// .5 second interval.
ACE_Time_Value no_miss_period = num_messages * write_interval;
ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%P|%t) Subscriber: sleep for %d msec\n"),
(SLEEP_DURATION + no_miss_period).msec()));
// Wait for another set of deadline periods(5 + 11 secs).
// During this period, the writers continue write all samples with
// .5 second interval.
ACE_OS::sleep (SLEEP_DURATION + no_miss_period);
ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%P|%t) Subscriber: now verify missed ")
ACE_TEXT ("deadline status \n")));
if ((dr1->get_requested_deadline_missed_status(deadline_status1) != ::DDS::RETCODE_OK)
|| (dr2->get_requested_deadline_missed_status(deadline_status2) != ::DDS::RETCODE_OK))
{
cerr << "ERROR: failed to get requested deadline missed status" << endl;
exit (1);
}
ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%P|%t) Subscriber: got missed")
ACE_TEXT ("deadline status \n")));
if (deadline_status1.last_instance_handle != dr1_hd1
&& deadline_status1.last_instance_handle != dr1_hd2)
{
cerr << "ERROR: Expected DR1 last instance handle ("
<< dr1_hd1 << " or " << dr1_hd2 << ") did not occur ("
<< deadline_status1.last_instance_handle << ")" << endl;
exit (1);
}
if (deadline_status2.last_instance_handle != dr2_hd1
&& deadline_status2.last_instance_handle != dr2_hd2)
{
cerr << "ERROR: Expected DR2 last instance handle ("
<< dr2_hd1 << " or " << dr2_hd2 << ") did not occur ("
<< deadline_status2.last_instance_handle << endl;
exit (1);
}
if (deadline_status1.total_count != 3 * NUM_INSTANCE
|| deadline_status2.total_count != 3 * NUM_INSTANCE)
{
cerr << "ERROR: Another expected number of missed requested "
<< "deadlines (" << NUM_INSTANCE << ")" << endl
<< " did not occur ("
<< deadline_status1.total_count << " and/or "
<< deadline_status2.total_count << ")." << endl;
exit (1);
}
if (deadline_status1.total_count_change != 2 * NUM_INSTANCE
|| deadline_status2.total_count_change != 2 * NUM_INSTANCE)
{
cerr << "ERROR: Incorrect missed requested "
<< "deadline count" << endl
<< " change ("
<< deadline_status1.total_count_change
<< "and/or "
<< deadline_status2.total_count_change
<< " instead of " << NUM_EXPIRATIONS << ")." << endl;
exit (1);
}
int expected = 10;
while ( listener_servant->num_arrived() < expected) {
ACE_OS::sleep (1);
}
if (!CORBA::is_nil (participant.in ())) {
participant->delete_contained_entities();
}
if (!CORBA::is_nil (dpf.in ())) {
dpf->delete_participant(participant.in ());
}
ACE_OS::sleep(2);
TheServiceParticipant->shutdown ();
}
catch (CORBA::Exception& e)
{
cerr << "SUB: Exception caught in main ():" << endl << e << endl;
return 1;
}
return 0;
}
int ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
try
{
DDS::DomainParticipantFactory_var dpf;
DDS::DomainParticipant_var participant;
dpf = TheParticipantFactoryWithArgs(argc, argv);
participant = dpf->create_participant(411,
PARTICIPANT_QOS_DEFAULT,
DDS::DomainParticipantListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (participant.in ())) {
cerr << "create_participant failed." << endl;
return 1 ;
}
if (parse_args (argc, argv) == -1) {
return -1;
}
MessageTypeSupport_var mts = new MessageTypeSupportImpl();
if (DDS::RETCODE_OK != mts->register_type(participant.in (), "")) {
cerr << "Failed to register the MessageTypeTypeSupport." << endl;
exit(1);
}
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 ())) {
cerr << "ERROR 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 << "ERROR Failed to create_subscriber." << endl;
exit(1);
}
// activate the listener
DDS::DataReaderListener_var listener = new DataReaderListenerImpl;
DataReaderListenerImpl &listener_servant =
*dynamic_cast<DataReaderListenerImpl*>(listener.in());
if (CORBA::is_nil (listener.in ())) {
cerr << "ERROR listener is nil." << endl;
exit(1);
}
::DDS::DataReaderQos dr_qos;
sub->get_default_datareader_qos (dr_qos);
dr_qos.liveliness.lease_duration.sec = LEASE_DURATION_SEC ;
dr_qos.liveliness.lease_duration.nanosec = 0 ;
// Create the Datareaders
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 << "ERROR create_datareader failed." << endl;
exit(1);
}
int count = 0;
while ((++count < 60) && ((listener_servant.num_reads() < total_num_messages)))
{
ACE_OS::sleep (1);
}
ACE_OS::sleep(2);
ACE_DEBUG((LM_INFO,
"Subscriber got %d of %d messages, "
"and %d of %d callbacks, deleting entities\n",
(int) listener_servant.num_reads(), total_num_messages,
listener_servant.num_liveliness_change_callbacks(), num_liveliness_change_callbacks));
if (!CORBA::is_nil (participant.in ())) {
participant->delete_contained_entities();
}
if (!CORBA::is_nil (dpf.in ())) {
dpf->delete_participant(participant.in ());
}
ACE_OS::sleep(2);
TheServiceParticipant->shutdown ();
if (listener_servant.num_liveliness_change_callbacks () != num_liveliness_change_callbacks)
{
cerr
<< "ERROR: did not receive liveliness change callbacks as expected.("
<< listener_servant.num_liveliness_change_callbacks () << "/"
<< num_liveliness_change_callbacks << ")" << endl;
return 1;
}
}
catch (CORBA::Exception& e)
{
cerr << "ERROR: subscriber Exception caught in main ():" << endl << e << endl;
return 1;
}
return 0;
}
int ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
try
{
DDS::DomainParticipantFactory_var dpf;
DDS::DomainParticipant_var participant;
if( OpenDDS::DCPS::DCPS_debug_level > 0) {
ACE_DEBUG((LM_DEBUG,
ACE_TEXT("(%P|%t) subscriber: ")
ACE_TEXT("initialization starting.\n")
));
}
dpf = TheParticipantFactoryWithArgs(argc, argv);
participant = dpf->create_participant(411,
PARTICIPANT_QOS_DEFAULT,
DDS::DomainParticipantListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (participant.in ())) {
cerr << "create_participant failed." << endl;
return 1 ;
}
if( OpenDDS::DCPS::DCPS_debug_level > 0) {
ACE_DEBUG((LM_DEBUG,
ACE_TEXT("(%P|%t) subscriber: ")
ACE_TEXT("participant created.\n")
));
}
if (parse_args (argc, argv) == -1) {
return -1;
}
if( OpenDDS::DCPS::DCPS_debug_level > 0) {
ACE_DEBUG((LM_DEBUG,
ACE_TEXT("(%P|%t) subscriber: ")
ACE_TEXT("command line parsed.\n")
));
}
MessageTypeSupportImpl* mts_servant = new MessageTypeSupportImpl();
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 ();
if( OpenDDS::DCPS::DCPS_debug_level > 0) {
ACE_DEBUG((LM_DEBUG,
ACE_TEXT("(%P|%t) subscriber: ")
ACE_TEXT("type support installed.\n")
));
}
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);
}
if( OpenDDS::DCPS::DCPS_debug_level > 0) {
ACE_DEBUG((LM_DEBUG,
ACE_TEXT("(%P|%t) subscriber: ")
ACE_TEXT("topic created.\n")
));
}
// Initialize the transport
OpenDDS::DCPS::TransportImpl_rch tcp_impl =
TheTransportFactory->create_transport_impl (transport_impl_id,
::OpenDDS::DCPS::AUTO_CONFIG);
if( OpenDDS::DCPS::DCPS_debug_level > 0) {
ACE_DEBUG((LM_DEBUG,
ACE_TEXT("(%P|%t) subscriber: ")
ACE_TEXT("transport created.\n")
));
}
// 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);
}
if( OpenDDS::DCPS::DCPS_debug_level > 0) {
ACE_DEBUG((LM_DEBUG,
ACE_TEXT("(%P|%t) subscriber: ")
ACE_TEXT("subscriber created.\n")
));
}
// Attach the subscriber to the transport.
OpenDDS::DCPS::SubscriberImpl* sub_impl =
dynamic_cast<OpenDDS::DCPS::SubscriberImpl*> (sub.in ());
if (0 == sub_impl) {
cerr << "Failed to obtain subscriber servant\n" << endl;
exit(1);
}
if( OpenDDS::DCPS::DCPS_debug_level > 0) {
ACE_DEBUG((LM_DEBUG,
ACE_TEXT("(%P|%t) subscriber: ")
ACE_TEXT("servant extracted.\n")
));
}
OpenDDS::DCPS::AttachStatus status = sub_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);
}
if( OpenDDS::DCPS::DCPS_debug_level > 0) {
ACE_DEBUG((LM_DEBUG,
ACE_TEXT("(%P|%t) subscriber: ")
ACE_TEXT("transport attached.\n")
));
}
// activate the listener
DDS::DataReaderListener_var listener (new DataReaderListenerImpl);
DataReaderListenerImpl* listener_servant =
dynamic_cast<DataReaderListenerImpl*>(listener.in());
if (CORBA::is_nil (listener.in ())) {
cerr << "listener is nil." << endl;
exit(1);
}
if( OpenDDS::DCPS::DCPS_debug_level > 0) {
ACE_DEBUG((LM_DEBUG,
ACE_TEXT("(%P|%t) subscriber: ")
ACE_TEXT("listener created.\n")
));
}
// 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);
}
if( OpenDDS::DCPS::DCPS_debug_level > 0) {
ACE_DEBUG((LM_DEBUG,
ACE_TEXT("(%P|%t) subscriber: ")
ACE_TEXT("processing starting.\n")
));
}
int expected = 5;
while ( listener_servant->num_reads() < expected) {
ACE_OS::sleep (1);
}
if (!CORBA::is_nil (participant.in ())) {
participant->delete_contained_entities();
}
if (!CORBA::is_nil (dpf.in ())) {
dpf->delete_participant(participant.in ());
}
ACE_OS::sleep(2);
TheTransportFactory->release();
TheServiceParticipant->shutdown ();
}
catch (CORBA::Exception& e)
{
cerr << "SUB: Exception caught in main ():" << endl << e << endl;
return 1;
}
return 0;
}
int main (int argc, char *argv[])
{
try {
// initialize the participant. the same as in the publisher
DDS::DomainParticipantFactory_var dpf =
TheParticipantFactoryWithArgs(argc, argv);
DDS::DomainParticipant_var participant =
dpf->create_participant(42, // Domain ID
PARTICIPANT_QOS_DEFAULT,
0, // No listener required
OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (!participant)
{
std::cerr << "create_participant failed." << std::endl;
return 1 ;
}
Messenger::MessageTypeSupport_var mts =
new Messenger::MessageTypeSupportImpl();
if (DDS::RETCODE_OK != mts->register_type(participant, ""))
{
std::cerr << "Failed to register the MessageTypeSupport." << std::endl;
return 1;
}
CORBA::String_var type_name = mts->get_type_name ();
DDS::Topic_var topic =
participant->create_topic("Movie Discussion List",
type_name,
TOPIC_QOS_DEFAULT,
0, // No listener required
OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (!topic)
{
std::cerr << "Failed to create_topic." << std::endl;
return 1;
}
// Create the subscriber
DDS::Subscriber_var sub =
participant->create_subscriber(SUBSCRIBER_QOS_DEFAULT,
0, // No listener required
OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (!sub)
{
std::cerr << "Failed to create_subscriber." << std::endl;
return 1;
}
// Associate a listener object with the data reader we create,
// so we can use it to detect when data is available.
// The listener is allocated on the heap and assigned to a//
// DataReaderListener_var object. This type provides
// reference counting behavior so the listener is
// automatically cleaned up when the last reference to it is
// removed. This usage is typical for heap allocations in
// OpenDDS application code and frees the application
// developer from having to actively manage the lifespan of
// the allocated objects.
DDS::DataReaderListener_var listener(new DataReaderListenerImpl);
// Create the data reader
DDS::DataReader_var dr =
sub->create_datareader(topic,
DATAREADER_QOS_DEFAULT,
listener,
OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (!dr) {
std::cerr << "create_datareader failed." << std::endl;
return 1;
}
// clean up
//1. delete all the topics, subscribers and publishers create
// with this participant
//2. when done, use the factory to delete the domain participant.
participant->delete_contained_entities();
dpf->delete_participant(participant);
TheServiceParticipant->shutdown ();
} catch(...)
{
std::cerr << "ERROR!!! exception caught" << std::endl;
}
}
int ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
try {
DDS::DomainParticipantFactory_var dpf;
DDS::DomainParticipant_var participant;
dpf = TheParticipantFactoryWithArgs(argc, argv);
if( parse_args(argc, argv) != 0)
return 1;
ACE_DEBUG((LM_DEBUG, "(%P|%t) subscriber.cpp main()\n"));
participant =
dpf->create_participant(411,
PARTICIPANT_QOS_DEFAULT,
DDS::DomainParticipantListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (participant.in ())) {
cerr << "create_participant failed." << endl;
return 1 ;
}
Messenger::MessageTypeSupportImpl* mts_servant = new Messenger::MessageTypeSupportImpl();
OpenDDS::DCPS::LocalObject_var safe_servant = mts_servant;
if (DDS::RETCODE_OK != mts_servant->register_type(participant.in (),
"")) {
cerr << "Failed to register the MessageTypeTypeSupport." << endl;
exit(1);
}
CORBA::String_var type_name = mts_servant->get_type_name ();
DDS::TopicQos topic_qos;
participant->get_default_topic_qos(topic_qos);
DDS::Topic_var topic =
participant->create_topic("Movie Discussion List",
type_name.in (),
topic_qos,
DDS::TopicListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (topic.in ())) {
cerr << "Failed to create_topic." << endl;
exit(1);
}
// Create the subscriber and attach to the corresponding
// transport.
DDS::Subscriber_var sub =
participant->create_subscriber(SUBSCRIBER_QOS_DEFAULT,
DDS::SubscriberListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (sub.in ())) {
cerr << "Failed to create_subscriber." << endl;
exit(1);
}
// activate the listener
DDS::DataReaderListener_var listener (new DataReaderListenerImpl);
if (CORBA::is_nil (listener.in ())) {
cerr << "listener is nil." << endl;
exit(1);
}
DataReaderListenerImpl* listener_servant =
dynamic_cast<DataReaderListenerImpl*>(listener.in());
// Create the Datareaders
DDS::DataReaderQos dr_qos;
sub->get_default_datareader_qos (dr_qos);
DDS::DataReader_var dr = sub->create_datareader(topic.in (),
dr_qos,
listener.in (),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (dr.in ())) {
cerr << "create_datareader failed." << endl;
exit(1);
}
// Indicate that the subscriber is ready
FILE* readers_ready = ACE_OS::fopen (sub_ready_filename, ACE_TEXT ("w"));
if (readers_ready == 0) {
cerr << "ERROR Unable to create subscriber ready file." << endl;
exit(1);
}
ACE_OS::fclose(readers_ready);
// Wait for the publisher to be ready
FILE* writers_ready = 0;
do {
ACE_Time_Value small_time(0,250000);
ACE_OS::sleep (small_time);
writers_ready = ACE_OS::fopen (pub_ready_filename, ACE_TEXT ("r"));
} while (0 == writers_ready);
ACE_OS::fclose(writers_ready);
// Since the publisher continue sending while the subscriber crashes,
// some messages may be lost, we lower the num_expected_reads by 2.
num_expected_reads -= num_reads_deviation;
FILE* writers_completed = 0;
int timeout_writes = 0;
while ( listener_servant->num_reads() < num_expected_reads) {
// Get the number of the timed out writes from publisher so we
// can re-calculate the number of expected messages. Otherwise,
// the blocking timeout test will never exit from this loop.
if (writers_completed == 0) {
writers_completed = ACE_OS::fopen (pub_finished_filename, ACE_TEXT ("r"));
if (writers_completed != 0) {
if (end_with_publisher)
{
// Since we are in the "bp_timeout" test case that publisher
// close connection when backpressure last longer than
// max_output_pause_period, the publisher ends as it finishes
// sending. As the subscriber sees the publisher is done, it
// changes the read_delay_ms to 0 so it can read all received
// messages and them announce it completed.
int old_read_delay_ms = read_delay_ms;
read_delay_ms = 0;
// Give time to finish reading.
ACE_OS::sleep (old_read_delay_ms/1000 * 2);
break;
}
//writers_completed = ACE_OS::fopen (pub_finished_filename, "r");
fscanf (writers_completed, "%d\n", &timeout_writes);
num_expected_reads -= timeout_writes;
cout << "timed out writes " << timeout_writes << ", we expect "
<< num_expected_reads << endl;
}
}
ACE_OS::sleep (1);
}
// Indicate that the subscriber is done
FILE* readers_completed = ACE_OS::fopen (sub_finished_filename, ACE_TEXT ("w"));
if (readers_completed == 0) {
cerr << "ERROR Unable to create subscriber completed file." << endl;
exit(1);
}
ACE_OS::fclose(readers_completed);
// Wait for 5 seconds to (>passive_reconnect_duration)
// to give transport time to detect the connection lost due to
// backpressure timeout before shutdown the datareader.
if (end_with_publisher)
ACE_OS::sleep (5);
if (!CORBA::is_nil (participant.in ())) {
participant->delete_contained_entities();
}
if (!CORBA::is_nil (dpf.in ())) {
dpf->delete_participant(participant.in ());
}
TheServiceParticipant->shutdown ();
} catch (CORBA::Exception& e) {
cerr << "Exception caught in main ():" << endl << e << endl;
return 1;
}
if (verify_lost_sub_notification
&& actual_lost_sub_notification != expected_lost_sub_notification)
{
ACE_ERROR ((LM_ERROR, "(%P|%t) ERROR: on_subscription_lost called %d times "
"and expected %d times\n", actual_lost_sub_notification,
expected_lost_sub_notification));
return 1;
}
return 0;
}
int main (int argc, char *argv[])
{
try {
DDS::DomainParticipantFactory_var dpf;
DDS::DomainParticipant_var participant;
dpf = TheParticipantFactoryWithArgs(argc, argv);
if( parse_args(argc, argv) != 0)
return 1;
participant =
dpf->create_participant(411,
PARTICIPANT_QOS_DEFAULT,
DDS::DomainParticipantListener::_nil());
if (CORBA::is_nil (participant.in ())) {
ACE_ERROR_RETURN ((LM_ERROR,
"(%P|%t) create_participant failed.\n")
, -1);
}
MessageTypeSupportImpl* mts_servant = new MessageTypeSupportImpl();
PortableServer::ServantBase_var safe_servant = mts_servant;
if (DDS::RETCODE_OK != mts_servant->register_type(participant.in (),
"")) {
ACE_ERROR_RETURN ((LM_ERROR,
"(%P|%t) Failed to register the MessageTypeTypeSupport.\n")
, -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());
if (CORBA::is_nil (topic.in ())) {
ACE_ERROR_RETURN ((LM_ERROR,
"(%P|%t) Failed to create_topic.\n")
, -1);
}
// Initialize the transport
TAO::DCPS::TransportImpl_rch tcp_impl =
TheTransportFactory->create_transport_impl (TCP_IMPL_ID, ::TAO::DCPS::AUTO_CONFIG);
// Indicate that the subscriber is about to become ready
FILE* readers_ready = ACE_OS::fopen (sub_ready_filename, "w");
if (readers_ready == 0) {
ACE_ERROR_RETURN ((LM_ERROR,
"(%P|%t) ERROR Unable to create subscriber ready file.\n")
, -1);
}
ACE_OS::fclose(readers_ready);
// Check if the publisher is up and running
ACE_stat stats;
while (ACE_OS::stat (pub_ready_filename, &stats) == -1)
{
ACE_Time_Value small(0,250000);
ACE_OS::sleep (small);
}
for (int count = 1; count <= sub_reinit_itr; count++)
{
if (verbose) {
ACE_DEBUG ((LM_DEBUG, "(%P|%t) Reinitializing subscriber.\n"));
}
// Create the subscriber and attach to the corresponding
// transport.
DDS::Subscriber_var sub =
participant->create_subscriber(SUBSCRIBER_QOS_DEFAULT,
DDS::SubscriberListener::_nil());
if (CORBA::is_nil (sub.in ())) {
ACE_ERROR_RETURN ((LM_ERROR,
"(%P|%t) Failed to create_subscriber.\n")
, -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,
"(%P|%t) Failed to obtain subscriber servant.\n")
, -1);
}
TAO::DCPS::AttachStatus status = sub_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;
}
ACE_ERROR_RETURN ((LM_ERROR,
"(%P|%t) Failed to attach to the transport. "
"Status == %s.\n"
, status_str.c_str())
, -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,
DDS::DataReaderListener::_nil());
if (CORBA::is_nil (dr.in ())) {
ACE_ERROR_RETURN ((LM_ERROR,
"(%P|%t) create_datareader failed.\n")
, -1);
}
{
ACE_OS::sleep (2);
// This is where a speed-bump should be.
}
if (verbose) {
ACE_DEBUG ((LM_DEBUG, "(%P|%t) *** Destroying Subscriber\n"));
}
// Delete data reader
sub->delete_datareader(dr.in());
// Delete subscriber
participant->delete_subscriber(sub.in());
sub = DDS::Subscriber::_nil();
}
if (!CORBA::is_nil (participant.in ())) {
participant->delete_contained_entities();
}
if (!CORBA::is_nil (dpf.in ())) {
dpf->delete_participant(participant.in ());
}
TheTransportFactory->release();
TheServiceParticipant->shutdown ();
// Indicate that the subscriber is done
FILE* readers_completed = ACE_OS::fopen (sub_finished_filename, "w");
if (readers_completed == 0) {
ACE_ERROR_RETURN ((LM_ERROR,
"(%P|%t) ERROR Unable to create subscriber completed file.\n")
, -1);
}
ACE_OS::fclose(readers_completed);
}
catch (CORBA::Exception& e) {
ACE_ERROR_RETURN ((LM_ERROR,
"(%P|%t) Exception caught in main (): %s (%s).\n"
, e._name (), e._rep_id ())
, -1);
}
return 0;
}
int ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
int result = 0;
ACE_DEBUG ((LM_DEBUG, "(%P|%t) subscriber main\n"));
try
{
DDS::DomainParticipantFactory_var dpf;
DDS::DomainParticipant_var participant;
dpf = TheParticipantFactoryWithArgs(argc, argv);
if (parse_args (argc, argv) == -1) {
return -1;
}
DDS::DomainParticipantQos partQos;
dpf->get_default_participant_qos(partQos);
// set up user data in DP qos
CORBA::ULong part_user_data_len
= static_cast<CORBA::ULong>(ACE_OS::strlen (PART_USER_DATA));
partQos.user_data.value.length (part_user_data_len);
partQos.user_data.value.replace (part_user_data_len,
part_user_data_len,
reinterpret_cast<CORBA::Octet*>(PART_USER_DATA));
participant = dpf->create_participant(411,
partQos,
DDS::DomainParticipantListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (participant.in ())) {
cerr << "subscriber: create_participant failed." << endl;
return 1 ;
}
::Messenger::MessageTypeSupport_var mts = new ::Messenger::MessageTypeSupportImpl();
if (DDS::RETCODE_OK != mts->register_type(participant.in (), "Messenger")) {
cerr << "subscriber: Failed to register the MessageTypeTypeSupport." << endl;
exit(1);
}
CORBA::String_var type_name = mts->get_type_name ();
DDS::TopicQos topic_qos;
participant->get_default_topic_qos(topic_qos);
// set up topic data in topic qos
CORBA::ULong topic_data_len = static_cast<CORBA::ULong>(ACE_OS::strlen (TOPIC_DATA));
topic_qos.topic_data.value.length (topic_data_len);
topic_qos.topic_data.value.replace (topic_data_len, topic_data_len, reinterpret_cast<CORBA::Octet*>(TOPIC_DATA));
DDS::Topic_var topic = participant->create_topic("Movie Discussion List",
type_name.in (),
topic_qos,
DDS::TopicListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (topic.in ())) {
cerr << "subscriber: Failed to create_topic." << endl;
exit(1);
}
// Create the subscriber
DDS::SubscriberQos sub_qos;
participant->get_default_subscriber_qos (sub_qos);
// set up group data in subscriber qos
CORBA::ULong group_data_len = static_cast<CORBA::ULong> (ACE_OS::strlen (GROUP_DATA));
sub_qos.group_data.value.length (group_data_len);
sub_qos.group_data.value.replace (group_data_len, group_data_len, reinterpret_cast<CORBA::Octet*>(GROUP_DATA));
DDS::Subscriber_var sub =
participant->create_subscriber(sub_qos,
DDS::SubscriberListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (sub.in ())) {
cerr << "subscriber: Failed to create_subscriber." << endl;
exit(1);
}
// activate the listener
DDS::DataReaderListener_var listener (new DataReaderListenerImpl);
DataReaderListenerImpl* listener_servant =
dynamic_cast<DataReaderListenerImpl*>(listener.in());
DDS::Subscriber_var builtin = participant->get_builtin_subscriber();
DDS::DataReader_var bitdr =
builtin->lookup_datareader(OpenDDS::DCPS::BUILT_IN_PUBLICATION_TOPIC);
listener_servant->set_builtin_datareader(bitdr.in());
if (CORBA::is_nil (listener.in ())) {
cerr << "subscriber: listener is nil." << endl;
exit(1);
}
// Create the Datareaders
DDS::DataReaderQos dr_qos;
sub->get_default_datareader_qos (dr_qos);
// set up user data in DR qos
CORBA::ULong dr_user_data_len = static_cast<CORBA::ULong>(ACE_OS::strlen (DR_USER_DATA));
dr_qos.user_data.value.length (dr_user_data_len);
dr_qos.user_data.value.replace (dr_user_data_len,
dr_user_data_len,
reinterpret_cast<CORBA::Octet*>(DR_USER_DATA));
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 << "subscriber: create_datareader failed." << endl;
exit(1);
}
// Wait for Monitor 1 done.
FILE* fp = ACE_OS::fopen (synch_fname, ACE_TEXT("r"));
int i = 0;
while (fp == 0 && i < 15)
{
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT("(%P|%t) waiting monitor1 done ...\n")));
ACE_OS::sleep (1);
++i;
fp = ACE_OS::fopen (synch_fname, ACE_TEXT("r"));
}
if (fp != 0)
ACE_OS::fclose (fp);
// Now change the changeable qos. The second monitor should get the updated qos from BIT.
part_user_data_len = static_cast<CORBA::ULong>(ACE_OS::strlen (UPDATED_PART_USER_DATA));
partQos.user_data.value.length (part_user_data_len);
partQos.user_data.value.replace (part_user_data_len,
part_user_data_len,
reinterpret_cast<CORBA::Octet*>(UPDATED_PART_USER_DATA));
participant->set_qos (partQos);
dr_user_data_len = static_cast<CORBA::ULong>(ACE_OS::strlen (UPDATED_DR_USER_DATA));
dr_qos.user_data.value.length (dr_user_data_len);
dr_qos.user_data.value.replace (dr_user_data_len,
dr_user_data_len,
reinterpret_cast<CORBA::Octet*>(UPDATED_DR_USER_DATA));
dr->set_qos (dr_qos);
group_data_len = static_cast<CORBA::ULong> (ACE_OS::strlen (UPDATED_GROUP_DATA));
sub_qos.group_data.value.length (group_data_len);
sub_qos.group_data.value.replace (group_data_len,
group_data_len,
reinterpret_cast<CORBA::Octet*>(UPDATED_GROUP_DATA));
sub->set_qos (sub_qos);
topic_data_len = static_cast<CORBA::ULong>(ACE_OS::strlen (UPDATED_TOPIC_DATA));
topic_qos.topic_data.value.length (topic_data_len);
topic_qos.topic_data.value.replace (topic_data_len,
topic_data_len,
reinterpret_cast<CORBA::Octet*>(UPDATED_TOPIC_DATA));
topic->set_qos (topic_qos);
while ( listener_servant->num_reads() < num_messages) {
ACE_OS::sleep (1);
}
if (listener_servant->builtin_read_errors()) {
cerr << "subscriber: Built in topic read failure." << endl;
result = 1;
}
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 << "subscriber: SUB: Exception caught in main ():" << endl << e << endl;
return 1;
}
return result;
}
int main (int argc, char *argv[])
{
try {
DDS::DomainParticipantFactory_var dpf;
DDS::DomainParticipant_var participant;
dpf = TheParticipantFactoryWithArgs(argc, argv);
if( parse_args(argc, argv) != 0)
return 1;
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* mts_servant = new Messenger::MessageTypeSupportImpl();
TAO::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());
if (CORBA::is_nil (topic.in ())) {
cerr << "Failed to create_topic." << endl;
exit(1);
}
// Initialize the transport
TAO::DCPS::TransportImpl_rch tcp_impl =
TheTransportFactory->create_transport_impl (TCP_IMPL_ID, ::TAO::DCPS::AUTO_CONFIG);
// Create the subscriber and attach to the corresponding
// transport.
DDS::Subscriber_var sub =
participant->create_subscriber(SUBSCRIBER_QOS_DEFAULT,
DDS::SubscriberListener::_nil());
if (CORBA::is_nil (sub.in ())) {
cerr << "Failed to create_subscriber." << endl;
exit(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) {
cerr << "Failed to obtain subscriber servant\n" << endl;
exit(1);
}
TAO::DCPS::AttachStatus status = sub_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);
}
// activate the listener
DataReaderListenerImpl listener_servant;
DDS::DataReaderListener_var listener =
::TAO::DCPS::servant_to_reference (&listener_servant);
if (CORBA::is_nil (listener.in ())) {
cerr << "listener is nil." << endl;
exit(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 ());
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, "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(0,250000);
ACE_OS::sleep (small);
writers_ready = ACE_OS::fopen (pub_ready_filename, "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, "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, "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 ());
}
TheTransportFactory->release();
TheServiceParticipant->shutdown ();
} catch (CORBA::Exception& e) {
cerr << "Exception caught in main ():" << endl << e << endl;
return 1;
}
if (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;
}
