int ACE_TMAIN (int argc, ACE_TCHAR *argv[]) { DDS::DomainParticipantFactory_var dpf = DDS::DomainParticipantFactory::_nil(); DDS::DomainParticipant_var participant = DDS::DomainParticipant::_nil(); try { // Initialize, and create a DomainParticipant // (same as publishe dpf = TheParticipantFactoryWithArgs(argc, argv); participant = dpf->create_participant( QUOTER_DOMAIN_ID, PARTICIPANT_QOS_DEFAULT, DDS::DomainParticipantListener::_nil(), ::OpenDDS::DCPS::DEFAULT_STATUS_MASK); if (CORBA::is_nil (participant.in ())) { cerr << "create_participant failed." << endl; ACE_OS::exit(1); } // Create a subscriber for the two topics // (SUBSCRIBER_QOS_DEFAULT is defined in Marked_Default_Qos.h) 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 << "create_subscriber failed." << endl; ACE_OS::exit(1); } // Initialize the transport; the TRANSPORT_IMPL_ID must match the // value in the configuration file. OpenDDS::DCPS::TransportImpl_rch trans_impl = TheTransportFactory->create_transport_impl (TRANSPORT_IMPL_ID, OpenDDS::DCPS::AUTO_CONFIG); // Attach the subscriber to the TCP transport. // (almost identical to the publisher) OpenDDS::DCPS::SubscriberImpl* sub_impl = dynamic_cast< OpenDDS::DCPS::SubscriberImpl* >(sub.in ()); if (0 == sub_impl) { cerr << "Failed to obtain subscriber servant" << endl; ACE_OS::exit(1); } OpenDDS::DCPS::AttachStatus status = sub_impl->attach_transport(trans_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; ACE_OS::exit(1); } // Register the Quote type // (same as publisher) StockQuoter::QuoteTypeSupport_var quote_servant = new StockQuoter::QuoteTypeSupportImpl(); if (DDS::RETCODE_OK != quote_servant->register_type(participant.in (), QUOTER_QUOTE_TYPE)) { cerr << "register_type for " << QUOTER_QUOTE_TYPE << " failed." << endl; ACE_OS::exit(1); } // Register the ExchangeEvent type // (same as publisher) StockQuoter::ExchangeEventTypeSupport_var exchange_evt_servant = new StockQuoter::ExchangeEventTypeSupportImpl(); if (DDS::RETCODE_OK != exchange_evt_servant->register_type(participant.in (), QUOTER_EXCHANGE_EVENT_TYPE)) { cerr << "register_type for " << QUOTER_EXCHANGE_EVENT_TYPE << " failed." << endl; ACE_OS::exit(1); } // Get QoS to use for our two topics // (same as publisher) DDS::TopicQos default_topic_qos; participant->get_default_topic_qos(default_topic_qos); // Create a topic for the Quote type... // Could also use TOPIC_QOS_DEFAULT instead // (same as publisher) DDS::Topic_var quote_topic = participant->create_topic (QUOTER_QUOTE_TOPIC, QUOTER_QUOTE_TYPE, default_topic_qos, DDS::TopicListener::_nil(), ::OpenDDS::DCPS::DEFAULT_STATUS_MASK); if (CORBA::is_nil (quote_topic.in ())) { cerr << "create_topic for " << QUOTER_QUOTE_TOPIC << " failed." << endl; ACE_OS::exit(1); } // .. and another topic for the Exchange Event type // (same as publisher) DDS::Topic_var exchange_evt_topic = participant->create_topic (QUOTER_EXCHANGE_EVENT_TOPIC, QUOTER_EXCHANGE_EVENT_TYPE, default_topic_qos, DDS::TopicListener::_nil(), ::OpenDDS::DCPS::DEFAULT_STATUS_MASK); if (CORBA::is_nil (exchange_evt_topic.in ())) { cerr << "create_topic for " << QUOTER_EXCHANGE_EVENT_TOPIC << " failed." << endl; ACE_OS::exit(1); } // Create DataReaders and DataReaderListeners for the // Quote and ExchangeEvent DDS::DataReaderListener_var quote_listener (new QuoteDataReaderListenerImpl); if (CORBA::is_nil (quote_listener.in ())) { cerr << "Quote listener is nil." << endl; ACE_OS::exit(1); } DDS::DataReaderListener_var exchange_evt_listener (new ExchangeEventDataReaderListenerImpl); ExchangeEventDataReaderListenerImpl* listener_servant = dynamic_cast<ExchangeEventDataReaderListenerImpl*>(exchange_evt_listener.in()); if (CORBA::is_nil (exchange_evt_listener.in ())) { cerr << "ExchangeEvent listener is nil." << endl; ACE_OS::exit(1); } // Create the Quote and ExchangeEvent DataReaders // Get the default QoS for our Data Readers // Could also use DATAREADER_QOS_DEFAULT DDS::DataReaderQos dr_default_qos; sub->get_default_datareader_qos (dr_default_qos); DDS::DataReader_var quote_dr = sub->create_datareader(quote_topic.in (), dr_default_qos, quote_listener.in (), ::OpenDDS::DCPS::DEFAULT_STATUS_MASK); DDS::DataReader_var exchange_evt_dr = sub->create_datareader(exchange_evt_topic.in (), dr_default_qos, exchange_evt_listener.in (), ::OpenDDS::DCPS::DEFAULT_STATUS_MASK); // Wait for events from the Publisher; shut down when "close" received cout << "Subscriber: waiting for events" << endl; while ( ! listener_servant->is_exchange_closed_received() ) { ACE_OS::sleep(1); } cout << "Received CLOSED event from publisher; exiting..." << endl; } catch (CORBA::Exception& e) { cerr << "Exception caught in main.cpp:" << endl << e << endl; ACE_OS::exit(1); } // Cleanup try { if (!CORBA::is_nil (participant.in ())) { participant->delete_contained_entities(); } if (!CORBA::is_nil (dpf.in ())) { dpf->delete_participant(participant.in ()); } } catch (CORBA::Exception& e) { cerr << "Exception caught in cleanup." << endl << e << endl; ACE_OS::exit(1); } TheTransportFactory->release(); TheServiceParticipant->shutdown (); 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 ACE_TMAIN (int argc, ACE_TCHAR *argv[]) { try { DDS::DomainParticipantFactory_var dpf; DDS::DomainParticipant_var participant; dpf = TheParticipantFactoryWithArgs(argc, argv); participant = dpf->create_participant(411, PARTICIPANT_QOS_DEFAULT, DDS::DomainParticipantListener::_nil(), ::OpenDDS::DCPS::DEFAULT_STATUS_MASK); if (CORBA::is_nil (participant.in ())) { cerr << "create_participant failed." << endl; return 1 ; } if (parse_args (argc, argv) == -1) { return -1; } MessageTypeSupport_var mts = new MessageTypeSupportImpl(); if (DDS::RETCODE_OK != mts->register_type(participant.in (), "")) { cerr << "Failed to register the MessageTypeTypeSupport." << endl; exit(1); } CORBA::String_var type_name = mts->get_type_name (); DDS::Topic_var topic = participant->create_topic("Movie Discussion List", type_name.in (), TOPIC_QOS_DEFAULT, DDS::TopicListener::_nil(), ::OpenDDS::DCPS::DEFAULT_STATUS_MASK); if (CORBA::is_nil (topic.in ())) { cerr << "ERROR Failed to create_topic." << endl; exit(1); } // Create the subscriber and attach to the corresponding // transport. DDS::Subscriber_var sub = participant->create_subscriber(SUBSCRIBER_QOS_DEFAULT, DDS::SubscriberListener::_nil(), ::OpenDDS::DCPS::DEFAULT_STATUS_MASK); if (CORBA::is_nil (sub.in ())) { cerr << "ERROR Failed to create_subscriber." << endl; exit(1); } // activate the listener DDS::DataReaderListener_var listener = new DataReaderListenerImpl; DataReaderListenerImpl &listener_servant = *dynamic_cast<DataReaderListenerImpl*>(listener.in()); if (CORBA::is_nil (listener.in ())) { cerr << "ERROR listener is nil." << endl; exit(1); } ::DDS::DataReaderQos dr_qos; sub->get_default_datareader_qos (dr_qos); dr_qos.liveliness.lease_duration.sec = LEASE_DURATION_SEC ; dr_qos.liveliness.lease_duration.nanosec = 0 ; // Create the Datareaders DDS::DataReader_var dr = sub->create_datareader(topic.in (), dr_qos, listener.in (), ::OpenDDS::DCPS::DEFAULT_STATUS_MASK); if (CORBA::is_nil (dr.in ())) { cerr << "ERROR create_datareader failed." << endl; exit(1); } int count = 0; while ((++count < 60) && ((listener_servant.num_reads() < total_num_messages))) { ACE_OS::sleep (1); } ACE_OS::sleep(2); ACE_DEBUG((LM_INFO, "Subscriber got %d of %d messages, " "and %d of %d callbacks, deleting entities\n", (int) listener_servant.num_reads(), total_num_messages, listener_servant.num_liveliness_change_callbacks(), num_liveliness_change_callbacks)); if (!CORBA::is_nil (participant.in ())) { participant->delete_contained_entities(); } if (!CORBA::is_nil (dpf.in ())) { dpf->delete_participant(participant.in ()); } ACE_OS::sleep(2); TheServiceParticipant->shutdown (); if (listener_servant.num_liveliness_change_callbacks () != num_liveliness_change_callbacks) { cerr << "ERROR: did not receive liveliness change callbacks as expected.(" << listener_servant.num_liveliness_change_callbacks () << "/" << num_liveliness_change_callbacks << ")" << endl; return 1; } } catch (CORBA::Exception& e) { cerr << "ERROR: subscriber Exception caught in main ():" << endl << e << endl; return 1; } return 0; }
int ACE_TMAIN(int argc, ACE_TCHAR *argv[]) { ::DDS::DomainParticipantFactory_var dpf; ::DDS::DomainParticipant_var participant; int status = 0; try { ACE_DEBUG((LM_INFO,"(%P|%t) %T subscriber main\n")); dpf = TheParticipantFactoryWithArgs(argc, argv); // let the Service_Participant (in above line) strip out -DCPSxxx parameters // and then get application specific parameters. parse_args (argc, argv); results.init (); participant = dpf->create_participant(MY_DOMAIN, PARTICIPANT_QOS_DEFAULT, ::DDS::DomainParticipantListener::_nil(), ::OpenDDS::DCPS::DEFAULT_STATUS_MASK); if (CORBA::is_nil (participant.in ())) { ACE_ERROR ((LM_ERROR, ACE_TEXT("(%P|%t) create_participant failed.\n"))); return 1 ; } if (no_key) { ::Xyz::FooNoKeyTypeSupportImpl* nokey_fts_servant = new ::Xyz::FooNoKeyTypeSupportImpl(); OpenDDS::DCPS::LocalObject_var safe_servant = nokey_fts_servant; if (::DDS::RETCODE_OK != nokey_fts_servant->register_type(participant.in (), MY_TYPE)) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("Failed to register the FooTypeSupport."))); throw TestException (); } } else { ::Xyz::FooTypeSupportImpl* fts_servant = new ::Xyz::FooTypeSupportImpl(); OpenDDS::DCPS::LocalObject_var safe_servant = fts_servant; if (::DDS::RETCODE_OK != fts_servant->register_type(participant.in (), MY_TYPE)) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("Failed to register the FooNoTypeTypeSupport."))); throw TestException (); } } if (mixed_trans) { ::Xyz::FooTypeSupportImpl* fts_servant = new ::Xyz::FooTypeSupportImpl(); OpenDDS::DCPS::LocalObject_var safe_servant = fts_servant; if (::DDS::RETCODE_OK != fts_servant->register_type(participant.in (), MY_TYPE_FOR_UDP)) { ACE_ERROR ((LM_ERROR, ACE_TEXT("(%P|%t) register_type failed.\n"))); throw TestException (); } } ::DDS::TopicQos topic_qos; participant->get_default_topic_qos(topic_qos); ::DDS::Topic_var topic = participant->create_topic(MY_TOPIC, MY_TYPE, topic_qos, ::DDS::TopicListener::_nil(), ::OpenDDS::DCPS::DEFAULT_STATUS_MASK); if (CORBA::is_nil (topic.in ())) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("Failed to create_topic."))); throw TestException (); } ::DDS::TopicDescription_var description = participant->lookup_topicdescription(MY_TOPIC); if (CORBA::is_nil (description.in ())) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("Failed to lookup_topicdescription."))); throw TestException (); } ::DDS::Topic_var topic1; ::DDS::TopicDescription_var description1; if (mixed_trans) { topic1 = participant->create_topic (MY_TOPIC_FOR_UDP, MY_TYPE_FOR_UDP, topic_qos, ::DDS::TopicListener::_nil(), ::OpenDDS::DCPS::DEFAULT_STATUS_MASK); if (CORBA::is_nil (topic1.in ())) { ACE_ERROR ((LM_ERROR, ACE_TEXT("(%P|%t) create_topic failed.\n"))); throw TestException (); } description1 = participant->lookup_topicdescription(MY_TOPIC_FOR_UDP); if (CORBA::is_nil (description1.in ())) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("Failed to lookup_topicdescription."))); throw TestException (); } } int attach_to_udp = using_udp; int attach_to_multicast = using_multicast; // Create the subscriber and attach to the corresponding // transport. DDS::Subscriber_var sub = create_subscriber(participant, attach_to_udp, attach_to_multicast, using_rtps_transport, using_shmem); if (CORBA::is_nil (sub.in ())) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("Failed to create_subscriber."))); throw TestException (); } ::DDS::Subscriber_var sub1; if (mixed_trans) { // Create the subscriber with a different transport from previous // subscriber. sub1 = create_subscriber(participant, !attach_to_udp, attach_to_multicast, false /*rtps*/, false); if (CORBA::is_nil (sub1.in ())) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("Failed to create_subscriber."))); throw TestException (); } } // Create the Datareaders ::DDS::DataReaderQos dr_qos; sub->get_default_datareader_qos (dr_qos); // Make it KEEP_ALL history so we can verify the received // data without dropping. dr_qos.history.kind = ::DDS::KEEP_ALL_HISTORY_QOS; dr_qos.reliability.kind = (using_udp || mixed_trans) ? ::DDS::BEST_EFFORT_RELIABILITY_QOS : ::DDS::RELIABLE_RELIABILITY_QOS; dr_qos.resource_limits.max_samples_per_instance = max_samples_per_instance ; // The history depth is only used for KEEP_LAST. //dr_qos.history.depth = history_depth ; // activate the listener ::DDS::DataReaderListener_var listener (new DataReaderListenerImpl); if (CORBA::is_nil (listener.in ())) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("(%P|%t) listener is nil."))); throw TestException (); } ::DDS::DataReader_var * drs = new ::DDS::DataReader_var[num_datareaders]; // Create one datareader or multiple datareaders belonging to the same // subscriber. for (int i = 0; i < num_datareaders; i ++) { int attach_to_udp = using_udp; ::DDS::Subscriber_var the_sub = sub; ::DDS::TopicDescription_var the_description = description; // The first datawriter would be using a different transport // from others for the diff trans test case. if (mixed_trans && i == 0) { attach_to_udp = ! attach_to_udp; the_sub = sub1; the_description = description1; } // create the datareader. drs[i] = the_sub->create_datareader(the_description.in (), dr_qos, listener.in (), ::OpenDDS::DCPS::DEFAULT_STATUS_MASK); if (CORBA::is_nil (drs[i].in ())) { ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT("(%P|%t) create_datareader failed.\n")), 1); } } // Indicate that the subscriber is ready ACE_DEBUG((LM_INFO, "(%P|%t) subscriber signaling ready\n")); FILE* readers_ready = ACE_OS::fopen (sub_ready_filename.c_str (), ACE_TEXT("w")); if (readers_ready == 0) { ACE_ERROR ((LM_ERROR, ACE_TEXT("(%P|%t) ERROR: Unable to create subscriber completed file\n"))); } // Wait for the publisher to be ready FILE* writers_ready = 0; do { ACE_Time_Value small_time(0,250000); ACE_OS::sleep (small_time); ACE_DEBUG((LM_INFO, "(%P|%t) subscriber checking for pub ready\n")); writers_ready = ACE_OS::fopen (pub_ready_filename.c_str (), ACE_TEXT("r")); } while (0 == writers_ready); ACE_OS::fclose(readers_ready); ACE_OS::fclose(writers_ready); int num_associations = mixed_trans ? num_datawriters : num_datareaders * num_datawriters; int expected = num_associations * num_instances_per_writer * num_samples_per_instance; FILE* writers_completed = 0; int timeout_writes = 0; while ( num_reads < expected) { // Get the number of the timed out writes from publisher so we // can re-calculate the number of expected messages. Otherwise, // the blocking timeout test will never exit from this loop. if (writers_completed == 0) { ACE_DEBUG((LM_INFO, "(%P|%t) subscriber checking for pub finished\n")); writers_completed = ACE_OS::fopen (pub_finished_filename.c_str (), ACE_TEXT("r")); if (writers_completed != 0) { //writers_completed = ACE_OS::fopen (pub_finished_filename.c_str (), ACE_TEXT("r")); if (std::fscanf (writers_completed, "%d\n", &timeout_writes) != 1) { //if fscanf return 0 or EOF(-1), failed to read a matching line format to populate in timeout_writes ACE_DEBUG ((LM_DEBUG, ACE_TEXT("(%P|%t) Warning: subscriber could not read timeout_writes\n"))); } else if (timeout_writes) { expected -= timeout_writes; ACE_DEBUG((LM_DEBUG, ACE_TEXT ("(%P|%t) %d timed out writes, adjusted we expected to %d\n"), timeout_writes, expected)); } // After we got the number of timed out writes, we should speed the // receiving. op_interval_ms = 0; } ACE_DEBUG((LM_DEBUG, ACE_TEXT ("(%P|%t) received %d of expected %d\n"), num_reads.value(), expected)); } ACE_OS::sleep (1); } // Indicate that the subscriber is done ACE_DEBUG((LM_INFO, "(%P|%t) subscriber signaling finished\n")); FILE* readers_completed = ACE_OS::fopen (sub_finished_filename.c_str (), ACE_TEXT("w")); if (readers_completed == 0) { ACE_ERROR ((LM_ERROR, ACE_TEXT("(%P|%t) ERROR: Unable to create subscriber completed file\n"))); } // Wait for the publisher to finish while (writers_completed == 0) { ACE_Time_Value small_time(0,250000); ACE_OS::sleep (small_time); ACE_DEBUG((LM_INFO, "(%P|%t) subscriber checking for pub finished\n")); writers_completed = ACE_OS::fopen (pub_finished_filename.c_str (), ACE_TEXT("r")); } ACE_OS::fclose(readers_completed); ACE_OS::fclose(writers_completed); if (results.test_passed (expected) == false) { ACE_ERROR ((LM_ERROR, ACE_TEXT("(%P|%t) Verify received samples - not passed \n"))); status = 1; } delete [] drs; } catch (const TestException&) { ACE_ERROR ((LM_ERROR, ACE_TEXT("(%P|%t) TestException caught in main (). "))); status = 1; } catch (const CORBA::Exception& ex) { ex._tao_print_exception ("Exception caught in main ():"); status = 1; } catch (const OpenDDS::DCPS::Transport::MiscProblem &) { ACE_ERROR((LM_ERROR, ACE_TEXT("(%P|%t) Transport::MiscProblem exception caught during processing.\n") )); status = 1; } ACE_DEBUG((LM_INFO, "(%P|%t) subscriber starting shutdown\n")); try { if (! CORBA::is_nil (participant.in ())) { participant->delete_contained_entities(); } if (! CORBA::is_nil (dpf.in ())) { dpf->delete_participant(participant.in ()); participant = 0; dpf = 0; } } catch (const CORBA::Exception& ex) { ex._tao_print_exception ("Exception caught in cleanup."); status = 1; } ACE_DEBUG((LM_INFO, "(%P|%t) subscriber shutdown of ServiceParticipant\n")); TheServiceParticipant->shutdown (); ACE_DEBUG((LM_INFO, "(%P|%t) subscriber exiting with status %d\n", status)); return status; }
int ACE_TMAIN(int argc, ACE_TCHAR** argv) { 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[]) { int return_result = 0; try { DDS::DomainParticipantFactory_var dpf; DDS::DomainParticipant_var participant; dpf = TheParticipantFactoryWithArgs(argc, argv); participant = dpf->create_participant(11, PARTICIPANT_QOS_DEFAULT, DDS::DomainParticipantListener::_nil(), ::OpenDDS::DCPS::DEFAULT_STATUS_MASK); if (CORBA::is_nil (participant.in ())) { cerr << "create_participant failed." << endl; return 1 ; } Messenger::MessageTypeSupportImpl* mts_servant = new Messenger::MessageTypeSupportImpl; if (DDS::RETCODE_OK != mts_servant->register_type(participant.in (), "")) { cerr << "Failed to register the MessageTypeTypeSupport." << endl; exit(1); } CORBA::String_var type_name = mts_servant->get_type_name (); DDS::TopicQos topic_qos; participant->get_default_topic_qos(topic_qos); DDS::Topic_var topic = participant->create_topic("Movie Discussion List", type_name.in (), topic_qos, DDS::TopicListener::_nil(), ::OpenDDS::DCPS::DEFAULT_STATUS_MASK); if (CORBA::is_nil (topic.in ())) { cerr << "Failed to create_topic." << endl; exit(1); } // Create the subscriber and attach to the corresponding // transport. DDS::Subscriber_var sub = participant->create_subscriber (SUBSCRIBER_QOS_DEFAULT, DDS::SubscriberListener::_nil(), ::OpenDDS::DCPS::DEFAULT_STATUS_MASK); if (CORBA::is_nil (sub.in ())) { cerr << "Failed to create_subscriber." << endl; exit(1); } // Create the listener. DDS::DataReaderListener_var listener (new DataReaderListenerImpl); DataReaderListenerImpl* listener_servant = dynamic_cast<DataReaderListenerImpl*>(listener.in()); if (CORBA::is_nil (listener.in ())) { cerr << "ERROR: listener is nil." << endl; exit(1); } DDS::DataReaderQos dr_qos; // Good QoS. sub->get_default_datareader_qos (dr_qos); dr_qos.resource_limits.max_samples_per_instance = MAX_SAMPLES_PER_INSTANCES; dr_qos.resource_limits.max_samples = MAX_SAMPLES; dr_qos.resource_limits.max_instances = MAX_INSTANCES; #ifndef OPENDDS_NO_OWNERSHIP_PROFILE dr_qos.history.kind = ::DDS::KEEP_ALL_HISTORY_QOS; dr_qos.history.depth = MAX_SAMPLES_PER_INSTANCES; #endif DDS::DataReader_var dr1 = sub->create_datareader (topic.in (), dr_qos, listener.in (), ::OpenDDS::DCPS::DEFAULT_STATUS_MASK); if (CORBA::is_nil (dr1.in ()) ) { cerr << "ERROR: create_datareader failed." << endl; exit(1); } DDS::DataReader_var dr2 = sub->create_datareader (topic.in (), dr_qos, DDS::DataReaderListener::_nil (), ::OpenDDS::DCPS::DEFAULT_STATUS_MASK); if (CORBA::is_nil (dr2.in ()) ) { cerr << "ERROR: create_datareader failed." << endl; exit(1); } int max_attempts = 10; int attempts = 0; // Synchronize with publisher. Wait until both associate with DataWriter. while (attempts < max_attempts) { ::DDS::SubscriptionMatchedStatus status1; ::DDS::SubscriptionMatchedStatus status2; if (dr1->get_subscription_matched_status (status1) == ::DDS::RETCODE_OK && dr2->get_subscription_matched_status (status2) == ::DDS::RETCODE_OK) { if (status1.total_count == 2 && status2.total_count == 2) break; ++ attempts; ACE_OS::sleep (1); } else { cerr << "ERROR: Failed to get subscription matched status" << endl; exit (1); } } if (attempts >= max_attempts) { cerr << "ERROR: failed to make associations. " << endl; exit (1); } // ---------------------------------------------- ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%P|%t) Subscriber: sleep for %d milliseconds\n"), SLEEP_DURATION.msec())); // Wait for publisher to finish sending ACE_OS::sleep (SLEEP_DURATION); long rej_max_samples = listener_servant->num_rejected_for_max_samples(); long rej_max_instances = listener_servant->num_rejected_for_max_instances(); long rej_max_samp_instance = listener_servant->num_rejected_for_max_samples_per_instance(); ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%P|%t) Subscriber: %d rejected for ") ACE_TEXT ("max_samples\n"), rej_max_samples)); ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%P|%t) Subscriber: %d rejected for ") ACE_TEXT ("max_instances\n"), rej_max_instances)); ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%P|%t) Subscriber: %d rejected for ") ACE_TEXT ("max_samples_per_instance\n"), rej_max_samp_instance)); ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%P|%t) Subscriber: received %d ") ACE_TEXT ("samples\n"), listener_servant->num_arrived() )); // 3 instances writing 5 messages each // expect 2 rejected for max_samples // expect 6 rejected for max_instances (register_instance + 5 messages) // expect 1 rejected for max_samples_per_instance #ifndef OPENDDS_NO_OWNERSHIP_PROFILE if (rej_max_samples != 2) { cerr << "ERROR: Failed to reject expected for max_samples" << endl; return_result = 1; } #endif if (rej_max_instances != 6) { cerr << "ERROR: Failed to reject expected for max_instances" << endl; return_result = 1; } #ifndef OPENDDS_NO_OWNERSHIP_PROFILE if (rej_max_samp_instance != 1) { cerr << "ERROR: Failed to reject expected for max_samples_per_instance" << endl; return_result = 1; } #endif Messenger::MessageDataReader_var message_dr1 = Messenger::MessageDataReader::_narrow(dr1.in()); Messenger::MessageDataReader_var message_dr2 = Messenger::MessageDataReader::_narrow(dr2.in()); message_dr1->set_listener(DDS::DataReaderListener::_nil (), ::OpenDDS::DCPS::DEFAULT_STATUS_MASK); message_dr2->set_listener(DDS::DataReaderListener::_nil (), ::OpenDDS::DCPS::DEFAULT_STATUS_MASK); listener = DDS::DataReaderListener::_nil (); ACE_OS::sleep (2); if (!CORBA::is_nil (participant.in ())) { participant->delete_contained_entities(); } if (!CORBA::is_nil (dpf.in ())) { dpf->delete_participant(participant.in ()); } ACE_OS::sleep(2); TheServiceParticipant->shutdown (); } catch (CORBA::Exception& e) { cerr << "SUB: Exception caught in main ():" << endl << e << endl; return_result = 1; } return return_result; }
int ACE_TMAIN(int argc, ACE_TCHAR** argv) { try { TheParticipantFactoryWithArgs(argc, argv); // Create Participant DDS::DomainParticipant_var participant = TheParticipantFactory->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(" ERROR: create_participant 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("%N:%l: main()") ACE_TEXT(" ERROR: create_subscriber failed!\n")), 2); // Create Publisher DDS::Publisher_var publisher = participant->create_publisher(PUBLISHER_QOS_DEFAULT, DDS::PublisherListener::_nil(), OpenDDS::DCPS::DEFAULT_STATUS_MASK); if (CORBA::is_nil(publisher.in())) ACE_ERROR_RETURN((LM_ERROR, ACE_TEXT("%N:%l: main()") ACE_TEXT(" ERROR: create_publisher failed!\n")), 1); OpenDDS::DCPS::TransportIdType transportId(0); // Attach Subscriber Transport ++transportId; OpenDDS::DCPS::TransportConfiguration_rch sub_config = TheTransportFactory->get_or_create_configuration(transportId, ACE_TEXT("SimpleTcp")); OpenDDS::DCPS::TransportImpl_rch sub_transport = TheTransportFactory->create_transport_impl(transportId); OpenDDS::DCPS::SubscriberImpl* subscriber_i = dynamic_cast<OpenDDS::DCPS::SubscriberImpl*>(subscriber.in()); if (subscriber_i == 0) ACE_ERROR_RETURN((LM_ERROR, ACE_TEXT("%N:%l: main()") ACE_TEXT(" ERROR: dynamic_cast failed!\n")), 1); OpenDDS::DCPS::AttachStatus sub_status = subscriber_i->attach_transport(sub_transport.in()); if (sub_status != OpenDDS::DCPS::ATTACH_OK) ACE_ERROR_RETURN((LM_ERROR, ACE_TEXT("%N:%l: main()") ACE_TEXT(" ERROR: attach_transport failed!\n")), 1); // Attach Publisher Transport ++transportId; OpenDDS::DCPS::TransportConfiguration_rch pub_config = TheTransportFactory->get_or_create_configuration(transportId, ACE_TEXT("SimpleTcp")); OpenDDS::DCPS::TransportImpl_rch pub_transport = TheTransportFactory->create_transport_impl(transportId); OpenDDS::DCPS::PublisherImpl* publisher_i = dynamic_cast<OpenDDS::DCPS::PublisherImpl*>(publisher.in()); if (publisher_i == 0) ACE_ERROR_RETURN((LM_ERROR, ACE_TEXT("%N:%l: main()") ACE_TEXT(" ERROR: dynamic_cast failed!\n")), 1); OpenDDS::DCPS::AttachStatus pub_status = publisher_i->attach_transport(pub_transport.in()); if (pub_status != OpenDDS::DCPS::ATTACH_OK) ACE_ERROR_RETURN((LM_ERROR, ACE_TEXT("%N:%l: main()") ACE_TEXT(" ERROR: attach_transport failed!\n")), 1); // 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(" ERROR: register_type failed!\n")), 1); // 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); 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 DataReader DDS::DataReaderQos qos; if (subscriber->get_default_datareader_qos(qos) != DDS::RETCODE_OK) ACE_ERROR_RETURN((LM_ERROR, ACE_TEXT("%N:%l main()") ACE_TEXT(" ERROR: create_datareader failed!\n")), -1); qos.history.kind = DDS::KEEP_ALL_HISTORY_QOS; DDS::DataReader_var reader = subscriber->create_datareader(topic.in(), 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(" ERROR: create_datareader failed!\n")), 7); FooDataReader_var reader_i = FooDataReader::_narrow(reader); if (CORBA::is_nil(reader_i)) ACE_ERROR_RETURN((LM_ERROR, ACE_TEXT("%N:%l: main()") ACE_TEXT(" ERROR: _narrow failed!\n")), 1); // Create DataWriter DDS::DataWriter_var writer = publisher->create_datawriter(topic.in(), DATAWRITER_QOS_DEFAULT, DDS::DataWriterListener::_nil(), OpenDDS::DCPS::DEFAULT_STATUS_MASK); if (CORBA::is_nil(writer.in())) ACE_ERROR_RETURN((LM_ERROR, ACE_TEXT("%N:%l: main()") ACE_TEXT(" ERROR: create_datawriter failed!\n")), 1); FooDataWriter_var writer_i = FooDataWriter::_narrow(writer); if (CORBA::is_nil(writer_i)) ACE_ERROR_RETURN((LM_ERROR, ACE_TEXT("%N:%l: main()") ACE_TEXT(" ERROR: _narrow failed!\n")), 1); // Block until Subscriber is associated DDS::StatusCondition_var cond = writer->get_statuscondition(); cond->set_enabled_statuses(DDS::PUBLICATION_MATCHED_STATUS); DDS::WaitSet_var ws = new DDS::WaitSet; ws->attach_condition(cond); DDS::Duration_t timeout = { DDS::DURATION_INFINITE_SEC, DDS::DURATION_INFINITE_NSEC }; DDS::ConditionSeq conditions; DDS::PublicationMatchedStatus matches = { 0, 0, 0, 0, 0 }; do { if (ws->wait(conditions, timeout) != DDS::RETCODE_OK) ACE_ERROR_RETURN((LM_ERROR, ACE_TEXT("%N:%l: main()") ACE_TEXT(" ERROR: wait failed!\n")), 1); if (writer->get_publication_matched_status(matches) != ::DDS::RETCODE_OK) { ACE_ERROR_RETURN((LM_ERROR, ACE_TEXT("%N:%l: main()") ACE_TEXT(" ERROR: failed to get publication matched status!\n")), 2); } } while (matches.current_count < 1); ws->detach_condition(cond); // // FooDataWriter::dispose should cause an instance to be // deleted after the last sample in the instance has been // taken from the ReceivedDataElementList: // DDS_TEST test(reader_i); if (!test) return 1; Foo foo; DDS::InstanceHandle_t handle; handle = writer_i->register_instance(foo); writer_i->write(foo, handle); writer_i->dispose(foo, handle); ACE_OS::sleep(5); // wait for samples to arrive if (!test.take_all_samples()) ACE_ERROR_RETURN((LM_ERROR, ACE_TEXT("%N:%l: main()") ACE_TEXT(" ERROR: unable to take samples!\n")), 2); /// Verify instance has been deleted if (test.has_instance(handle)) ACE_ERROR_RETURN((LM_ERROR, ACE_TEXT("%N:%l: main()") ACE_TEXT(" ERROR: instance not removed!\n")), 3); // Clean-up! participant->delete_contained_entities(); TheParticipantFactory->delete_participant(participant); TheTransportFactory->release(); TheServiceParticipant->shutdown(); } catch (const CORBA::Exception& e) { e._tao_print_exception("caught in main()"); return -1; } return 0; }
int ACE_TMAIN (int argc, ACE_TCHAR *argv[]) { try { DDS::DomainParticipantFactory_var dpf; DDS::DomainParticipant_var participant; dpf = TheParticipantFactoryWithArgs(argc, argv); 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[]) { long expected_late = 0; try { DDS::DomainParticipantFactory_var dpf; DDS::DomainParticipant_var participant; dpf = TheParticipantFactoryWithArgs(argc, argv); participant = dpf->create_participant(111, PARTICIPANT_QOS_DEFAULT, DDS::DomainParticipantListener::_nil(), ::OpenDDS::DCPS::DEFAULT_STATUS_MASK); if (CORBA::is_nil (participant.in ())) { cerr << "create_participant failed." << endl; return 1 ; } ACE_Get_Opt get_opts (argc, argv, ACE_TEXT("l:")); int c; while ((c = get_opts ()) != -1) { switch(c) { case 'l': expected_late = ACE_OS::atoi (get_opts.opt_arg ()); break; case '?': default: ACE_ERROR_RETURN ((LM_ERROR, "usage: %s " "-l expected late samples " "\n", argv [0]), -1); } } Messenger::MessageTypeSupportImpl::_var_type mts_servant = new Messenger::MessageTypeSupportImpl; if (DDS::RETCODE_OK != mts_servant->register_type (participant.in (), "")) { cerr << "Failed to register the MessageTypeTypeSupport." << endl; exit(1); } CORBA::String_var type_name = mts_servant->get_type_name (); DDS::TopicQos topic_qos; participant->get_default_topic_qos(topic_qos); DDS::Topic_var topic = participant->create_topic ("Movie Discussion List", type_name.in (), topic_qos, DDS::TopicListener::_nil(), ::OpenDDS::DCPS::DEFAULT_STATUS_MASK); if (CORBA::is_nil (topic.in ())) { cerr << "Failed to create_topic." << endl; exit(1); } // Create the subscriber DDS::Subscriber_var sub = participant->create_subscriber(SUBSCRIBER_QOS_DEFAULT, DDS::SubscriberListener::_nil(), ::OpenDDS::DCPS::DEFAULT_STATUS_MASK); if (CORBA::is_nil (sub.in ())) { cerr << "Failed to create_subscriber." << endl; exit(1); } // activate the listener DDS::DataReaderListener_var listener (new DataReaderListenerImpl); DataReaderListenerImpl* const listener_servant = dynamic_cast<DataReaderListenerImpl*>(listener.in()); if (CORBA::is_nil (listener.in ())) { cerr << "listener is nil." << endl; exit(1); } 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); dr_qos.latency_budget.duration.sec = 1; dr_qos.latency_budget.duration.nanosec = 0; 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); } dynamic_cast<OpenDDS::DCPS::DataReaderImpl*> (dr.in ())-> reset_latency_stats (); dynamic_cast<OpenDDS::DCPS::DataReaderImpl*> (dr.in ())-> statistics_enabled (true); ACE_OS::sleep (10); if (listener_servant->num_reads () != 10) { cerr << "ERROR: Incorrect number of samples received." << endl << " Expired data was probably read." << endl; exit (1); } if (listener_servant->num_late () != expected_late) { cerr << "ERROR: Incorrect number of samples received late." << endl; exit (1); } if (!CORBA::is_nil (participant.in ())) { participant->delete_contained_entities(); } if (!CORBA::is_nil (dpf.in ())) { dpf->delete_participant(participant.in ()); } ACE_OS::sleep(2); TheServiceParticipant->shutdown (); } catch (CORBA::Exception& e) { cerr << "SUB: Exception caught in main ():" << endl << e << endl; return 1; } return 0; }
int ACE_TMAIN(int argc, ACE_TCHAR *argv[]) { int status = 0; 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, 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* const listener_servant = new DataReaderListenerImpl; DDS::DataReaderListener_var listener(listener_servant); DDS::DataReaderQos dr_qos; sub->get_default_datareader_qos(dr_qos); if (DataReaderListenerImpl::is_reliable()) { std::cout << "Reliable DataReader" << std::endl; dr_qos.reliability.kind = DDS::RELIABLE_RELIABILITY_QOS; } DDS::DataReader_var reader = sub->create_datareader(topic.in(), dr_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); } // 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::Duration_t timeout = { DDS::DURATION_INFINITE_SEC, DDS::DURATION_INFINITE_NSEC }; DDS::ConditionSeq conditions; DDS::SubscriptionMatchedStatus matches = { 0, 0, 0, 0, 0 }; while (true) { if (reader->get_subscription_matched_status(matches) != DDS::RETCODE_OK) { ACE_ERROR_RETURN((LM_ERROR, ACE_TEXT("%N:%l main()") ACE_TEXT(" ERROR: get_subscription_matched_status() failed!\n")), -1); } if (matches.current_count == 0 && matches.total_count > 0) { break; } if (ws->wait(conditions, timeout) != DDS::RETCODE_OK) { ACE_ERROR_RETURN((LM_ERROR, ACE_TEXT("%N:%l main()") ACE_TEXT(" ERROR: wait() failed!\n")), -1); } } status = listener_servant->is_valid() ? 0 : -1; 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():"); status = -1; } return status; }
Subscriber::Subscriber( const Options& options) : options_( options), waiter_( new DDS::WaitSet) { // Create the DomainParticipant this->participant_ = TheParticipantFactory->create_participant( this->options_.domain(), PARTICIPANT_QOS_DEFAULT, DDS::DomainParticipantListener::_nil(), ::OpenDDS::DCPS::DEFAULT_STATUS_MASK ); if( CORBA::is_nil( this->participant_.in())) { ACE_ERROR((LM_ERROR, ACE_TEXT("(%P|%t) ERROR: Subscriber::Subscriber() - ") ACE_TEXT("failed to create a participant.\n") )); throw BadParticipantException(); } else if( this->options_.verbose()) { ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) Subscriber::Subscriber() - ") ACE_TEXT("created participant in domain %d.\n"), this->options_.domain() )); } // Create and register the type support. DataTypeSupportImpl* testData = new DataTypeSupportImpl(); if( ::DDS::RETCODE_OK != testData->register_type( this->participant_.in(), 0)) { ACE_ERROR((LM_ERROR, ACE_TEXT("(%P|%t) ERROR: Subscriber::Subscriber() - ") ACE_TEXT("unable to install type %C support.\n"), testData->get_type_name() )); throw BadTypeSupportException (); } else if( this->options_.verbose()) { ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) Subscriber::Subscriber() - ") ACE_TEXT("created type %C support.\n"), testData->get_type_name() )); } // Create the topic. DDS::Topic_var topic = this->participant_->create_topic( this->options_.topicName().c_str(), testData->get_type_name(), TOPIC_QOS_DEFAULT, ::DDS::TopicListener::_nil(), ::OpenDDS::DCPS::DEFAULT_STATUS_MASK ); if( CORBA::is_nil( topic.in())) { ACE_ERROR((LM_ERROR, ACE_TEXT("(%P|%t) ERROR: Subscriber::Subscriber() - ") ACE_TEXT("failed to create topic %C.\n"), this->options_.topicName().c_str() )); throw BadTopicException(); } else if( this->options_.verbose()) { ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) Subscriber::Subscriber() - ") ACE_TEXT("created topic %C.\n"), this->options_.topicName().c_str() )); } // Create the subscriber. DDS::Subscriber_var subscriber = this->participant_->create_subscriber( SUBSCRIBER_QOS_DEFAULT, ::DDS::SubscriberListener::_nil(), ::OpenDDS::DCPS::DEFAULT_STATUS_MASK ); if( CORBA::is_nil( subscriber.in())) { ACE_ERROR((LM_ERROR, ACE_TEXT("(%P|%t) ERROR: Subscriber::Subscriber() - ") ACE_TEXT("failed to create subscriber.\n") )); throw BadSubscriberException(); } else if( this->options_.verbose()) { ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) Subscriber::Subscriber() - ") ACE_TEXT("created subscriber.\n") )); } // Create the transport. OpenDDS::DCPS::TransportImpl_rch transport = TheTransportFactory->create_transport_impl( this->options_.transportKey(), OpenDDS::DCPS::AUTO_CONFIG ); if( transport.is_nil()) { ACE_ERROR((LM_ERROR, ACE_TEXT("(%P|%t) ERROR: Subscriber::Subscriber() - ") ACE_TEXT("failed to create transport.\n") )); throw BadTransportException(); } else if( this->options_.verbose()) { ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) Subscriber::Subscriber() - ") ACE_TEXT("created transport.\n") )); } // Attach the transport. if( ::OpenDDS::DCPS::ATTACH_OK != transport->attach( subscriber.in())) { ACE_ERROR((LM_ERROR, ACE_TEXT("(%P|%t) ERROR: Subscriber::Subscriber() - ") ACE_TEXT("failed to attach subscriber to transport.\n") )); throw BadAttachException(); } else if( this->options_.verbose()) { ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) Subscriber::Subscriber() - ") ACE_TEXT("attached subscriber to transport.\n") )); } // Reader Qos policy values. ::DDS::DataReaderQos readerQos; subscriber->get_default_datareader_qos( readerQos); readerQos.reliability.kind = ::DDS::RELIABLE_RELIABILITY_QOS; // Create the readers. for( int index = 0; index < 2; ++index) { ::DDS::DataReader_var reader = subscriber->create_datareader( topic.in(), readerQos, DDS::DataReaderListener::_nil(), ::OpenDDS::DCPS::DEFAULT_STATUS_MASK ); if( CORBA::is_nil( reader.in())) { ACE_ERROR((LM_ERROR, ACE_TEXT("(%P|%t) ERROR: Subscriber::Subscriber() - ") ACE_TEXT("failed to create reader.\n") )); throw BadReaderException(); } else if( this->options_.verbose()) { ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) Subscriber::Subscriber() - ") ACE_TEXT("created reader.\n") )); } this->reader_[ index] = ::OpenDDS::DCPS::DataReaderEx::_narrow( reader.in()); if( CORBA::is_nil( this->reader_[ index].in())) { ACE_ERROR((LM_ERROR, ACE_TEXT("(%P|%t) ERROR: Subscriber::Subscriber() - ") ACE_TEXT("failed to narrow reader to extract statistics.\n") )); throw BadReaderException(); } // Grab, enable and attach the status condition for test synchronization. this->status_ = this->reader_[ index]->get_statuscondition(); this->status_->set_enabled_statuses( DDS::SUBSCRIPTION_MATCHED_STATUS); this->waiter_->attach_condition( this->status_.in()); if( this->options_.verbose()) { ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) Subscriber::Subscriber() - ") ACE_TEXT("created StatusCondition and WaitSet for test synchronization.\n") )); } } }
int ACE_TMAIN(int argc, ACE_TCHAR** argv) { parse_args(argc, argv); ACE_DEBUG((LM_INFO, ACE_TEXT("(%P|%t) -> SUBSCRIBER STARTED\n"))); try { DDS::DomainParticipantFactory_var dpf = TheParticipantFactoryWithArgs(argc, argv); // 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); // 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("%N:%l: main()") ACE_TEXT(" create_subscriber failed!\n")), 2); // Attach Transport OpenDDS::DCPS::TransportImpl_rch transport = TheTransportFactory->create_transport_impl( OpenDDS::DCPS::DEFAULT_SIMPLE_TCP_ID, "SimpleTcp"); OpenDDS::DCPS::SubscriberImpl* subscriber_i = dynamic_cast<OpenDDS::DCPS::SubscriberImpl*>(subscriber.in()); if (subscriber_i == 0) ACE_ERROR_RETURN((LM_ERROR, ACE_TEXT("%N:%l: main()") ACE_TEXT(" dynamic_cast failed!\n")), 3); OpenDDS::DCPS::AttachStatus status = subscriber_i->attach_transport(transport.in()); if (status != OpenDDS::DCPS::ATTACH_OK) ACE_ERROR_RETURN((LM_ERROR, ACE_TEXT("%N:%l: main()") ACE_TEXT(" attach_transport failed!\n")), 4); // 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); 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 ProgressIndicator progress = ProgressIndicator("(%P|%t) SUBSCRIBER %d%% (%d samples received)\n", expected_samples); DDS::DataReaderListener_var listener = new DataReaderListenerImpl(received_samples, progress); DDS::DataReaderQos reader_qos; subscriber->get_default_datareader_qos(reader_qos); reader_qos.history.kind = DDS::KEEP_ALL_HISTORY_QOS; DDS::DataReader_var reader = subscriber->create_datareader(topic.in(), reader_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(" create_datareader failed!\n")), 7); // Block until Publisher completes DDS::StatusCondition_var cond = reader->get_statuscondition(); cond->set_enabled_statuses(DDS::SUBSCRIPTION_MATCHED_STATUS); DDS::WaitSet_var ws = new DDS::WaitSet; ws->attach_condition(cond); DDS::Duration_t timeout = { DDS::DURATION_INFINITE_SEC, DDS::DURATION_INFINITE_NSEC }; DDS::ConditionSeq conditions; DDS::SubscriptionMatchedStatus matches = {0, 0, 0, 0, 0}; do { if (ws->wait(conditions, timeout) != DDS::RETCODE_OK) ACE_ERROR_RETURN((LM_ERROR, ACE_TEXT("%N:%l: main()") ACE_TEXT(" wait failed!\n")), 8); if (reader->get_subscription_matched_status(matches) != ::DDS::RETCODE_OK) { ACE_ERROR ((LM_ERROR, "ERROR: failed to get subscription matched status\n")); return 1; } } while (matches.current_count > 0 || matches.total_count < n_publishers); ws->detach_condition(cond); // Clean-up! participant->delete_contained_entities(); dpf->delete_participant(participant.in()); TheTransportFactory->release(); TheServiceParticipant->shutdown(); } 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"))); if (received_samples != expected_samples) { ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) ERROR: subscriber - ") ACE_TEXT("received %d of expected %d samples.\n"), received_samples, expected_samples )); return 10; } return 0; }
int ACE_TMAIN(int argc, ACE_TCHAR *argv[]) { try { // Initialize DomainParticipantFactory DDS::DomainParticipantFactory_var dpf = TheParticipantFactoryWithArgs(argc, argv); DDS::DomainParticipant_var participant; bool result1, result2; int error; if ((error = parse_args(argc, argv)) != 0) { ACE_DEBUG((LM_ERROR, "(%P|%t) Parsing error, returning %d\n", error)); return error; } { // Scope of entities // Create DomainParticipant participant = dpf->create_participant(411, PARTICIPANT_QOS_DEFAULT, DDS::DomainParticipantListener::_nil(), OpenDDS::DCPS::DEFAULT_STATUS_MASK); if (CORBA::is_nil(participant.in())) { ACE_ERROR_RETURN((LM_ERROR, ACE_TEXT("%N:%l main()") ACE_TEXT(" ERROR: create_participant() failed!\n")), -1); } // Register Type (Messenger::Message) Messenger::MessageTypeSupport_var ts = new Messenger::MessageTypeSupportImpl(); if (ts->register_type(participant.in(), "") != DDS::RETCODE_OK) { ACE_ERROR_RETURN((LM_ERROR, ACE_TEXT("%N:%l main()") ACE_TEXT(" ERROR: register_type() failed!\n")), -1); } // Create Topic (Movie Discussion List) DDS::Topic_var topic = participant->create_topic("Movie Discussion List", ts->get_type_name(), TOPIC_QOS_DEFAULT, DDS::TopicListener::_nil(), OpenDDS::DCPS::DEFAULT_STATUS_MASK); if (CORBA::is_nil(topic.in())) { ACE_ERROR_RETURN((LM_ERROR, ACE_TEXT("%N:%l main()") ACE_TEXT(" ERROR: create_topic() failed!\n")), -1); } // 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_svt1 = new DataReaderListenerImpl("DataReader1"); DataReaderListenerImpl* listener_svt2 = new DataReaderListenerImpl("DataReader2"); DDS::DataReaderListener_var listener1(listener_svt1); DDS::DataReaderListener_var listener2(listener_svt2); ::DDS::DataReaderQos dr_qos; sub->get_default_datareader_qos (dr_qos); dr_qos.ownership.kind = ::DDS::EXCLUSIVE_OWNERSHIP_QOS; dr_qos.deadline.period.sec = deadline.sec; dr_qos.deadline.period.nanosec = deadline.nanosec; dr_qos.liveliness.lease_duration.sec = liveliness.sec; dr_qos.liveliness.lease_duration.nanosec = liveliness.nanosec; DDS::DataReader_var reader1 = sub->create_datareader(topic.in(), dr_qos, listener1.in(), OpenDDS::DCPS::DEFAULT_STATUS_MASK); if (CORBA::is_nil(reader1.in())) { ACE_ERROR_RETURN((LM_ERROR, ACE_TEXT("%N:%l main()") ACE_TEXT(" ERROR: create_datareader() failed!\n")), -1); } DDS::DataReader_var reader2 = sub->create_datareader(topic.in(), dr_qos, listener2.in(), OpenDDS::DCPS::DEFAULT_STATUS_MASK); if (CORBA::is_nil(reader2.in())) { ACE_ERROR_RETURN((LM_ERROR, ACE_TEXT("%N:%l main()") ACE_TEXT(" ERROR: create_datareader() failed!\n")), -1); } // Block until Publisher completes DDS::StatusCondition_var condition1 = reader1->get_statuscondition(); DDS::StatusCondition_var condition2 = reader2->get_statuscondition(); condition1->set_enabled_statuses(DDS::SUBSCRIPTION_MATCHED_STATUS); condition2->set_enabled_statuses(DDS::SUBSCRIPTION_MATCHED_STATUS); DDS::WaitSet_var ws = new DDS::WaitSet; ws->attach_condition(condition1); ws->attach_condition(condition2); DDS::Duration_t timeout = { DDS::DURATION_INFINITE_SEC, DDS::DURATION_INFINITE_NSEC }; DDS::ConditionSeq conditions; DDS::SubscriptionMatchedStatus matches1 = { 0, 0, 0, 0, 0 }; DDS::SubscriptionMatchedStatus matches2 = { 0, 0, 0, 0, 0 }; while (true) { if (reader1->get_subscription_matched_status(matches1) != DDS::RETCODE_OK) { ACE_ERROR_RETURN((LM_ERROR, ACE_TEXT("%N:%l main()") ACE_TEXT(" ERROR: get_subscription_matched_status() failed!\n")), -1); } if (reader2->get_subscription_matched_status(matches2) != DDS::RETCODE_OK) { ACE_ERROR_RETURN((LM_ERROR, ACE_TEXT("%N:%l main()") ACE_TEXT(" ERROR: get_subscription_matched_status() failed!\n")), -1); } if ((matches1.current_count == 0 && matches1.total_count > 0) || (matches2.current_count == 0 && matches2.total_count > 0)) { break; } DDS::ReturnCode_t wait_status = ws->wait(conditions, timeout); if (wait_status != DDS::RETCODE_OK) { std::cerr << "ERROR: Subscriber failed during waiting on wait set with return code " << wait_status << std::endl; } } ws->detach_condition(condition1); ws->detach_condition(condition2); result1 = listener_svt1->verify_result(); result2 = listener_svt2->verify_result(); } // Scope of entities // Clean-up! participant->delete_contained_entities(); dpf->delete_participant(participant.in()); TheServiceParticipant->shutdown(); if (result1 == false || result2 == false) { ACE_ERROR_RETURN((LM_ERROR, ACE_TEXT("%N:%l main()") ACE_TEXT(" ERROR: failed to verify message!\n")), -2); } } 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 = 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; }
void EBRouter::init() { DDS::DomainId_t myDomain = NULL; DDS::DomainParticipantFactory_var dpf; DDS::DomainParticipant_var dp; DDS::Subscriber_var subscriber; DDS::Publisher_var publisher; DDS::DomainParticipantQos dpQos; DDS::TopicQos tQos; DDS::SubscriberQos sQos; DDS::DataReaderQos drQos; DDS::PublisherQos pQos; DDS::DataWriterQos dwQos; DDS::Topic_var topic; DDSEventChannel::EventContainerTypeSupport_var ts; // Create Participants dpf = DDS::DomainParticipantFactory::get_instance(); dpf->get_default_participant_qos(dpQos); dp = dpf->create_participant(myDomain, dpQos, NULL, DDS::STATUS_MASK_NONE); // Create Subscriber dp->get_default_subscriber_qos(sQos); sQos.partition.name.length(1); sQos.partition.name[0] = partition.c_str(); subscriber = dp->create_subscriber(sQos, NULL, DDS::STATUS_MASK_NONE); // Create Publisher dp->get_default_publisher_qos(pQos); pQos.partition.name.length(1); pQos.partition.name[0] = partition.c_str(); publisher = dp->create_publisher(pQos, NULL, DDS::STATUS_MASK_NONE); // Set DataReader QoS settings subscriber->get_default_datareader_qos(drQos); drQos.reliability.kind = DDS::RELIABLE_RELIABILITY_QOS; drQos.history.kind = DDS::KEEP_LAST_HISTORY_QOS; drQos.history.depth = 30; // Set DataWriter QoS settings publisher->get_default_datawriter_qos(dwQos); dwQos.reliability.kind = DDS::RELIABLE_RELIABILITY_QOS; dwQos.history.kind = DDS::KEEP_LAST_HISTORY_QOS; dwQos.history.depth = 30; // Set Topic Qos settings dp->get_default_topic_qos(tQos); tQos.reliability.kind = DDS::RELIABLE_RELIABILITY_QOS; tQos.history.kind = DDS::KEEP_LAST_HISTORY_QOS; tQos.history.depth = 30; // Create Topic ts = new DDSEventChannel::EventContainerTypeSupport(); ts->register_type(dp, "DDSEventChannel::EventContainer"); topic = dp->create_topic("EventContainer", "DDSEventChannel::EventContainer", tQos, NULL, DDS::STATUS_MASK_NONE); // Create Datareader dataReader = subscriber->create_datareader(topic, drQos, NULL, DDS::STATUS_MASK_NONE); eventContainerDataReader = DDSEventChannel::EventContainerDataReader::_narrow( dataReader); if (dataReader == NULL) std::cout << "ERROR: DDS Connection failed" << std::endl; // Create Datawriter eventContainerDataWriter = DDSEventChannel::EventContainerDataWriter::_narrow( publisher->create_datawriter(topic, dwQos, NULL, DDS::STATUS_MASK_NONE)); if (eventContainerDataWriter == NULL) std::cout << "ERROR: DDS Connection failed" << std::endl; // Create Readcondition readCondition = dataReader->create_readcondition(DDS::ANY_SAMPLE_STATE, DDS::ANY_VIEW_STATE, DDS::ALIVE_INSTANCE_STATE); }
int ACE_TMAIN(int argc, ACE_TCHAR *argv[]) { 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); participant = dpf->create_participant(111, PARTICIPANT_QOS_DEFAULT, DDS::DomainParticipantListener::_nil(), ::OpenDDS::DCPS::DEFAULT_STATUS_MASK); if (CORBA::is_nil (participant.in ())) { cerr << "create_participant failed." << endl; return 1 ; } Messenger::MessageTypeSupport_var mts_servant = new Messenger::MessageTypeSupportImpl; if (DDS::RETCODE_OK != mts_servant->register_type (participant.in (), "")) { cerr << "Failed to register the MessageTypeTypeSupport." << endl; exit(1); } CORBA::String_var type_name = mts_servant->get_type_name (); DDS::TopicQos topic_qos; participant->get_default_topic_qos(topic_qos); topic_qos.lifespan.duration.sec = 10; topic_qos.lifespan.duration.nanosec = 0; topic_qos.durability.kind = DDS::TRANSIENT_LOCAL_DURABILITY_QOS; DDS::Topic_var topic = participant->create_topic ("Movie Discussion List", type_name.in (), topic_qos, DDS::TopicListener::_nil(), ::OpenDDS::DCPS::DEFAULT_STATUS_MASK); if (CORBA::is_nil (topic.in ())) { cerr << "Failed to create_topic." << endl; exit(1); } // Create the subscriber and attach to the corresponding // transport. DDS::Subscriber_var sub = participant->create_subscriber(SUBSCRIBER_QOS_DEFAULT, DDS::SubscriberListener::_nil(), ::OpenDDS::DCPS::DEFAULT_STATUS_MASK); if (CORBA::is_nil (sub.in ())) { cerr << "Failed to create_subscriber." << endl; exit(1); } // activate the listener DDS::DataReaderListener_var listener (new DataReaderListenerImpl); DataReaderListenerImpl* const listener_servant = dynamic_cast<DataReaderListenerImpl*>(listener.in()); if (CORBA::is_nil (listener.in ())) { cerr << "listener is nil." << endl; exit(1); } 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::DataReader_var dr = sub->create_datareader(topic.in (), DATAREADER_QOS_USE_TOPIC_QOS, listener.in (), ::OpenDDS::DCPS::DEFAULT_STATUS_MASK); if (CORBA::is_nil (dr.in ())) { cerr << "create_datareader failed." << endl; exit(1); } ACE_OS::sleep (10); if (listener_servant->num_reads () != 1) { cerr << "ERROR: Incorrect number of samples received." << endl << " Expired data was probably read." << endl; exit (1); } if (!CORBA::is_nil (participant.in ())) { participant->delete_contained_entities(); } if (!CORBA::is_nil (dpf.in ())) { dpf->delete_participant(participant.in ()); } ACE_OS::sleep(2); TheServiceParticipant->shutdown (); } catch (CORBA::Exception& e) { cerr << "SUB: Exception caught in main ():" << endl << e << endl; return 1; } return 0; }
int ACE_TMAIN(int argc, ACE_TCHAR* argv[]) { try { DDS::DomainParticipantFactory_var dpf; DDS::DomainParticipant_var participant; dpf = TheParticipantFactoryWithArgs(argc, argv); participant = dpf->create_participant(411, PARTICIPANT_QOS_DEFAULT, DDS::DomainParticipantListener::_nil(), ::OpenDDS::DCPS::DEFAULT_STATUS_MASK); if (CORBA::is_nil (participant.in ())) { cerr << "create_participant failed." << endl; return 1 ; } MessageTypeSupportImpl* mts_servant = new MessageTypeSupportImpl; if (DDS::RETCODE_OK != mts_servant->register_type(participant.in (), "")) { cerr << "Failed to register the MessageTypeTypeSupport." << endl; exit(1); } CORBA::String_var type_name = mts_servant->get_type_name (); DDS::TopicQos topic_qos; participant->get_default_topic_qos(topic_qos); DDS::Topic_var topic = participant->create_topic("Movie Discussion List", type_name.in (), topic_qos, DDS::TopicListener::_nil(), ::OpenDDS::DCPS::DEFAULT_STATUS_MASK); if (CORBA::is_nil (topic.in ())) { cerr << "Failed to create_topic." << endl; exit(1); } // Create the subscriber and attach to the corresponding // transport. DDS::Subscriber_var sub = participant->create_subscriber(SUBSCRIBER_QOS_DEFAULT, DDS::SubscriberListener::_nil(), ::OpenDDS::DCPS::DEFAULT_STATUS_MASK); if (CORBA::is_nil (sub.in ())) { cerr << "Failed to create_subscriber." << endl; exit(1); } // activate the listener DDS::DataReaderListener_var listener (new DataReaderListenerImpl); if (CORBA::is_nil (listener.in ())) { cerr << "listener is nil." << endl; exit(1); } DataReaderListenerImpl* listener_servant = dynamic_cast<DataReaderListenerImpl*>(listener.in()); // Create the Datareaders DDS::DataReaderQos dr_qos; sub->get_default_datareader_qos (dr_qos); DDS::DataReader_var dr = sub->create_datareader(topic.in (), dr_qos, listener.in (), ::OpenDDS::DCPS::DEFAULT_STATUS_MASK); if (CORBA::is_nil (dr.in ())) { cerr << "create_datareader failed." << endl; exit(1); } while ( ! listener_servant->received_all ()) { ACE_OS::sleep (1); } if (! listener_servant->passed ()) { cerr << "test failed - see errors." << endl; return 1; } if (!CORBA::is_nil (participant.in ())) { participant->delete_contained_entities(); } if (!CORBA::is_nil (dpf.in ())) { dpf->delete_participant(participant.in ()); } ::DDS::InstanceHandleSeq handles; while (1) { ACE_OS::sleep(1); dr->get_matched_publications(handles); if (handles.length() == 0) break; } ACE_OS::sleep(2); TheServiceParticipant->shutdown(); } catch (CORBA::Exception& e) { cerr << "Exception caught in main ():" << endl << e << endl; return 1; } return 0; }
int main (int argc, char *argv[]) { try { // initialize the participant. the same as in the publisher DDS::DomainParticipantFactory_var dpf = TheParticipantFactoryWithArgs(argc, argv); DDS::DomainParticipant_var participant = dpf->create_participant(42, // Domain ID PARTICIPANT_QOS_DEFAULT, 0, // No listener required OpenDDS::DCPS::DEFAULT_STATUS_MASK); if (!participant) { std::cerr << "create_participant failed." << std::endl; return 1 ; } Messenger::MessageTypeSupport_var mts = new Messenger::MessageTypeSupportImpl(); if (DDS::RETCODE_OK != mts->register_type(participant, "")) { std::cerr << "Failed to register the MessageTypeSupport." << std::endl; return 1; } CORBA::String_var type_name = mts->get_type_name (); DDS::Topic_var topic = participant->create_topic("Movie Discussion List", type_name, TOPIC_QOS_DEFAULT, 0, // No listener required OpenDDS::DCPS::DEFAULT_STATUS_MASK); if (!topic) { std::cerr << "Failed to create_topic." << std::endl; return 1; } // Create the subscriber DDS::Subscriber_var sub = participant->create_subscriber(SUBSCRIBER_QOS_DEFAULT, 0, // No listener required OpenDDS::DCPS::DEFAULT_STATUS_MASK); if (!sub) { std::cerr << "Failed to create_subscriber." << std::endl; return 1; } // Associate a listener object with the data reader we create, // so we can use it to detect when data is available. // The listener is allocated on the heap and assigned to a// // DataReaderListener_var object. This type provides // reference counting behavior so the listener is // automatically cleaned up when the last reference to it is // removed. This usage is typical for heap allocations in // OpenDDS application code and frees the application // developer from having to actively manage the lifespan of // the allocated objects. DDS::DataReaderListener_var listener(new DataReaderListenerImpl); // Create the data reader DDS::DataReader_var dr = sub->create_datareader(topic, DATAREADER_QOS_DEFAULT, listener, OpenDDS::DCPS::DEFAULT_STATUS_MASK); if (!dr) { std::cerr << "create_datareader failed." << std::endl; return 1; } // clean up //1. delete all the topics, subscribers and publishers create // with this participant //2. when done, use the factory to delete the domain participant. participant->delete_contained_entities(); dpf->delete_participant(participant); TheServiceParticipant->shutdown (); } catch(...) { std::cerr << "ERROR!!! exception caught" << std::endl; } }
int ACE_TMAIN (int argc, ACE_TCHAR *argv[]) { try { DDS::DomainParticipantFactory_var dpf; DDS::DomainParticipant_var participant; dpf = TheParticipantFactoryWithArgs(argc, argv); // Default DomainParticipantFactory qos is to auto enable. ::DDS::DomainParticipantFactoryQos fqos; if (dpf->get_qos (fqos) != ::DDS::RETCODE_OK) { cerr << "DomainParticipantFactory get_qos failed." << endl; return 1; } if (fqos.entity_factory.autoenable_created_entities == 0) { cerr << "The DomainParticipantFactory defaults to autoenable upon entities creation." << endl; return 1; } // Now disable DomainParticipantFactory autoenable fqos.entity_factory.autoenable_created_entities = 0; if (dpf->set_qos (fqos) != ::DDS::RETCODE_OK) { cerr << "DomainParticipantFactory set_qos failed." << endl; return 1; } participant = dpf->create_participant(411, PARTICIPANT_QOS_DEFAULT, DDS::DomainParticipantListener::_nil(), ::OpenDDS::DCPS::DEFAULT_STATUS_MASK); if (CORBA::is_nil (participant.in ())) { cerr << "create_participant failed." << endl; return 1 ; } if (participant->enable () != ::DDS::RETCODE_PRECONDITION_NOT_MET) { cerr << "DomainParticipant can not be enabled because factory autoenable is off." << endl; return 1; } MessageTypeSupport_var mts = new MessageTypeSupportImpl(); if (DDS::RETCODE_OK != mts->register_type(participant.in (), "")) { cerr << "Failed to register the MessageTypeTypeSupport." << endl; exit(1); } CORBA::String_var type_name = mts->get_type_name (); DDS::Topic_var topic = participant->create_topic("Movie Discussion List", type_name.in (), TOPIC_QOS_DEFAULT, DDS::TopicListener::_nil(), ::OpenDDS::DCPS::DEFAULT_STATUS_MASK); if (CORBA::is_nil (topic.in ())) { cerr << "Failed to create_topic." << endl; exit(1); } if (topic->enable () != ::DDS::RETCODE_PRECONDITION_NOT_MET) { cerr << "Topic can not be enabled because DomainParticipant is not enabled." << endl; return 1; } // Initialize the transport OpenDDS::DCPS::TransportImpl_rch transport_impl = TheTransportFactory->create_transport_impl (transport_impl_id, ::OpenDDS::DCPS::AUTO_CONFIG); // Create the subscriber and attach to the corresponding // transport. DDS::Subscriber_var sub = participant->create_subscriber(SUBSCRIBER_QOS_DEFAULT, DDS::SubscriberListener::_nil(), ::OpenDDS::DCPS::DEFAULT_STATUS_MASK); if (CORBA::is_nil (sub.in ())) { cerr << "Failed to create_subscriber." << endl; exit(1); } if (sub->enable () != ::DDS::RETCODE_PRECONDITION_NOT_MET) { cerr << "Publisher can not be enabled because DomainParticipant is not enabled." << endl; return 1; } // Attach the subscriber to the transport. OpenDDS::DCPS::SubscriberImpl* sub_impl = dynamic_cast<OpenDDS::DCPS::SubscriberImpl*> (sub.in ()); if (0 == sub_impl) { cerr << "Failed to obtain subscriber servant\n" << endl; exit(1); } OpenDDS::DCPS::AttachStatus status = sub_impl->attach_transport(transport_impl.in()); if (status != OpenDDS::DCPS::ATTACH_OK) { std::string status_str; switch (status) { case OpenDDS::DCPS::ATTACH_BAD_TRANSPORT: status_str = "ATTACH_BAD_TRANSPORT"; break; case OpenDDS::DCPS::ATTACH_ERROR: status_str = "ATTACH_ERROR"; break; case OpenDDS::DCPS::ATTACH_INCOMPATIBLE_QOS: status_str = "ATTACH_INCOMPATIBLE_QOS"; break; default: status_str = "Unknown Status"; break; } cerr << "Failed to attach to the transport. Status == " << status_str.c_str() << endl; exit(1); } // activate the listener DDS::DataReaderListener_var listener = new DataReaderListenerImpl; DataReaderListenerImpl &listener_servant = *dynamic_cast<DataReaderListenerImpl*>(listener.in()); if (CORBA::is_nil (listener.in ())) { cerr << "listener is nil." << endl; exit(1); } // Create the Datareaders DDS::DataReader_var dr = sub->create_datareader(topic.in (), DATAREADER_QOS_DEFAULT, listener.in (), ::OpenDDS::DCPS::DEFAULT_STATUS_MASK); if (CORBA::is_nil (dr.in ())) { cerr << "create_datareader failed." << endl; exit(1); } if (dr->enable () != ::DDS::RETCODE_PRECONDITION_NOT_MET) { cerr << "DataReader can not be enabled because Subscriber is not enabled." << endl; return 1; } // Now enable DomainParticipantFactory autoenable fqos.entity_factory.autoenable_created_entities = 1; if (dpf->set_qos (fqos) != ::DDS::RETCODE_OK) { cerr << "DomainParticipantFactory set_qos failed." << endl; return 1; } // Enable every entity from factory to it's entities and it should succeed. if (participant->enable () != ::DDS::RETCODE_OK || topic->enable () != ::DDS::RETCODE_OK || sub->enable () != ::DDS::RETCODE_OK) { cerr << "Failed to enable factory." << endl; return 1; } // The datareader is not enabled so it will not able to // communicate with datawriter. int i = 0; while (i < 5 && listener_servant.num_reads() == 0) { ACE_OS::sleep (1); ++i; } if (listener_servant.num_reads() > 0) { cerr << "Should not receive any samples since datareader is not enabled." << endl; return 1; } if (dr->enable () != ::DDS::RETCODE_OK) { cerr << "Failed to enable DataReader." << endl; return 1; } int expected = 10; while ( listener_servant.num_reads() < expected ) { ACE_OS::sleep (1); } if (!CORBA::is_nil (participant.in ())) { participant->delete_contained_entities(); } if (!CORBA::is_nil (dpf.in ())) { dpf->delete_participant(participant.in ()); } ACE_OS::sleep(2); TheTransportFactory->release(); TheServiceParticipant->shutdown (); } catch (CORBA::Exception& e) { cerr << "SUB: Exception caught in main ():" << endl << e << endl; return 1; } return 0; }
int main (int argc, char *argv[]) { try { DDS::DomainParticipantFactory_var dpf; DDS::DomainParticipant_var participant; dpf = TheParticipantFactoryWithArgs(argc, argv); if( parse_args(argc, argv) != 0) return 1; participant = dpf->create_participant(411, PARTICIPANT_QOS_DEFAULT, DDS::DomainParticipantListener::_nil()); if (CORBA::is_nil (participant.in ())) { ACE_ERROR_RETURN ((LM_ERROR, "(%P|%t) create_participant failed.\n") , -1); } MessageTypeSupportImpl* mts_servant = new MessageTypeSupportImpl(); PortableServer::ServantBase_var safe_servant = mts_servant; if (DDS::RETCODE_OK != mts_servant->register_type(participant.in (), "")) { ACE_ERROR_RETURN ((LM_ERROR, "(%P|%t) Failed to register the MessageTypeTypeSupport.\n") , -1); } CORBA::String_var type_name = mts_servant->get_type_name (); DDS::TopicQos topic_qos; participant->get_default_topic_qos(topic_qos); DDS::Topic_var topic = participant->create_topic("Movie Discussion List", type_name.in (), topic_qos, DDS::TopicListener::_nil()); if (CORBA::is_nil (topic.in ())) { ACE_ERROR_RETURN ((LM_ERROR, "(%P|%t) Failed to create_topic.\n") , -1); } // Initialize the transport TAO::DCPS::TransportImpl_rch tcp_impl = TheTransportFactory->create_transport_impl (TCP_IMPL_ID, ::TAO::DCPS::AUTO_CONFIG); // Indicate that the subscriber is about to become ready FILE* readers_ready = ACE_OS::fopen (sub_ready_filename, "w"); if (readers_ready == 0) { ACE_ERROR_RETURN ((LM_ERROR, "(%P|%t) ERROR Unable to create subscriber ready file.\n") , -1); } ACE_OS::fclose(readers_ready); // Check if the publisher is up and running ACE_stat stats; while (ACE_OS::stat (pub_ready_filename, &stats) == -1) { ACE_Time_Value small(0,250000); ACE_OS::sleep (small); } for (int count = 1; count <= sub_reinit_itr; count++) { if (verbose) { ACE_DEBUG ((LM_DEBUG, "(%P|%t) Reinitializing subscriber.\n")); } // Create the subscriber and attach to the corresponding // transport. DDS::Subscriber_var sub = participant->create_subscriber(SUBSCRIBER_QOS_DEFAULT, DDS::SubscriberListener::_nil()); if (CORBA::is_nil (sub.in ())) { ACE_ERROR_RETURN ((LM_ERROR, "(%P|%t) Failed to create_subscriber.\n") , -1); } // Attach the subscriber to the transport. TAO::DCPS::SubscriberImpl* sub_impl = ::TAO::DCPS::reference_to_servant < TAO::DCPS::SubscriberImpl, DDS::Subscriber_ptr> (sub.in ()); if (0 == sub_impl) { ACE_ERROR_RETURN ((LM_ERROR, "(%P|%t) Failed to obtain subscriber servant.\n") , -1); } TAO::DCPS::AttachStatus status = sub_impl->attach_transport(tcp_impl.in()); if (status != TAO::DCPS::ATTACH_OK) { std::string status_str; switch (status) { case TAO::DCPS::ATTACH_BAD_TRANSPORT: status_str = "ATTACH_BAD_TRANSPORT"; break; case TAO::DCPS::ATTACH_ERROR: status_str = "ATTACH_ERROR"; break; case TAO::DCPS::ATTACH_INCOMPATIBLE_QOS: status_str = "ATTACH_INCOMPATIBLE_QOS"; break; default: status_str = "Unknown Status"; break; } ACE_ERROR_RETURN ((LM_ERROR, "(%P|%t) Failed to attach to the transport. " "Status == %s.\n" , status_str.c_str()) , -1); } // Create the Datareaders DDS::DataReaderQos dr_qos; sub->get_default_datareader_qos (dr_qos); DDS::DataReader_var dr = sub->create_datareader(topic.in (), dr_qos, DDS::DataReaderListener::_nil()); if (CORBA::is_nil (dr.in ())) { ACE_ERROR_RETURN ((LM_ERROR, "(%P|%t) create_datareader failed.\n") , -1); } { ACE_OS::sleep (2); // This is where a speed-bump should be. } if (verbose) { ACE_DEBUG ((LM_DEBUG, "(%P|%t) *** Destroying Subscriber\n")); } // Delete data reader sub->delete_datareader(dr.in()); // Delete subscriber participant->delete_subscriber(sub.in()); sub = DDS::Subscriber::_nil(); } if (!CORBA::is_nil (participant.in ())) { participant->delete_contained_entities(); } if (!CORBA::is_nil (dpf.in ())) { dpf->delete_participant(participant.in ()); } TheTransportFactory->release(); TheServiceParticipant->shutdown (); // Indicate that the subscriber is done FILE* readers_completed = ACE_OS::fopen (sub_finished_filename, "w"); if (readers_completed == 0) { ACE_ERROR_RETURN ((LM_ERROR, "(%P|%t) ERROR Unable to create subscriber completed file.\n") , -1); } ACE_OS::fclose(readers_completed); } catch (CORBA::Exception& e) { ACE_ERROR_RETURN ((LM_ERROR, "(%P|%t) Exception caught in main (): %s (%s).\n" , e._name (), e._rep_id ()) , -1); } return 0; }
int do_reader(DDS::DomainParticipant_var participant, DDS::Topic_var topic, bool toggle) { // Create Subscriber DDS::Subscriber_var subscriber = participant->create_subscriber(SUBSCRIBER_QOS_DEFAULT, 0, OpenDDS::DCPS::DEFAULT_STATUS_MASK); if (!subscriber) { ACE_ERROR_RETURN((LM_ERROR, ACE_TEXT("ERROR: %N:%l: do_reader() -") ACE_TEXT(" create_subscriber failed!\n")), -1); } DDS::DataReaderQos qos; subscriber->get_default_datareader_qos(qos); qos.user_data.value.length(3); qos.user_data.value[0] = 0; qos.user_data.value[1] = 0; qos.user_data.value[2] = 0; qos.reliability.kind = DDS::RELIABLE_RELIABILITY_QOS; if (toggle) { ACE_DEBUG((LM_DEBUG, "Creating reader\n")); DDS::DataReader_var reader = subscriber->create_datareader(topic, qos, 0, OpenDDS::DCPS::DEFAULT_STATUS_MASK); if (!reader) { ACE_ERROR_RETURN((LM_ERROR, ACE_TEXT("ERROR: %N:%l: do_reader() -") ACE_TEXT(" create_datareader failed!\n")), -1); } ACE_OS::sleep(SLEEP_SHORT); // Go away. ACE_DEBUG((LM_DEBUG, "Deleting reader\n")); subscriber->delete_datareader(reader); ACE_OS::sleep(SLEEP_SHORT); // Come back. ACE_DEBUG((LM_DEBUG, "Creating reader\n")); reader = subscriber->create_datareader(topic, qos, 0, OpenDDS::DCPS::DEFAULT_STATUS_MASK); ACE_OS::sleep(SLEEP_SHORT); return 0; } else { struct Listener : public DDS::DataReaderListener { size_t found, lost; Listener() : found(0), lost(0) { } virtual void on_requested_deadline_missed (::DDS::DataReader_ptr, const ::DDS::RequestedDeadlineMissedStatus &) { } virtual void on_requested_incompatible_qos (::DDS::DataReader_ptr, const ::DDS::RequestedIncompatibleQosStatus &) { } virtual void on_sample_rejected (::DDS::DataReader_ptr, const ::DDS::SampleRejectedStatus &) { } virtual void on_liveliness_changed (::DDS::DataReader_ptr, const ::DDS::LivelinessChangedStatus &) { } virtual void on_data_available (::DDS::DataReader_ptr) { } virtual void on_subscription_matched (::DDS::DataReader_ptr, const ::DDS::SubscriptionMatchedStatus & status) { if (status.current_count_change > 0) { ACE_DEBUG((LM_DEBUG, "Reader found writer\n")); ++found; } if (status.current_count_change < 0) { ACE_DEBUG((LM_DEBUG, "Reader lost writer\n")); ++lost; } } virtual void on_sample_lost (::DDS::DataReader_ptr, const ::DDS::SampleLostStatus &) { } } listener; // Create DataReader DDS::DataReader_var reader = subscriber->create_datareader(topic, qos, &listener, OpenDDS::DCPS::DEFAULT_STATUS_MASK); if (!reader) { ACE_ERROR_RETURN((LM_ERROR, ACE_TEXT("ERROR: %N:%l: do_reader() -") ACE_TEXT(" create_datareader failed!\n")), -1); } ACE_OS::sleep(SLEEP_LONG); if (listener.found == 2 && listener.lost == 1) { reader->set_listener(0, OpenDDS::DCPS::DEFAULT_STATUS_MASK); return 0; } return -1; } }
int ACE_TMAIN (int argc, ACE_TCHAR *argv[]) { DDS::DomainParticipantFactory_var dpf = DDS::DomainParticipantFactory::_nil(); DDS::DomainParticipant_var participant = DDS::DomainParticipant::_nil(); try { QuantLibAddinCpp::initializeAddin(); boost::gregorian::date date ( boost::gregorian::from_undelimited_string( "20111019" ) ); long evaluationDate = QuantLib::Date( date.day(), QuantLib::Month(date.month().as_number()), date.year() ).serialNumber(); QuantLibAddinCpp::qlSettingsSetEvaluationDate(evaluationDate, OH_NULL); std::string ticker; // Initialize, and create a DomainParticipant dpf = TheParticipantFactoryWithArgs(argc, argv); qldds_utils::BasicDomainParticipant participant( dpf, EQUITY_OPTIONS_DOMAIN_ID ); participant.createPublisher(); participant.createSubscriber(); DDS::DomainParticipant_var dp = participant.getDomainParticipant(); ACE_Get_Opt cmd_opts( argc, argv, ":s:" ); int option; while ( (option = cmd_opts()) != EOF ) { switch( option ) { case 's' : ticker = cmd_opts.opt_arg(); break; } } // Topics // setting up qlBlackConstantVols Topic DDS::Topic_var ql_black_constant_vols_topic = participant.createTopicAndRegisterType < qlBlackConstantVolsTypeSupport_var, qlBlackConstantVolsTypeSupportImpl > ( QL_BLACK_CONSTANT_VOLS_TOPIC_NAME ); // setting up qlGeneralizedBlackScholesProcesses Topic DDS::Topic_var ql_generalized_black_scholes_processes_topic = participant.createTopicAndRegisterType < qlGeneralizedBlackScholesProcessesTypeSupport_var, qlGeneralizedBlackScholesProcessesTypeSupportImpl > ( QL_GENERALIZED_BLACK_SCHOLES_PROCESSES_TOPIC_NAME ); // setting up qlStrikedTypePayoff Topic DDS::Topic_var ql_striked_type_payoffs_topic = participant.createTopicAndRegisterType < qlStrikedTypePayoffsTypeSupport_var, qlStrikedTypePayoffsTypeSupportImpl > ( QL_STRIKED_TYPE_PAYOFFS_TOPIC_NAME ); // setting up qlEuropeanExercises Topic DDS::Topic_var ql_european_exercises_topic = participant.createTopicAndRegisterType < qlEuropeanExercisesTypeSupport_var, qlEuropeanExercisesTypeSupportImpl > ( QL_EUROPEAN_EXERCISES_TOPIC_NAME ); StraddleSetupTypeSupport_var ts_res = new StraddleSetupTypeSupportImpl; if ( ts_res->register_type(dp, "") != DDS::RETCODE_OK ) { std::cout << "Registration of the Topic FAILED!!!!" << std::endl; } CORBA::String_var type_name = ts_res->get_type_name(); std::cout << "Type Name : " << type_name << std::endl; std::stringstream multi_topic_select; multi_topic_select << "SELECT ticker, putVols, callVols, putPayoffs, callPayoffs, process, exercises FROM "<< QL_BLACK_CONSTANT_VOLS_TOPIC_NAME << " NATURAL JOIN " << QL_GENERALIZED_BLACK_SCHOLES_PROCESSES_TOPIC_NAME << " NATURAL JOIN " << QL_STRIKED_TYPE_PAYOFFS_TOPIC_NAME << " NATURAL JOIN " << QL_EUROPEAN_EXERCISES_TOPIC_NAME << " WHERE ticker = '" << ticker << "'"; std::cout << multi_topic_select.str() << std::endl; DDS::MultiTopic_var mt = dp->create_multitopic("MyMultiTopic", type_name, multi_topic_select.str().c_str(), DDS::StringSeq()); if ( CORBA::is_nil( mt ) ) std::cout << "MultiTopic Subscribtion failed.!!!!" << mt << std::endl; DDS::Subscriber_var sub = participant.getSubscriber(); std::cout << "Creating Data Reader"<< std::endl; DDS::DataReader_var dr = sub->create_datareader(mt, DATAREADER_QOS_DEFAULT, 0, ::OpenDDS::DCPS::DEFAULT_STATUS_MASK); std::cout << "Done..."<< std::endl; DDS::WaitSet_var ws = new DDS::WaitSet; DDS::ReadCondition_var rc = dr->create_readcondition( DDS::ANY_SAMPLE_STATE, DDS::ANY_VIEW_STATE, DDS::ANY_INSTANCE_STATE); ws->attach_condition(rc); DDS::Duration_t infinite = { DDS::DURATION_INFINITE_SEC, DDS::DURATION_INFINITE_NSEC}; DDS::ConditionSeq active; int ret = ws->wait(active, infinite); if (ret != DDS::RETCODE_OK) return false; ws->detach_condition(rc); // setting up topic for Straddles DDS::Topic_var straddles_topic = participant.createTopicAndRegisterType < StraddlesTypeSupport_var, StraddlesTypeSupportImpl > ( STRADDLES_TOPIC_NAME ); StraddlesDataWriter_var straddles_dw = participant.createDataWriter < StraddlesDataWriter_var, StraddlesDataWriter > ( straddles_topic ); int calculation_performed = 0; do { StraddleSetupDataReader_var res_dr = StraddleSetupDataReader::_narrow(dr); StraddleSetupSeq data; DDS::SampleInfoSeq info; int ret = res_dr->take_w_condition(data, info, DDS::LENGTH_UNLIMITED, rc); if (ret == DDS::RETCODE_OK) { qlBlackConstantVolMatrix& putVols = data[0].putVols; qlStrikedTypePayoffSeq& putPayoffs = data[0].putPayoffs; qlBlackConstantVolMatrix& callVols = data[0].callVols; qlStrikedTypePayoffSeq& callPayoffs = data[0].callPayoffs; processes::qlGeneralizedBlackScholesProcess& process = data[0].process; qlEuropeanExerciseSeq& exercises = data[0].exercises; Straddles straddles; straddles.ticker = CORBA::string_dup( ticker.c_str() ); straddles.underlying = data[0].process.Underlying; int strike_count = putPayoffs.length() + callPayoffs.length(); int exercises_count = exercises.length(); straddles.options.length( strike_count * exercises_count ); int priced_options = 0; price( ticker, putVols, putPayoffs, process, exercises, straddles, priced_options ); price( ticker, callVols, callPayoffs, process, exercises, straddles, priced_options ); ACE_DEBUG( (LM_INFO, "(%T|%P|%t) Publishing Straddles for ticker : %s trading @%f\n", ticker.c_str(), data[0].process.Underlying ) ); int ret = straddles_dw->write( straddles, DDS::HANDLE_NIL ); if (ret != DDS::RETCODE_OK) { ACE_ERROR ((LM_ERROR, ACE_TEXT("(%P|%t) ERROR: Publishing Straddles for ticker : %s failed %d.\n"), ticker.c_str(), ret)); } calculation_performed++; } } while ( calculation_performed < 30 ); cout << "Exiting..." << endl; } catch (CORBA::Exception& e) { cerr << "Exception caught in main.cpp:" << endl << e << endl; ACE_OS::exit(1); } TheServiceParticipant->shutdown(); return 0; }
int ACE_TMAIN(int argc, ACE_TCHAR *argv[]) { try { // Initialize DomainParticipantFactory DDS::DomainParticipantFactory_var dpf = TheParticipantFactoryWithArgs(argc, argv); // 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 main (int argc, char *argv[]) { const int domainId = 411; const char *topicName = "Stock Quotes"; try { DDS::DomainParticipantFactory_var dpf; DDS::DomainParticipant_var participant; dpf = TheParticipantFactoryWithArgs(argc, argv); // To Do: Create the participant participant = dpf->create_participant(domainId, PARTICIPANT_QOS_DEFAULT, DDS::DomainParticipantListener::_nil()); if (CORBA::is_nil (participant.in ())) { cerr << "create_participant failed." << endl; return 1 ; } // End: Create the participant QuoterTypeSupportImpl* servant = new QuoterTypeSupportImpl(); PortableServer::ServantBase_var safe_servant = servant; // To Do: Register the type if (DDS::RETCODE_OK != servant->register_type(participant.in (), "")) { cerr << "Failed to register the QuoterTypeTypeSupport." << endl; exit(1); } // End: Register the type CORBA::String_var type_name = servant->get_type_name (); // To Do: Get the (default) topic QoS and create the topic DDS::TopicQos topic_qos; participant->get_default_topic_qos(topic_qos); DDS::Topic_var topic = participant->create_topic(topicName, type_name.in (), topic_qos, DDS::TopicListener::_nil()); if (CORBA::is_nil (topic.in ())) { cerr << "Failed to create_topic." << endl; exit(1); } // End: Get the (default) topic QoS and create the topic // To Do: Create the subscriber DDS::Subscriber_var sub = participant->create_subscriber(SUBSCRIBER_QOS_DEFAULT, DDS::SubscriberListener::_nil()); if (CORBA::is_nil (sub.in ())) { cerr << "Failed to create_subscriber." << endl; exit(1); } // End: Create the subscriber // jhoffert // There seem to be problems using auto configurations with an application // distributed across different nodes. Take this out for now. // Initialize the transport TAO::DCPS::TransportImpl_rch tcp_impl = TheTransportFactory->create_transport_impl (TCP_IMPL_ID, //::TAO::DCPS::AUTO_CONFIG); ::TAO::DCPS::DONT_AUTO_CONFIG); TAO::DCPS::TransportConfiguration_rch reader_config = //TheTransportFactory->get_configuration (SUB_TRAFFIC); TheTransportFactory->get_configuration (TCP_IMPL_ID); TAO::DCPS::SimpleTcpConfiguration* reader_tcp_config = static_cast <TAO::DCPS::SimpleTcpConfiguration*> (reader_config.in ()); if (0 != ACE_OS::strcmp ("default", reader_address_str)) { ACE_INET_Addr reader_address (reader_address_str); reader_tcp_config->local_address_ = reader_address; } if (0 != tcp_impl->configure (reader_config.in ())) { ACE_ERROR ((LM_ERROR, ACE_TEXT("(%P|%t) ::main: ") ACE_TEXT("Failed to configure the transport.\n"))); exit(1); } // jhoffert - End of transport configuration changes // Attach the subscriber to the transport. TAO::DCPS::SubscriberImpl* sub_impl = ::TAO::DCPS::reference_to_servant< TAO::DCPS::SubscriberImpl, DDS::Subscriber_ptr> (sub.in ()); if (0 == sub_impl) { cerr << "Failed to obtain subscriber servant\n" << endl; exit(1); } TAO::DCPS::AttachStatus status = sub_impl->attach_transport(tcp_impl.in()); if (status != TAO::DCPS::ATTACH_OK) { std::string status_str; switch (status) { case TAO::DCPS::ATTACH_BAD_TRANSPORT: status_str = "ATTACH_BAD_TRANSPORT"; break; case TAO::DCPS::ATTACH_ERROR: status_str = "ATTACH_ERROR"; break; case TAO::DCPS::ATTACH_INCOMPATIBLE_QOS: status_str = "ATTACH_INCOMPATIBLE_QOS"; break; default: status_str = "Unknown Status"; break; } cerr << "Failed to attach to the transport. Status == " << status_str.c_str() << endl; exit(1); } // activate the listener DataReaderListenerImpl listener_servant; PortableServer::POA_var poa = TheServiceParticipant->the_poa (); CORBA::Object_var obj = poa->servant_to_reference(&listener_servant); DDS::DataReaderListener_var listener = DDS::DataReaderListener::_narrow (obj.in ()); if (CORBA::is_nil (listener.in ())) { cerr << "listener is nil." << endl; exit(1); } // To Do: Get default data reader QoS and create the data reader. DDS::DataReaderQos dr_qos; sub->get_default_datareader_qos (dr_qos); DDS::DataReader_var dr = sub->create_datareader(topic.in (), dr_qos, listener.in ()); if (CORBA::is_nil (dr.in ())) { cerr << "create_datareader failed." << endl; exit(1); } // End: Get default data reader QoS and create the data reader. // To Do: Set up the constraints for when the subscriber is done // receiving updates. int expected = 10; while ( listener_servant.num_reads() < expected) { ACE_OS::sleep (1); } // End: Set up the constraints for how long the subscriber should // receive updates. // To Do: Delete the participant's contained entities if (!CORBA::is_nil (participant.in ())) { participant->delete_contained_entities(); } // End: Delete the participant's contained entities if (!CORBA::is_nil (dpf.in ())) { dpf->delete_participant(participant.in ()); } ::DDS::InstanceHandleSeq handles; while (1) { ACE_OS::sleep(1); dr->get_matched_publications(handles); if (handles.length() == 0) break; } ACE_OS::sleep(2); TheTransportFactory->release(); TheServiceParticipant->shutdown (); } catch (CORBA::Exception& e) { cerr << "Exception caught in main ():" << endl << e << endl; return 1; } return 0; }
int ACE_TMAIN (int argc, ACE_TCHAR *argv[]) { try { DDS::DomainParticipantFactory_var dpf = TheParticipantFactoryWithArgs(argc, argv); DDS::DomainParticipant_var participant = dpf->create_participant (411, PARTICIPANT_QOS_DEFAULT, DDS::DomainParticipantListener::_nil(), ::OpenDDS::DCPS::DEFAULT_STATUS_MASK); if (CORBA::is_nil (participant.in ())) { cerr << "create_participant failed." << endl; return 1 ; } Messenger::MessageTypeSupport_var mts_servant = new Messenger::MessageTypeSupportImpl; if (DDS::RETCODE_OK != mts_servant->register_type(participant.in (), "")) { cerr << "Failed to register the MessageTypeTypeSupport." << endl; exit(1); } CORBA::String_var type_name = mts_servant->get_type_name (); DDS::TopicQos topic_qos; participant->get_default_topic_qos(topic_qos); DDS::Topic_var topic = participant->create_topic ("Movie Discussion List", type_name.in (), topic_qos, DDS::TopicListener::_nil(), ::OpenDDS::DCPS::DEFAULT_STATUS_MASK); if (CORBA::is_nil (topic.in ())) { cerr << "Failed to create_topic." << endl; exit(1); } // Create the subscriber and attach to the corresponding // transport. DDS::Subscriber_var sub = participant->create_subscriber (SUBSCRIBER_QOS_DEFAULT, DDS::SubscriberListener::_nil(), ::OpenDDS::DCPS::DEFAULT_STATUS_MASK); if (CORBA::is_nil (sub.in ())) { cerr << "Failed to create_subscriber." << endl; exit(1); } // activate the listener DDS::DataReaderListener_var listener (new DataReaderListenerImpl); DataReaderListenerImpl* const listener_servant = dynamic_cast<DataReaderListenerImpl*>(listener.in()); if (CORBA::is_nil (listener.in ())) { cerr << "listener is nil." << endl; exit(1); } // Create the Datareader DDS::DataReaderQos dr_qos; sub->get_default_datareader_qos(dr_qos); dr_qos.durability.kind = DDS::PERSISTENT_DURABILITY_QOS; DDS::DataReader_var dr = sub->create_datareader(topic, dr_qos, listener, OpenDDS::DCPS::DEFAULT_STATUS_MASK); if (CORBA::is_nil (dr.in ())) { cerr << "create_datareader failed." << endl; exit(1); } int const expected = 10; while (listener_servant->num_reads() < expected) { ACE_OS::sleep (1); } if (!CORBA::is_nil (participant.in ())) { participant->delete_contained_entities(); } if (!CORBA::is_nil (dpf.in ())) { dpf->delete_participant(participant.in ()); } ACE_OS::sleep(2); TheServiceParticipant->shutdown (); } catch (CORBA::Exception& e) { cerr << "SUB: Exception caught in main ():" << endl << e << endl; return 1; } return 0; }
bool ExampleSubscriber::init() { this->msgs_count = 0; domain = DDS::DOMAIN_ID_DEFAULT; partition_name = "Default"; topic_name = "big_chatter"; /* Create Domain Participant Factory */ this->dpf = DDS::DomainParticipantFactory::get_instance(); checkHandle(dpf.in(), "DDS::DomainParticipantFactory::get_instance"); /* Create Domain Participant */ std::cout << "Creating domain participant in subscriber" << std::endl; this->participant = dpf->create_participant( domain, PARTICIPANT_QOS_DEFAULT, NULL, DDS::STATUS_MASK_NONE ); checkHandle(participant.in(), "DDS::DomainParticipantFactory::create_participant"); /* Create a default QoS for Topics */ status = participant->get_default_topic_qos(default_topic_qos); checkStatus(status, "DDS::DomainParticipant::get_default_topic_qos"); // default_topic_qos.reliability.kind = DDS::RELIABLE_RELIABILITY_QOS; default_topic_qos.reliability.kind = DDS::BEST_EFFORT_RELIABILITY_QOS; /* Register the LargeMessage Type */ large_message_ts = new LargeMsg::LargeMessageTypeSupport(); checkHandle(large_message_ts.in(), "new LargeMessageTypeSupport"); this->large_message_type_name = large_message_ts->get_type_name(); status = large_message_ts->register_type(participant.in(), large_message_type_name); checkStatus(status, "LargeMsg::LargeMessageTypeSupport::register_type"); /* Setup the Subscribers's QoS */ status = participant->get_default_subscriber_qos(sub_qos); checkStatus(status, "DDS::DomainParticipant::get_default_subscriber_qos"); sub_qos.partition.name.length(1); sub_qos.partition.name[0] = partition_name; /* Create the subscriber */ this->subscriber = participant->create_subscriber( sub_qos, NULL, DDS::STATUS_MASK_NONE ); checkHandle(subscriber.in(), "DDS::DomainParticipant::create_subscriber"); /* Create the Topic */ this->large_message_topic = participant->create_topic( topic_name, large_message_type_name, default_topic_qos, NULL, DDS::STATUS_MASK_NONE ); checkHandle(large_message_topic.in(), "DDS::DomainParticipant::create_topic(LargeMessage)"); /* Create Topic specific DataReader */ topic_reader = subscriber->create_datareader( large_message_topic.in(), DATAREADER_QOS_USE_TOPIC_QOS, NULL, DDS::STATUS_MASK_NONE ); checkHandle(topic_reader.in(), "DDS::Subscriber::create_datareader"); /* Narrow topic_reader down to LargeMessage specific DataReader */ this->data_reader = LargeMsg::LargeMessageDataReader::_narrow(topic_reader.in()); checkHandle(data_reader.in(), "LargeMsg::LargeMessageDataReader::_narrow"); this->large_msg_seq = new LargeMsg::LargeMessageSeq(); this->sample_info_seq = new DDS::SampleInfoSeq(); std::cout << "Polling DataReader..." << std::endl; return true; }