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