DDS::DomainParticipant_var
Factory::participant(const DDS::DomainParticipantFactory_var& dpf) const
{
DDS::DomainParticipant_var dp =
dpf->create_participant(MY_DOMAIN,
PARTICIPANT_QOS_DEFAULT,
DDS::DomainParticipantListener::_nil(),
OpenDDS::DCPS::DEFAULT_STATUS_MASK);
TEST_CHECK(!CORBA::is_nil(dp.in()));
// If there is a ini file-based configuration name initialize
// the transport configuration for the corresponding Entity
if (opts_.configuration_str != "none" && opts_.entity_str == "participant")
{
OpenDDS::DCPS::TransportRegistry::instance()->bind_config(opts_.configuration_str, dp.in());
}
// Register TypeSupport (Messenger::Message)
CORBA::String_var tn = typsup_->get_type_name();
TEST_CHECK(DDS::RETCODE_OK == typsup_->register_type(dp.in(), tn)); // Use the default name for the type
return dp;
}
DDS::DomainParticipant*
OpenDDS::Model::Delegate::createParticipant(
unsigned long domain,
const DDS::DomainParticipantQos& participantQos,
DDS::StatusMask mask,
const OPENDDS_STRING& transportConfig
)
{
DDS::DomainParticipantFactory_var pfact = TheParticipantFactory;
DDS::DomainParticipant_var participant
= pfact->create_participant(
domain,
participantQos,
DDS::DomainParticipantListener::_nil(),
mask
);
// If the modeler specified a transport config, bind to it
if (!transportConfig.empty()) {
try {
TheTransportRegistry->bind_config(transportConfig, participant);
} catch (OpenDDS::DCPS::Transport::Exception&) {
pfact->delete_participant(participant);
return 0;
}
}
return participant;
}
OpenDDS_Domain_Manager::OpenDDS_Domain_Manager (int & argc,
ACE_TCHAR* argv[],
DDS::DomainId_t domain_id,
const DDS::DomainParticipantQos & qos)
: dp_ (DDS::DomainParticipant::_nil ()),
shutdown_lock_ (0),
exit_handler_ (shutdown_lock_)
{
// get the domain participant factory from the singleton
DDS::DomainParticipantFactory_var dpf =
OpenDDS::DCPS::Service_Participant::instance ()->
get_domain_participant_factory (argc, argv);
this->parse_args (argc, argv);
// create the participant named 'participant'.
dp_ = dpf->create_participant (domain_id,
qos,
DDS::DomainParticipantListener::_nil (),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
// check for successful creation
if (CORBA::is_nil (dp_.in ()))
throw Manager_Exception ("Failed to create domain participant.");
// add a the handler for the SIGINT signal here
ACE_Sig_Handler sig_handler;
sig_handler.register_handler (SIGINT, &exit_handler_);
}
DDS::DomainParticipant_var
createParticipant(DDS::DomainParticipantFactory_var dpf)
{
// Create DomainParticipant
DDS::DomainParticipant_var participant =
dpf->create_participant(42, // made-up domain ID
PARTICIPANT_QOS_DEFAULT,
0, // no listener
OpenDDS::DCPS::DEFAULT_STATUS_MASK);
// Check for failure
if (!participant) {
throw std::string("failed to create domain participant");
}
return participant;
}
DDS::DomainParticipant_var
TestBase::create_participant()
{
DDS::DomainId_t domain = DEFAULT_DOMAIN;
DDS::DomainParticipantQos qos;
DDS::DomainParticipantFactory_var dpf = TheParticipantFactory;
if (dpf->get_default_participant_qos(qos) != DDS::RETCODE_OK) {
ACE_ERROR((LM_ERROR,
ACE_TEXT("ERROR: %N:%l: create_participant() -")
ACE_TEXT(" get_default_participant_qos failed!\n")));
ACE_OS::exit(-1);
}
DDS::DomainParticipantListener_ptr listener =
DDS::DomainParticipantListener::_nil();
DDS::StatusMask status = OpenDDS::DCPS::DEFAULT_STATUS_MASK;
if (init_participant(domain, qos, listener, status) != DDS::RETCODE_OK) {
ACE_ERROR((LM_ERROR,
ACE_TEXT("ERROR: %N:%l: create_participant() -")
ACE_TEXT(" init_participant failed!\n")));
ACE_OS::exit(-1);
}
DDS::DomainParticipant_var participant =
dpf->create_participant(domain, qos, listener, status);
if (CORBA::is_nil(participant.in())) {
ACE_ERROR((LM_ERROR,
ACE_TEXT("ERROR: %N:%l: create_participant() -")
ACE_TEXT(" create_participant failed!\n")));
ACE_OS::exit(-1);
}
return participant;
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
try {
// Initialize DomainParticipantFactory
DDS::DomainParticipantFactory_var dpf =
TheParticipantFactoryWithArgs(argc, argv);
// Create DomainParticipant
DDS::DomainParticipant_var participant =
dpf->create_participant(42,
PARTICIPANT_QOS_DEFAULT,
0,
OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (!participant) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("ERROR: %N:%l: main() -")
ACE_TEXT(" create_participant failed!\n")), -1);
}
// Register Type (Messenger::Message)
Messenger::MessageTypeSupport_var ts =
new Messenger::MessageTypeSupportImpl;
if (ts->register_type(participant, "") != DDS::RETCODE_OK) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("ERROR: %N:%l: main() -")
ACE_TEXT(" register_type failed!\n")), -1);
}
// Create Topic (Movie Discussion List)
CORBA::String_var type_name = ts->get_type_name();
DDS::Topic_var topic =
participant->create_topic("Movie Discussion List",
type_name,
TOPIC_QOS_DEFAULT,
0,
OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (!topic) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("ERROR: %N:%l: main() -")
ACE_TEXT(" create_topic failed!\n")), -1);
}
// Create Subscriber
DDS::Subscriber_var subscriber =
participant->create_subscriber(SUBSCRIBER_QOS_DEFAULT,
0,
OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (!subscriber) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("ERROR: %N:%l: main() -")
ACE_TEXT(" create_subscriber failed!\n")), -1);
}
// Create DataReader
DDS::DataReaderListener_var listener(new DataReaderListenerImpl);
DDS::DataReader_var reader =
subscriber->create_datareader(topic,
DATAREADER_QOS_DEFAULT,
listener,
OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (!reader) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("ERROR: %N:%l: main() -")
ACE_TEXT(" create_datareader failed!\n")), -1);
}
Messenger::MessageDataReader_var reader_i =
Messenger::MessageDataReader::_narrow(reader);
if (!reader_i) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("ERROR: %N:%l: main() -")
ACE_TEXT(" _narrow failed!\n")),
-1);
}
// Block until Publisher completes
DDS::StatusCondition_var condition = reader->get_statuscondition();
condition->set_enabled_statuses(DDS::SUBSCRIPTION_MATCHED_STATUS);
DDS::WaitSet_var ws = new DDS::WaitSet;
ws->attach_condition(condition);
while (true) {
DDS::SubscriptionMatchedStatus matches;
if (reader->get_subscription_matched_status(matches) != DDS::RETCODE_OK) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("ERROR: %N:%l: main() -")
ACE_TEXT(" get_subscription_matched_status failed!\n")), -1);
}
if (matches.current_count == 0 && matches.total_count > 0) {
break;
}
DDS::ConditionSeq conditions;
DDS::Duration_t timeout = { 60, 0 };
if (ws->wait(conditions, timeout) != DDS::RETCODE_OK) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("ERROR: %N:%l: main() -")
ACE_TEXT(" wait failed!\n")), -1);
}
}
ws->detach_condition(condition);
// Clean-up!
participant->delete_contained_entities();
dpf->delete_participant(participant);
TheServiceParticipant->shutdown();
} catch (const CORBA::Exception& e) {
e._tao_print_exception("Exception caught in main():");
return -1;
}
return 0;
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
bool ok = true;
bool generated_config = false;
try {
//Look to see if the config file (.ini) was generated
//for rtps participant processing
for(int i = 0; i < argc; ++i) {
if(ACE_OS::strstr(argv[i], ACE_TEXT("generated"))) {
generated_config = true;
}
}
// Initialize DomainParticipantFactory
DDS::DomainParticipantFactory_var dpf =
TheParticipantFactoryWithArgs(argc, argv);
// handle test performance issue on one platform
#if defined (sun)
const char* udpTransName = "udp";
OpenDDS::DCPS::TransportInst_rch inst = OpenDDS::DCPS::TransportRegistry::instance()->get_inst(udpTransName);
if (inst != 0) {
OpenDDS::DCPS::UdpInst_rch udp_inst = OpenDDS::DCPS::dynamic_rchandle_cast<OpenDDS::DCPS::UdpInst>(inst);
if (udp_inst == 0) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l main()")
ACE_TEXT(" ERROR: retrieving transport config for: %C failed!\n"),
udpTransName), -1);
}
udp_inst->rcv_buffer_size_ = 0x40000;
}
#endif
const Options options(argc, argv);
// Create DomainParticipant
typedef std::vector<DDS::DomainParticipant_var> Participants;
Participants participants(options.num_sub_participants);
// Register Type (Messenger::Message)
Messenger::MessageTypeSupport_var ts =
new Messenger::MessageTypeSupportImpl();
CORBA::String_var type_name = ts->get_type_name();
typedef std::vector<DataReaderListenerImpl*> ListenerServants;
ListenerServants listener_servants;
std::vector<DDS::DataReaderListener_var> listeners;
std::stringstream ss;
ss << std::setw(5) << ACE_OS::getpid();
const std::string pid = ss.str();
ACE_DEBUG((LM_DEBUG, ACE_TEXT("%T (%P|%t) Created dpf\n")));
unsigned int part_index = 0;
for (Participants::iterator part = participants.begin();
part != participants.end();
++part, ++part_index) {
ACE_DEBUG((LM_DEBUG, ACE_TEXT("%T (%P|%t) Creating participant\n")));
*part =
dpf->create_participant(411,
PARTICIPANT_QOS_DEFAULT,
DDS::DomainParticipantListener::_nil(),
OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil(part->in())) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l main()")
ACE_TEXT(" ERROR: create_participant() failed!\n")), -1);
}
if (generated_config) {
std::stringstream domain_config_stream;
std::string config_name = "domain_part_";
domain_config_stream << config_name << part_index;
std::string config;
config = domain_config_stream.str();
TheTransportRegistry->bind_config(config, *part);
}
if (ts->register_type(part->in(), "") != DDS::RETCODE_OK) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l main()")
ACE_TEXT(" ERROR: register_type() failed!\n")), -1);
}
// Create Topic (Movie Discussion List)
DDS::Topic_var topic =
(*part)->create_topic("Movie Discussion List",
type_name.in(),
TOPIC_QOS_DEFAULT,
DDS::TopicListener::_nil(),
OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil(topic.in())) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l main()")
ACE_TEXT(" ERROR: create_topic() failed!\n")), -1);
}
// Create Subscriber
DDS::Subscriber_var sub =
(*part)->create_subscriber(SUBSCRIBER_QOS_DEFAULT,
DDS::SubscriberListener::_nil(),
OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil(sub.in())) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l main()")
ACE_TEXT(" ERROR: create_subscriber() failed!\n")), -1);
}
DDS::DataReaderQos qos;
sub->get_default_datareader_qos(qos);
qos.liveliness.kind = DDS::AUTOMATIC_LIVELINESS_QOS;
qos.liveliness.lease_duration.sec = 10;
qos.liveliness.lease_duration.nanosec = 0;
qos.history.kind = DDS::KEEP_ALL_HISTORY_QOS;
if (options.reliable) {
qos.reliability.kind = DDS::RELIABLE_RELIABILITY_QOS;
}
for (unsigned int reader = 0; reader < options.num_readers; ++reader) {
ACE_DEBUG((LM_DEBUG, ACE_TEXT("%T (%P|%t) Creating reader\n")));
// Create DataReader
listener_servants.push_back(new DataReaderListenerImpl(options, pid, part_index, reader));
listeners.push_back(DDS::DataReaderListener_var(listener_servants.back()));
DDS::DataReader_var data_reader =
sub->create_datareader(topic.in(),
qos,
listeners.back().in(),
OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil(data_reader.in())) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l main()")
ACE_TEXT(" ERROR: create_datareader() failed!\n")), -1);
}
}
}
const unsigned int sleep_delay_msec = 500;
unsigned int delay = 0;
while (delay < options.total_duration_msec) {
bool complete = true;
for (ListenerServants::const_iterator listener = listener_servants.begin();
listener != listener_servants.end();
++listener) {
if (!(*listener)->done()) {
complete = false;
}
}
if (complete)
break;
delay += sleep_delay_msec;
ACE_OS::sleep(ACE_Time_Value(0, sleep_delay_msec * 1000));
}
ACE_DEBUG((LM_DEBUG, ACE_TEXT("%T (%P|%t) Listeners done (ran for %d msec)\n"), delay));
if (delay >= options.total_duration_msec) {
for (ListenerServants::const_iterator listener = listener_servants.begin();
listener != listener_servants.end();
++listener) {
(*listener)->report_errors();
}
if (options.reliable) {
ok = false;
}
}
// Clean-up!
for (Participants::iterator part = participants.begin();
part != participants.end();
++part) {
(*part)->delete_contained_entities();
dpf->delete_participant(*part);
}
TheServiceParticipant->shutdown();
ACE_Thread_Manager::instance()->wait();
} catch (const CORBA::Exception& e) {
e._tao_print_exception("Exception caught in main():");
return -1;
} catch (const OpenDDS::DCPS::Transport::Exception& e) {
ACE_DEBUG((LM_ERROR, "Transport exception caught in subscriber main\n"));
return -1;
}
ACE_DEBUG((LM_DEBUG, ACE_TEXT("%T (%P|%t) Subscriber exiting\n")));
return ok ? EXIT_SUCCESS : EXIT_FAILURE;
}
int ACE_TMAIN (int argc, ACE_TCHAR *argv[]) {
try {
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;
}
MessageTypeSupportImpl* servant = new MessageTypeSupportImpl;
if (DDS::RETCODE_OK != servant->register_type(participant.in (), "")) {
cerr << "register_type failed." << endl;
exit(1);
}
CORBA::String_var type_name = servant->get_type_name ();
DDS::TopicQos topic_qos;
participant->get_default_topic_qos(topic_qos);
DDS::Topic_var topic =
participant->create_topic ("Movie Discussion List",
type_name.in (),
topic_qos,
DDS::TopicListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (topic.in ())) {
cerr << "create_topic failed." << endl;
exit(1);
}
DDS::Publisher_var pub =
participant->create_publisher(PUBLISHER_QOS_DEFAULT,
DDS::PublisherListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (pub.in ())) {
cerr << "create_publisher failed." << endl;
exit(1);
}
// Create the datawriter
DDS::DataWriterQos dw_qos;
pub->get_default_datawriter_qos (dw_qos);
DDS::DataWriter_var dw =
pub->create_datawriter(topic.in (),
dw_qos,
DDS::DataWriterListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (dw.in ())) {
cerr << "create_datawriter failed." << endl;
exit(1);
}
Writer* writer = new Writer(dw.in());
writer->start ();
while ( !writer->is_finished()) {
ACE_Time_Value small_time(0,250000);
ACE_OS::sleep (small_time);
}
// Cleanup
writer->end();
delete writer;
participant->delete_contained_entities();
dpf->delete_participant(participant);
TheServiceParticipant->shutdown();
} catch (CORBA::Exception& e) {
cerr << "Exception caught in main.cpp:" << endl
<< e << endl;
exit(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;
}
if (parse_args (argc, argv) == -1) {
return -1;
}
{
// At this point we are connected to the Info Repo.
// Trigger the driver
std::ofstream ior_stream (driver_trigger.c_str());
if (!ior_stream) {
std::cerr << "Unable to open internal trigger file: "
<< driver_trigger << std::endl;
return -1;
}
ior_stream << "junk";
}
int max_wait_time = 30; //seconds
int count = 0;
while (true)
{
if (count > max_wait_time) {
std::cerr << "Timed out waiting for external file: "
<< publisher_trigger << std::endl;
return -1;
}
// check for file
ACE_stat my_stat;
if (ACE_OS::stat (publisher_trigger.c_str(), &my_stat) == 0) {
// found the trigger file.
break;
}
ACE_OS::sleep (1);
}
MessageTypeSupportImpl* servant = new MessageTypeSupportImpl();
OpenDDS::DCPS::LocalObject_var safe_servant = servant;
if (DDS::RETCODE_OK != servant->register_type(participant.in (), "")) {
cerr << "register_type failed." << endl;
exit(1);
}
CORBA::String_var type_name = servant->get_type_name ();
DDS::TopicQos topic_qos;
participant->get_default_topic_qos(topic_qos);
DDS::Topic_var topic =
participant->create_topic ("Movie Discussion List",
type_name.in (),
topic_qos,
DDS::TopicListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (topic.in ())) {
cerr << "create_topic failed." << endl;
exit(1);
}
DDS::Publisher_var pub =
participant->create_publisher(PUBLISHER_QOS_DEFAULT,
DDS::PublisherListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (pub.in ())) {
cerr << "create_publisher failed." << endl;
exit(1);
}
// Create the datawriter
DDS::DataWriterQos dw_qos;
pub->get_default_datawriter_qos (dw_qos);
DDS::DataWriter_var dw =
pub->create_datawriter(topic.in (),
dw_qos,
DDS::DataWriterListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (dw.in ())) {
cerr << "create_datawriter failed." << endl;
exit(1);
}
Writer* writer = new Writer(dw.in());
writer->start ();
while ( !writer->is_finished()) {
ACE_Time_Value small_time(0,250000);
ACE_OS::sleep (small_time);
}
// Cleanup
writer->end();
delete writer;
participant->delete_contained_entities();
dpf->delete_participant(participant);
TheServiceParticipant->shutdown();
}
catch (CORBA::Exception& e)
{
cerr << "PUB: Exception caught in main.cpp:" << endl
<< e << endl;
exit(1);
}
return 0;
}
int ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
int result = 0;
ACE_DEBUG ((LM_DEBUG, "(%P|%t) subscriber main\n"));
try
{
DDS::DomainParticipantFactory_var dpf;
DDS::DomainParticipant_var participant;
dpf = TheParticipantFactoryWithArgs(argc, argv);
if (parse_args (argc, argv) == -1) {
return -1;
}
DDS::DomainParticipantQos partQos;
dpf->get_default_participant_qos(partQos);
// set up user data in DP qos
CORBA::ULong part_user_data_len
= static_cast<CORBA::ULong>(ACE_OS::strlen (PART_USER_DATA));
partQos.user_data.value.length (part_user_data_len);
partQos.user_data.value.replace (part_user_data_len,
part_user_data_len,
reinterpret_cast<CORBA::Octet*>(PART_USER_DATA));
participant = dpf->create_participant(411,
partQos,
DDS::DomainParticipantListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (participant.in ())) {
cerr << "subscriber: create_participant failed." << endl;
return 1 ;
}
::Messenger::MessageTypeSupport_var mts = new ::Messenger::MessageTypeSupportImpl();
if (DDS::RETCODE_OK != mts->register_type(participant.in (), "Messenger")) {
cerr << "subscriber: Failed to register the MessageTypeTypeSupport." << endl;
exit(1);
}
CORBA::String_var type_name = mts->get_type_name ();
DDS::TopicQos topic_qos;
participant->get_default_topic_qos(topic_qos);
// set up topic data in topic qos
CORBA::ULong topic_data_len = static_cast<CORBA::ULong>(ACE_OS::strlen (TOPIC_DATA));
topic_qos.topic_data.value.length (topic_data_len);
topic_qos.topic_data.value.replace (topic_data_len, topic_data_len, reinterpret_cast<CORBA::Octet*>(TOPIC_DATA));
DDS::Topic_var topic = participant->create_topic("Movie Discussion List",
type_name.in (),
topic_qos,
DDS::TopicListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (topic.in ())) {
cerr << "subscriber: Failed to create_topic." << endl;
exit(1);
}
// Create the subscriber
DDS::SubscriberQos sub_qos;
participant->get_default_subscriber_qos (sub_qos);
// set up group data in subscriber qos
CORBA::ULong group_data_len = static_cast<CORBA::ULong> (ACE_OS::strlen (GROUP_DATA));
sub_qos.group_data.value.length (group_data_len);
sub_qos.group_data.value.replace (group_data_len, group_data_len, reinterpret_cast<CORBA::Octet*>(GROUP_DATA));
DDS::Subscriber_var sub =
participant->create_subscriber(sub_qos,
DDS::SubscriberListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (sub.in ())) {
cerr << "subscriber: Failed to create_subscriber." << endl;
exit(1);
}
// activate the listener
DDS::DataReaderListener_var listener (new DataReaderListenerImpl);
DataReaderListenerImpl* listener_servant =
dynamic_cast<DataReaderListenerImpl*>(listener.in());
DDS::Subscriber_var builtin = participant->get_builtin_subscriber();
DDS::DataReader_var bitdr =
builtin->lookup_datareader(OpenDDS::DCPS::BUILT_IN_PUBLICATION_TOPIC);
listener_servant->set_builtin_datareader(bitdr.in());
if (CORBA::is_nil (listener.in ())) {
cerr << "subscriber: listener is nil." << endl;
exit(1);
}
// Create the Datareaders
DDS::DataReaderQos dr_qos;
sub->get_default_datareader_qos (dr_qos);
// set up user data in DR qos
CORBA::ULong dr_user_data_len = static_cast<CORBA::ULong>(ACE_OS::strlen (DR_USER_DATA));
dr_qos.user_data.value.length (dr_user_data_len);
dr_qos.user_data.value.replace (dr_user_data_len,
dr_user_data_len,
reinterpret_cast<CORBA::Octet*>(DR_USER_DATA));
DDS::DataReader_var dr = sub->create_datareader(topic.in (),
dr_qos,
listener.in (),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (dr.in ())) {
cerr << "subscriber: create_datareader failed." << endl;
exit(1);
}
// Wait for Monitor 1 done.
FILE* fp = ACE_OS::fopen (synch_fname, ACE_TEXT("r"));
int i = 0;
while (fp == 0 && i < 15)
{
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT("(%P|%t) waiting monitor1 done ...\n")));
ACE_OS::sleep (1);
++i;
fp = ACE_OS::fopen (synch_fname, ACE_TEXT("r"));
}
if (fp != 0)
ACE_OS::fclose (fp);
// Now change the changeable qos. The second monitor should get the updated qos from BIT.
part_user_data_len = static_cast<CORBA::ULong>(ACE_OS::strlen (UPDATED_PART_USER_DATA));
partQos.user_data.value.length (part_user_data_len);
partQos.user_data.value.replace (part_user_data_len,
part_user_data_len,
reinterpret_cast<CORBA::Octet*>(UPDATED_PART_USER_DATA));
participant->set_qos (partQos);
dr_user_data_len = static_cast<CORBA::ULong>(ACE_OS::strlen (UPDATED_DR_USER_DATA));
dr_qos.user_data.value.length (dr_user_data_len);
dr_qos.user_data.value.replace (dr_user_data_len,
dr_user_data_len,
reinterpret_cast<CORBA::Octet*>(UPDATED_DR_USER_DATA));
dr->set_qos (dr_qos);
group_data_len = static_cast<CORBA::ULong> (ACE_OS::strlen (UPDATED_GROUP_DATA));
sub_qos.group_data.value.length (group_data_len);
sub_qos.group_data.value.replace (group_data_len,
group_data_len,
reinterpret_cast<CORBA::Octet*>(UPDATED_GROUP_DATA));
sub->set_qos (sub_qos);
topic_data_len = static_cast<CORBA::ULong>(ACE_OS::strlen (UPDATED_TOPIC_DATA));
topic_qos.topic_data.value.length (topic_data_len);
topic_qos.topic_data.value.replace (topic_data_len,
topic_data_len,
reinterpret_cast<CORBA::Octet*>(UPDATED_TOPIC_DATA));
topic->set_qos (topic_qos);
while ( listener_servant->num_reads() < num_messages) {
ACE_OS::sleep (1);
}
if (listener_servant->builtin_read_errors()) {
cerr << "subscriber: Built in topic read failure." << endl;
result = 1;
}
if (!CORBA::is_nil (participant.in ())) {
participant->delete_contained_entities();
}
if (!CORBA::is_nil (dpf.in ())) {
dpf->delete_participant(participant.in ());
}
TheServiceParticipant->shutdown ();
}
catch (CORBA::Exception& e)
{
cerr << "subscriber: SUB: Exception caught in main ():" << endl << e << endl;
return 1;
}
return result;
}
int
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(OpenDDS::DCPS::MONITOR_DOMAIN_ID,
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 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);
}
// Initialize Transport
OpenDDS::DCPS::TransportImpl_rch transport_impl =
TheTransportFactory->create_transport_impl(transport_impl_id,
OpenDDS::DCPS::AUTO_CONFIG);
OpenDDS::DCPS::AttachStatus status = transport_impl->attach(sub.in());
if (status != OpenDDS::DCPS::ATTACH_OK) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l main()")
ACE_TEXT(" ERROR: attach() failed!\n")), -1);
}
DDS::DataReaderQos dr_qos;
sub->get_default_datareader_qos(dr_qos);
dr_qos.durability.kind = DDS::TRANSIENT_LOCAL_DURABILITY_QOS;
DDS::DataReader_var reader;
// Register for OpenDDS::DCPS::ServiceParticipantReport
OpenDDS::DCPS::ServiceParticipantReportTypeSupport_var sp_ts =
new OpenDDS::DCPS::ServiceParticipantReportTypeSupportImpl();
if (sp_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);
}
CORBA::String_var sp_type_name = sp_ts->get_type_name();
DDS::DataReaderListener_var sp_drl(new SPMDataReaderListenerImpl);
reader = create_data_reader(participant.in(),
sub.in(),
sp_type_name.in(),
OpenDDS::DCPS::SERVICE_PARTICIPANT_MONITOR_TOPIC,
dr_qos,
sp_drl);
if (CORBA::is_nil(reader.in())) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l main()")
ACE_TEXT(" ERROR: create_datareader() failed!\n")), -1);
}
// Register for OpenDDS::DCPS::DomainParticipantReport
OpenDDS::DCPS::DomainParticipantReportTypeSupport_var dp_ts =
new OpenDDS::DCPS::DomainParticipantReportTypeSupportImpl();
if (dp_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);
}
CORBA::String_var dp_type_name = dp_ts->get_type_name();
DDS::DataReaderListener_var dp_drl(new DPMDataReaderListenerImpl);
reader = create_data_reader(participant.in(),
sub.in(),
dp_type_name.in(),
OpenDDS::DCPS::DOMAIN_PARTICIPANT_MONITOR_TOPIC,
dr_qos,
dp_drl);
if (CORBA::is_nil(reader.in())) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l main()")
ACE_TEXT(" ERROR: create_datareader() failed!\n")), -1);
}
// Register for OpenDDS::DCPS::TopicReport
OpenDDS::DCPS::TopicReportTypeSupport_var topic_ts =
new OpenDDS::DCPS::TopicReportTypeSupportImpl();
if (topic_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);
}
CORBA::String_var topic_type_name = topic_ts->get_type_name();
DDS::DataReaderListener_var topic_drl(new TopicMDataReaderListenerImpl);
reader = create_data_reader(participant.in(),
sub.in(),
topic_type_name.in(),
OpenDDS::DCPS::TOPIC_MONITOR_TOPIC,
dr_qos,
topic_drl);
if (CORBA::is_nil(reader.in())) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l main()")
ACE_TEXT(" ERROR: create_datareader() failed!\n")), -1);
}
// Register for OpenDDS::DCPS::PublisherReport
OpenDDS::DCPS::PublisherReportTypeSupport_var publisher_ts =
new OpenDDS::DCPS::PublisherReportTypeSupportImpl();
if (publisher_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);
}
CORBA::String_var publisher_type_name = publisher_ts->get_type_name();
DDS::DataReaderListener_var publisher_drl(new PublisherMDataReaderListenerImpl);
reader = create_data_reader(participant.in(),
sub.in(),
publisher_type_name.in(),
OpenDDS::DCPS::PUBLISHER_MONITOR_TOPIC,
dr_qos,
publisher_drl);
if (CORBA::is_nil(reader.in())) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l main()")
ACE_TEXT(" ERROR: create_datareader() failed!\n")), -1);
}
// Register for OpenDDS::DCPS::SubscriberReport
OpenDDS::DCPS::SubscriberReportTypeSupport_var subscriber_ts =
new OpenDDS::DCPS::SubscriberReportTypeSupportImpl();
if (subscriber_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);
}
CORBA::String_var subscriber_type_name = subscriber_ts->get_type_name();
DDS::DataReaderListener_var subscriber_drl(new SubscriberMDataReaderListenerImpl);
reader = create_data_reader(participant.in(),
sub.in(),
subscriber_type_name.in(),
OpenDDS::DCPS::SUBSCRIBER_MONITOR_TOPIC,
dr_qos,
subscriber_drl);
if (CORBA::is_nil(reader.in())) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l main()")
ACE_TEXT(" ERROR: create_datareader() failed!\n")), -1);
}
// Register for OpenDDS::DCPS::DataWriterReport
OpenDDS::DCPS::DataWriterReportTypeSupport_var dw_ts =
new OpenDDS::DCPS::DataWriterReportTypeSupportImpl();
if (dw_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);
}
CORBA::String_var dw_type_name = dw_ts->get_type_name();
DDS::DataReaderListener_var dw_drl(new DWMDataReaderListenerImpl);
reader = create_data_reader(participant.in(),
sub.in(),
dw_type_name.in(),
OpenDDS::DCPS::DATA_WRITER_MONITOR_TOPIC,
dr_qos,
dw_drl);
if (CORBA::is_nil(reader.in())) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l main()")
ACE_TEXT(" ERROR: create_datareader() failed!\n")), -1);
}
// Register for OpenDDS::DCPS::DataWriterPeriodicReport
OpenDDS::DCPS::DataWriterPeriodicReportTypeSupport_var dwper_ts =
new OpenDDS::DCPS::DataWriterPeriodicReportTypeSupportImpl();
if (dwper_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);
}
CORBA::String_var dwper_type_name = dwper_ts->get_type_name();
DDS::DataReaderListener_var dwper_drl(new DWPerMDataReaderListenerImpl);
reader = create_data_reader(participant.in(),
sub.in(),
dwper_type_name.in(),
OpenDDS::DCPS::DATA_WRITER_PERIODIC_MONITOR_TOPIC,
dr_qos,
dwper_drl);
if (CORBA::is_nil(reader.in())) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l main()")
ACE_TEXT(" ERROR: create_datareader() failed!\n")), -1);
}
// Register for OpenDDS::DCPS::DataReaderReport
OpenDDS::DCPS::DataReaderReportTypeSupport_var dr_ts =
new OpenDDS::DCPS::DataReaderReportTypeSupportImpl();
if (dr_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);
}
CORBA::String_var dr_type_name = dr_ts->get_type_name();
DDS::DataReaderListener_var dr_drl(new DRMDataReaderListenerImpl);
reader = create_data_reader(participant.in(),
sub.in(),
dr_type_name.in(),
OpenDDS::DCPS::DATA_READER_MONITOR_TOPIC,
dr_qos,
dr_drl);
if (CORBA::is_nil(reader.in())) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l main()")
ACE_TEXT(" ERROR: create_datareader() failed!\n")), -1);
}
// Register for OpenDDS::DCPS::DataReaderPeriodicReport
OpenDDS::DCPS::DataReaderPeriodicReportTypeSupport_var drper_ts =
new OpenDDS::DCPS::DataReaderPeriodicReportTypeSupportImpl();
if (drper_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);
}
CORBA::String_var drper_type_name = drper_ts->get_type_name();
DDS::DataReaderListener_var drper_drl(new DRPerMDataReaderListenerImpl);
reader = create_data_reader(participant.in(),
sub.in(),
drper_type_name.in(),
OpenDDS::DCPS::DATA_READER_PERIODIC_MONITOR_TOPIC,
dr_qos,
drper_drl);
if (CORBA::is_nil(reader.in())) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l main()")
ACE_TEXT(" ERROR: create_datareader() failed!\n")), -1);
}
// Register for OpenDDS::DCPS::TransportReport
OpenDDS::DCPS::TransportReportTypeSupport_var transport_ts =
new OpenDDS::DCPS::TransportReportTypeSupportImpl();
if (transport_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);
}
CORBA::String_var transport_type_name = transport_ts->get_type_name();
DDS::DataReaderListener_var transport_drl(new TransportMDataReaderListenerImpl);
reader = create_data_reader(participant.in(),
sub.in(),
transport_type_name.in(),
OpenDDS::DCPS::TRANSPORT_MONITOR_TOPIC,
dr_qos,
transport_drl);
if (CORBA::is_nil(reader.in())) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l main()")
ACE_TEXT(" ERROR: create_datareader() failed!\n")), -1);
}
while (1) {
ACE_OS::sleep(1);
}
// Clean-up!
participant->delete_contained_entities();
dpf->delete_participant(participant.in());
TheTransportFactory->release();
TheServiceParticipant->shutdown();
} catch (const CORBA::Exception& e) {
e._tao_print_exception("Exception caught in main():");
return -1;
}
return 0;
}
int ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
int status = 0;
try {
// Initialize DomainParticipantFactory
DDS::DomainParticipantFactory_var dpf =
TheParticipantFactoryWithArgs(argc, argv);
bool reliable = true;
int num_msgs = 10;
int my_pid = ACE_OS::getpid();
parse_args(argc, argv, reliable, num_msgs, my_pid);
// Create DomainParticipant
DDS::DomainParticipant_var participant =
dpf->create_participant(411,
PARTICIPANT_QOS_DEFAULT,
DDS::DomainParticipantListener::_nil(),
OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil(participant.in())) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l: main()")
ACE_TEXT(" ERROR: create_participant failed!\n")),
-1);
}
// Register TypeSupport (Messenger::Message)
Messenger::MessageTypeSupport_var mts =
new Messenger::MessageTypeSupportImpl();
if (mts->register_type(participant.in(), "") != DDS::RETCODE_OK) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l: main()")
ACE_TEXT(" ERROR: register_type failed!\n")),
-1);
}
// Create Topic
CORBA::String_var type_name = mts->get_type_name();
DDS::Topic_var topic =
participant->create_topic("Movie Discussion List",
type_name.in(),
TOPIC_QOS_DEFAULT,
DDS::TopicListener::_nil(),
OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil(topic.in())) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l: main()")
ACE_TEXT(" ERROR: create_topic failed!\n")),
-1);
}
// Create Publisher
DDS::Publisher_var pub =
participant->create_publisher(PUBLISHER_QOS_DEFAULT,
DDS::PublisherListener::_nil(),
OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil(pub.in())) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l: main()")
ACE_TEXT(" ERROR: create_publisher failed!\n")),
-1);
}
DDS::DataWriterQos qos;
pub->get_default_datawriter_qos(qos);
qos.liveliness.kind = DDS::AUTOMATIC_LIVELINESS_QOS;
qos.liveliness.lease_duration.sec = 5;
qos.liveliness.lease_duration.nanosec = 0;
qos.history.kind = DDS::KEEP_ALL_HISTORY_QOS;
qos.durability.kind = DDS::TRANSIENT_LOCAL_DURABILITY_QOS;
// Create DataWriter
DDS::DataWriter_var dw =
pub->create_datawriter(topic.in(),
qos,
DDS::DataWriterListener::_nil(),
OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil(dw.in())) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l: main()")
ACE_TEXT(" ERROR: create_datawriter failed!\n")),
-1);
}
DDS::DataWriter_var dw2 =
pub->create_datawriter(topic.in(),
qos,
DDS::DataWriterListener::_nil(),
OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil(dw2.in())) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l: main()")
ACE_TEXT(" ERROR: create_datawriter 2 failed!\n")),
-1);
}
{
Writer writer(dw, dw2, my_pid);
writer.write(reliable, num_msgs);
}
// Sleep to give subscriber a chance to nak before exiting
ACE_OS::sleep(3);
ACE_DEBUG((LM_DEBUG, "Publisher delete contained entities\n"));
// Clean-up!
participant->delete_contained_entities();
ACE_DEBUG((LM_DEBUG, "Publisher delete participant\n"));
dpf->delete_participant(participant.in());
ACE_DEBUG((LM_DEBUG, "Publisher shutdown\n"));
TheServiceParticipant->shutdown();
ACE_DEBUG((LM_DEBUG, "Publisher vars going out of scope\n"));
} catch (const CORBA::Exception& e) {
e._tao_print_exception("Exception caught in main():");
status = -1;
}
ACE_DEBUG((LM_DEBUG, "Publisher exiting with status=%d\n", status));
return status;
}
void init_dcps_objects (int i)
{
participant[i] =
dpf->create_participant(domain_id,
PARTICIPANT_QOS_DEFAULT,
::DDS::DomainParticipantListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (participant[i].in ()))
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT("(%P|%t) create_participant failed.\n")));
throw TestException ();
}
::Xyz::FooTypeSupportImpl* fts_servant
= new ::Xyz::FooTypeSupportImpl();
::Xyz::FooTypeSupportImpl* another_fts_servant
= new ::Xyz::FooTypeSupportImpl();
if (::DDS::RETCODE_OK != fts_servant->register_type(participant[i].in (), type_name))
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("Failed to register the FooNoTypeTypeSupport.")));
throw TestException ();
}
// Test if different TypeSupport instances of the same TypeSupport type can register
// with the same type name within the same domain participant.
if (::DDS::RETCODE_OK != another_fts_servant->register_type(participant[i].in (), type_name))
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("Failed to register the FooNoTypeTypeSupport.")));
throw TestException ();
}
::DDS::TopicQos topic_qos;
participant[i]->get_default_topic_qos(topic_qos);
topic[i]
= participant[i]->create_topic(topic_name[i],
type_name,
topic_qos,
::DDS::TopicListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (topic[i].in ()))
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("Failed to create_topic.")));
throw TestException ();
}
subscriber[i] = participant[i]->create_subscriber(SUBSCRIBER_QOS_DEFAULT,
::DDS::SubscriberListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (subscriber[i].in ()))
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("Failed to create_subscriber.")));
throw TestException ();
}
// Create the Datareaders
::DDS::DataReaderQos dr_qos;
subscriber[i]->get_default_datareader_qos (dr_qos);
::DDS::TopicDescription_var description
= participant[i]->lookup_topicdescription(topic_name[i]);
// create the datareader.
datareader[i] = subscriber[i]->create_datareader(description.in (),
dr_qos,
listener[i].in (),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (datareader[i].in ()))
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT("(%P|%t) create_datareader failed.\n")));
throw TestException ();
}
}
int ACE_TMAIN (int argc, ACE_TCHAR *argv[]){
try
{
DDS::DomainParticipantFactory_var dpf =
TheParticipantFactoryWithArgs(argc, argv);
DDS::DomainParticipant_var participant =
dpf->create_participant(311,
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* servant = new MessageTypeSupportImpl();
if (DDS::RETCODE_OK != servant->register_type(participant.in (), "")) {
cerr << "register_type failed." << endl;
exit(1);
}
CORBA::String_var type_name = servant->get_type_name ();
DDS::TopicQos topic_qos;
participant->get_default_topic_qos(topic_qos);
DDS::Topic_var topic =
participant->create_topic ("Movie Discussion List",
type_name.in (),
topic_qos,
DDS::TopicListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (topic.in ())) {
cerr << "create_topic failed." << endl;
exit(1);
}
DDS::PublisherQos pub_qos;
participant->get_default_publisher_qos (pub_qos);
pub_qos.partition.name.length (1);
pub_qos.partition.name[0] = PARTITION_A;
DDS::Publisher_var pub =
participant->create_publisher(pub_qos, DDS::PublisherListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (pub.in ())) {
cerr << "create_publisher failed." << endl;
exit(1);
}
// ----------------------------------------------
// Create DataWriter which is belongs to PARTITION_A
DDS::DataWriter_var dw =
pub->create_datawriter (topic.in (),
DATAWRITER_QOS_DEFAULT,
DDS::DataWriterListener::_nil (),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
int const max_attempts = 15;
int attempts = 1;
// ----------------------------------------------
// Wait for first DataReader that belongs to PARTITION_A too,
// then write samples.
// cache handle for first reader.
::DDS::InstanceHandle_t handle = -1;
{
std::auto_ptr<Writer> writer (new Writer (dw.in ()));
cout << "Pub waiting for match on A partition." << std::endl;
if (OpenDDS::Model::WriterSync::wait_match(dw)) {
cerr << "Error waiting for match on A partition" << std::endl;
return 1;
}
while (attempts != max_attempts)
{
::DDS::InstanceHandleSeq handles;
dw->get_matched_subscriptions(handles);
cout << "Pub matched " << handles.length() << " A subs." << std::endl;
if (handles.length() == 1)
{
handle = handles[0];
break;
}
else
ACE_OS::sleep(1);
++attempts;
}
if (attempts == max_attempts)
{
cerr << "ERROR: failed to wait for first DataReader." << endl;
exit (1);
}
writer->start ();
writer->end ();
}
// ----------------------------------------------
// Switch from PARTITION A to B, now the first DataReader belong to
// PARTITION A should be disconnected and the second DataReader belong to
// PARTITION B should be connected.
pub_qos.partition.name[0] = PARTITION_B;
if (pub->set_qos (pub_qos)!= ::DDS::RETCODE_OK)
{
cerr << "ERROR: DataWriter changed partition which should be compatible "
<< "but should disconnect with DataReaders" << endl;
exit (1);
}
// ----------------------------------------------
// Now DataWriter is in PARTITION B, the second DataReader in PARTITION B
// should receive the messages.
{
std::auto_ptr<Writer> writer (new Writer (dw.in ()));
cout << "Pub waiting for match on B partition." << std::endl;
if (OpenDDS::Model::WriterSync::wait_match(dw)) {
cerr << "Error waiting for match on B partition" << std::endl;
return 1;
}
attempts = 1;
while (attempts != max_attempts)
{
::DDS::InstanceHandleSeq handles;
dw->get_matched_subscriptions(handles);
cout << "Pub matched " << handles.length() << " B subs." << std::endl;
if (handles.length() == 1 && handles[0] != handle)
break;
else
ACE_OS::sleep(1);
++attempts;
}
if (attempts == max_attempts)
{
cerr << "ERROR: subscriptions failed to match." << endl;
exit (1);
}
writer->start ();
writer->end ();
}
// ----------------------------------------------
// Wait for first reader to switch from PARTITION A to B so
// both two readers will receive the messages.
{
std::auto_ptr<Writer> writer (new Writer (dw.in ()));
attempts = 1;
while (attempts != max_attempts)
{
::DDS::InstanceHandleSeq handles;
dw->get_matched_subscriptions(handles);
if (handles.length() == 2)
break;
else
ACE_OS::sleep(1);
++ attempts;
}
if (attempts == max_attempts)
{
cerr << "ERROR: failed to wait for DataReader partition switch." << endl;
exit (1);
}
writer->start ();
writer->end ();
}
// ----------------------------------------------
// Now wait for subscriber exit.
{
attempts = 1;
while (attempts != max_attempts)
{
::DDS::InstanceHandleSeq handles;
dw->get_matched_subscriptions(handles);
if (handles.length() == 0)
break;
else
ACE_OS::sleep(1);
++ attempts;
}
}
participant->delete_contained_entities();
dpf->delete_participant(participant.in ());
}
catch (CORBA::Exception& e)
{
cerr << "PUB: Exception caught in main.cpp:" << endl
<< e << endl;
exit(1);
}
TheServiceParticipant->shutdown ();
return 0;
}
Subscriber::Subscriber( const Options& options)
: options_( options),
listener_( 0),
waiter_( new DDS::WaitSet)
{
DDS::DomainParticipantFactory_var dpf = TheParticipantFactory;
// Create the DomainParticipant
this->participant_
= dpf->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 the listener.
this->listener_ = new DataReaderListener( this->options_.verbose());
this->safe_listener_ = this->listener_;
ACE_DEBUG((LM_DEBUG,
ACE_TEXT("(%P|%t) Subscriber::Subscriber() - ")
ACE_TEXT("created reader listener.\n")
));
// Create and register the type support.
DataTypeSupportImpl::_var_type testData = new DataTypeSupportImpl();
CORBA::String_var type_name = testData->get_type_name();
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"),
type_name.in()
));
throw BadTypeSupportException ();
}
ACE_DEBUG((LM_DEBUG,
ACE_TEXT("(%P|%t) Subscriber::Subscriber() - ")
ACE_TEXT("created type %C support.\n"),
type_name.in()
));
// Create the topic.
this->topic_ = this->participant_->create_topic(
this->options_.topicName().c_str(),
type_name,
TOPIC_QOS_DEFAULT,
::DDS::TopicListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK
);
if( CORBA::is_nil( this->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();
}
ACE_DEBUG((LM_DEBUG,
ACE_TEXT("(%P|%t) Subscriber::Subscriber() - ")
ACE_TEXT("created topic %C.\n"),
this->options_.topicName().c_str()
));
// Create the subscriber.
this->subscriber_ = this->participant_->create_subscriber(
SUBSCRIBER_QOS_DEFAULT,
::DDS::SubscriberListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK
);
if( CORBA::is_nil( this->subscriber_.in())) {
ACE_ERROR((LM_ERROR,
ACE_TEXT("(%P|%t) ERROR: Subscriber::Subscriber() - ")
ACE_TEXT("failed to create subscriber.\n")
));
throw BadSubscriberException();
}
ACE_DEBUG((LM_DEBUG,
ACE_TEXT("(%P|%t) Subscriber::Subscriber() - ")
ACE_TEXT("created subscriber.\n")
));
// Reader Qos policy values.
::DDS::DataReaderQos readerQos;
this->subscriber_->get_default_datareader_qos( readerQos);
// readerQos.durability.kind = ::DDS::TRANSIENT_LOCAL_DURABILITY_QOS;
readerQos.history.kind = ::DDS::KEEP_ALL_HISTORY_QOS;
readerQos.history.depth = 1;
readerQos.destination_order.kind = ::DDS::BY_SOURCE_TIMESTAMP_DESTINATIONORDER_QOS;
// readerQos.resource_limits.max_samples_per_instance = ::DDS::LENGTH_UNLIMITED;
// Reliability varies with the transport implementation.
switch( this->options_.transportType()) {
case Options::TCP:
case Options::MC:
readerQos.reliability.kind = ::DDS::RELIABLE_RELIABILITY_QOS;
break;
case Options::UDP:
readerQos.reliability.kind = ::DDS::BEST_EFFORT_RELIABILITY_QOS;
break;
case Options::TRANSPORT_NONE:
default:
ACE_ERROR((LM_ERROR,
ACE_TEXT("(%P|%t) ERROR: Subscriber::Subscriber() - ")
ACE_TEXT("unrecognized transport when setting up Qos policies.\n")
));
throw BadQosException();
}
// Create the reader.
this->reader_ = this->subscriber_->create_datareader(
this->topic_.in(),
readerQos,
DDS::DataReaderListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK
);
if( CORBA::is_nil( this->reader_.in())) {
ACE_ERROR((LM_ERROR,
ACE_TEXT("(%P|%t) ERROR: Subscriber::Subscriber() - ")
ACE_TEXT("failed to create reader.\n")
));
throw BadReaderException();
}
ACE_DEBUG((LM_DEBUG,
ACE_TEXT("(%P|%t) Subscriber::Subscriber() - ")
ACE_TEXT("created reader.\n")
));
// Set the listener mask here so that we don't conflict with the
// StatusCondition(s) that we want to wait on in the main thread.
this->reader_->set_listener( this->listener_, DDS::DATA_AVAILABLE_STATUS);
// Grab, enable and attach the status condition for test synchronization.
this->status_ = this->reader_->get_statuscondition();
this->status_->set_enabled_statuses( DDS::SUBSCRIPTION_MATCHED_STATUS);
if (this->waiter_->attach_condition( this->status_.in()) != DDS::RETCODE_OK) {
ACE_ERROR((LM_ERROR,
ACE_TEXT("(%P|%t) ERROR: Subscriber::Subscriber() - ")
ACE_TEXT("failed to match subscription.\n")
));
throw BadAttachException();
}
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[])
{
try
{
DDS::DomainParticipantFactory_var dpf;
DDS::DomainParticipant_var participant;
dpf = TheParticipantFactoryWithArgs(argc, argv);
participant =
dpf->create_participant(411,
PARTICIPANT_QOS_DEFAULT,
DDS::DomainParticipantListener::_nil());
if (CORBA::is_nil (participant.in ())) {
cerr << "create_participant failed." << endl;
return 1 ;
}
Messenger::MessageTypeSupportImpl* mts_servant =
new Messenger::MessageTypeSupportImpl;
if (DDS::RETCODE_OK != mts_servant->register_type(participant.in (),
""))
{
cerr << "Failed to register the MessageTypeTypeSupport." << endl;
exit(1);
}
CORBA::String_var type_name = mts_servant->get_type_name ();
DDS::TopicQos topic_qos;
participant->get_default_topic_qos(topic_qos);
DDS::Topic_var topic =
participant->create_topic("Movie Discussion List",
type_name.in (),
topic_qos,
DDS::TopicListener::_nil());
if (CORBA::is_nil (topic.in ())) {
cerr << "Failed to create_topic." << endl;
exit(1);
}
// Initialize the transport
OpenDDS::DCPS::TransportImpl_rch tcp_impl =
TheTransportFactory->create_transport_impl (
transport_impl_id,
::OpenDDS::DCPS::AUTO_CONFIG);
// Create the subscriber and attach to the corresponding
// transport.
DDS::Subscriber_var sub =
participant->create_subscriber (SUBSCRIBER_QOS_DEFAULT,
DDS::SubscriberListener::_nil());
if (CORBA::is_nil (sub.in ())) {
cerr << "Failed to create_subscriber." << endl;
exit(1);
}
// Attach the subscriber to the transport.
OpenDDS::DCPS::SubscriberImpl* sub_impl =
dynamic_cast<OpenDDS::DCPS::SubscriberImpl*> (sub.in ());
if (0 == sub_impl) {
cerr << "Failed to obtain subscriber servant\n" << endl;
exit(1);
}
OpenDDS::DCPS::AttachStatus const status =
sub_impl->attach_transport(tcp_impl.in());
if (status != OpenDDS::DCPS::ATTACH_OK) {
std::string status_str;
switch (status) {
case OpenDDS::DCPS::ATTACH_BAD_TRANSPORT:
status_str = "ATTACH_BAD_TRANSPORT";
break;
case OpenDDS::DCPS::ATTACH_ERROR:
status_str = "ATTACH_ERROR";
break;
case OpenDDS::DCPS::ATTACH_INCOMPATIBLE_QOS:
status_str = "ATTACH_INCOMPATIBLE_QOS";
break;
default:
status_str = "Unknown Status";
break;
}
cerr << "Failed to attach to the transport. Status == "
<< status_str.c_str() << endl;
exit(1);
}
// ----------------------------------------------
{
// Attempt to create a DataReader with intentionally
// incompatible QoS.
DDS::DataReaderQos bogus_qos;
sub->get_default_datareader_qos (bogus_qos);
// Set up a 1 second recurring deadline. DataReader creation
// should fail with this QoS since the requested deadline period
// will be less than the test configured offered deadline
// period.
bogus_qos.deadline.period.sec = 2;
bogus_qos.deadline.period.nanosec = 0;
DDS::DataReader_var tmp_dr =
sub->create_datareader (topic.in (),
bogus_qos,
DDS::DataReaderListener::_nil ());
if (CORBA::is_nil (tmp_dr.in ()))
{
cerr << "ERROR: DataReader creation with bogus QoS failed."
<< endl;
exit (1);
}
ACE_OS::sleep (2);
// Check if the incompatible deadline was correctly flagged.
DDS::RequestedIncompatibleQosStatus_var incompatible_status =
tmp_dr->get_requested_incompatible_qos_status ();
DDS::QosPolicyCountSeq const & policies =
incompatible_status->policies;
bool incompatible_deadline = false;
CORBA::ULong const len = policies.length ();
for (CORBA::ULong i = 0; i < len; ++i)
{
if (policies[i].policy_id == DDS::DEADLINE_QOS_POLICY_ID)
{
incompatible_deadline = true;
break;
}
}
if (!incompatible_deadline)
{
cerr << "ERROR: A DataReader/Writer association was created " << endl
<< " despite use of deliberately incompatible deadline "
<< "QoS." << endl;
exit (1);
}
}
// ----------------------------------------------
// Create the listener.
DDS::DataReaderListener_var listener (new DataReaderListenerImpl);
if (CORBA::is_nil (listener.in ()))
{
cerr << "ERROR: listener is nil." << endl;
exit(1);
}
DDS::DataReaderQos dr_qos; // Good QoS.
sub->get_default_datareader_qos (dr_qos);
// Set up a 5 second recurring deadline.
static DDS::Duration_t const DEADLINE_PERIOD =
{
5, // seconds
0 // nanoseconds
};
assert (DEADLINE_PERIOD.sec > 1); // Requirement for the test.
// Time to sleep waiting for deadline periods to expire
long const NUM_EXPIRATIONS = 2;
ACE_Time_Value const SLEEP_DURATION (
OpenDDS::DCPS::duration_to_time_value (DEADLINE_PERIOD)
* 2
+ ACE_Time_Value (1));
dr_qos.deadline.period.sec = DEADLINE_PERIOD.sec;
dr_qos.deadline.period.nanosec = DEADLINE_PERIOD.nanosec;
// First data reader will have a listener to test listener
// callback on deadline expiration.
DDS::DataReader_var dr1 =
sub->create_datareader (topic.in (),
dr_qos,
listener.in ());
// Second data reader will not have a listener to test proper
// handling of a nil listener in the deadline handling code.
DDS::DataReader_var dr2 =
sub->create_datareader (topic.in (),
dr_qos,
DDS::DataReaderListener::_nil ());
if (CORBA::is_nil (dr1.in ()) || CORBA::is_nil (dr2.in ()))
{
cerr << "ERROR: create_datareader failed." << endl;
exit(1);
}
// ----------------------------------------------
// Wait for deadline periods to expire.
ACE_OS::sleep (SLEEP_DURATION);
DDS::RequestedDeadlineMissedStatus deadline_status1 =
dr1->get_requested_deadline_missed_status();
DDS::RequestedDeadlineMissedStatus deadline_status2 =
dr2->get_requested_deadline_missed_status();
if (deadline_status1.total_count != NUM_EXPIRATIONS
|| deadline_status2.total_count != NUM_EXPIRATIONS)
{
cerr << "ERROR: Expected number of missed requested "
<< "deadlines (" << NUM_EXPIRATIONS << ") " << "did " << endl
<< " not occur ("
<< deadline_status1.total_count << " and/or "
<< deadline_status2.total_count << ")." << endl;
exit (1);
}
if (deadline_status1.total_count_change != NUM_EXPIRATIONS
|| deadline_status2.total_count_change != NUM_EXPIRATIONS)
{
cerr << "ERROR: Incorrect missed requested "
<< "deadline count change" << endl
<< " ("
<< deadline_status1.total_count_change
<< " and/or "
<< deadline_status2.total_count_change
<< " instead of " << NUM_EXPIRATIONS << ")."
<< endl;
exit (1);
}
// Wait for another set of deadline periods to expire.
ACE_OS::sleep (SLEEP_DURATION);
deadline_status1 = dr1->get_requested_deadline_missed_status();
deadline_status2 = dr2->get_requested_deadline_missed_status();
if (deadline_status1.total_count != NUM_EXPIRATIONS * 2
|| deadline_status2.total_count != NUM_EXPIRATIONS * 2)
{
cerr << "ERROR: Another expected number of missed requested "
<< "deadlines (" << NUM_EXPIRATIONS * 2 << ")" << endl
<< " did not occur ("
<< deadline_status1.total_count << " and/or "
<< deadline_status2.total_count << ")." << endl;
exit (1);
}
if (deadline_status1.total_count_change != NUM_EXPIRATIONS
|| deadline_status2.total_count_change != NUM_EXPIRATIONS)
{
cerr << "ERROR: Incorrect missed requested "
<< "deadline count" << endl
<< " change ("
<< deadline_status1.total_count_change
<< "and/or "
<< deadline_status2.total_count_change
<< " instead of " << NUM_EXPIRATIONS << ")." << endl;
exit (1);
}
// Create 3rd data reader to trigger the data writers to write.
DDS::DataReader_var dr3 =
sub->create_datareader (topic.in (),
dr_qos,
DDS::DataReaderListener::_nil ());
DataReaderListenerImpl* listener_servant =
dynamic_cast<DataReaderListenerImpl*>(listener.in());
int expected = 10;
while ( listener_servant->num_reads() < expected) {
ACE_OS::sleep (1);
}
// @todo We still need a check proper updating of the
// @c DDS::RequestedDeadlineMissedStatus::last_instance_handle
// field.
if (!CORBA::is_nil (participant.in ())) {
participant->delete_contained_entities();
}
if (!CORBA::is_nil (dpf.in ())) {
dpf->delete_participant(participant.in ());
}
ACE_OS::sleep(2);
TheTransportFactory->release();
TheServiceParticipant->shutdown ();
}
catch (CORBA::Exception& e)
{
cerr << "SUB: Exception caught in main ():" << endl << e << endl;
return 1;
}
return 0;
}
int ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
try
{
DDS::DomainParticipantFactory_var dpf;
DDS::DomainParticipant_var participant;
dpf = TheParticipantFactoryWithArgs(argc, argv);
participant =
dpf->create_participant(411,
PARTICIPANT_QOS_DEFAULT,
DDS::DomainParticipantListener::_nil());
if (CORBA::is_nil (participant.in ())) {
cerr << "create_participant failed." << endl;
return 1 ;
}
Messenger::MessageTypeSupportImpl* mts_servant =
new Messenger::MessageTypeSupportImpl;
if (DDS::RETCODE_OK != mts_servant->register_type(participant.in (),
""))
{
cerr << "Failed to register the MessageTypeTypeSupport." << endl;
exit(1);
}
CORBA::String_var type_name = mts_servant->get_type_name ();
DDS::TopicQos topic_qos;
participant->get_default_topic_qos(topic_qos);
DDS::Topic_var topic =
participant->create_topic("Movie Discussion List",
type_name.in (),
topic_qos,
DDS::TopicListener::_nil());
if (CORBA::is_nil (topic.in ())) {
cerr << "Failed to create_topic." << endl;
exit(1);
}
// Initialize the transport
OpenDDS::DCPS::TransportImpl_rch tcp_impl =
TheTransportFactory->create_transport_impl (
transport_impl_id,
::OpenDDS::DCPS::AUTO_CONFIG);
// Create the first subscriber belongs to PARTITION A
DDS::SubscriberQos sub_qos1;
participant->get_default_subscriber_qos (sub_qos1);
sub_qos1.partition.name.length (1);
sub_qos1.partition.name[0] = PARTITION_A;
DDS::Subscriber_var sub1 =
participant->create_subscriber (sub_qos1,
DDS::SubscriberListener::_nil());
if (CORBA::is_nil (sub1.in ())) {
cerr << "Failed to create_subscriber." << endl;
exit(1);
}
// Create the second subscriber belongs to PARTITION B
DDS::SubscriberQos sub_qos2;
participant->get_default_subscriber_qos (sub_qos2);
sub_qos2.partition.name.length (1);
sub_qos2.partition.name[0] = PARTITION_B;
DDS::Subscriber_var sub2 =
participant->create_subscriber (sub_qos2,
DDS::SubscriberListener::_nil());
if (CORBA::is_nil (sub2.in ())) {
cerr << "Failed to create_subscriber." << endl;
exit(1);
}
// Attach the subscribers to the transport.
OpenDDS::DCPS::SubscriberImpl* sub_impl1 =
dynamic_cast<OpenDDS::DCPS::SubscriberImpl*> (sub1.in ());
if (0 == sub_impl1) {
cerr << "Failed to obtain subscriber1 servant \n" << endl;
exit(1);
}
OpenDDS::DCPS::SubscriberImpl* sub_impl2 =
dynamic_cast<OpenDDS::DCPS::SubscriberImpl*> (sub2.in ());
if (0 == sub_impl2) {
cerr << "Failed to obtain subscriber2 servant \n" << endl;
exit(1);
}
OpenDDS::DCPS::AttachStatus status =
sub_impl1->attach_transport(tcp_impl.in());
if (status != OpenDDS::DCPS::ATTACH_OK) {
std::string status_str;
switch (status) {
case OpenDDS::DCPS::ATTACH_BAD_TRANSPORT:
status_str = "ATTACH_BAD_TRANSPORT";
break;
case OpenDDS::DCPS::ATTACH_ERROR:
status_str = "ATTACH_ERROR";
break;
case OpenDDS::DCPS::ATTACH_INCOMPATIBLE_QOS:
status_str = "ATTACH_INCOMPATIBLE_QOS";
break;
default:
status_str = "Unknown Status";
break;
}
cerr << "Failed to attach to the transport. Status == "
<< status_str.c_str() << endl;
exit(1);
}
status = sub_impl2->attach_transport(tcp_impl.in());
if (status != OpenDDS::DCPS::ATTACH_OK) {
std::string status_str;
switch (status) {
case OpenDDS::DCPS::ATTACH_BAD_TRANSPORT:
status_str = "ATTACH_BAD_TRANSPORT";
break;
case OpenDDS::DCPS::ATTACH_ERROR:
status_str = "ATTACH_ERROR";
break;
case OpenDDS::DCPS::ATTACH_INCOMPATIBLE_QOS:
status_str = "ATTACH_INCOMPATIBLE_QOS";
break;
default:
status_str = "Unknown Status";
break;
}
cerr << "Failed to attach to the transport. Status == "
<< status_str.c_str() << endl;
exit(1);
}
DDS::DataReaderQos dr_qos;
sub1->get_default_datareader_qos (dr_qos);
// Create first DataReader with listener.
DDS::DataReaderListener_var listener1 (new DataReaderListenerImpl);
if (CORBA::is_nil (listener1.in ()))
{
cerr << "ERROR: listener1 is nil." << endl;
exit(1);
}
DDS::DataReader_var dr1 =
sub1->create_datareader (topic.in (),
dr_qos,
listener1.in ());
// Create second DataReader with listener.
DDS::DataReaderListener_var listener2 (new DataReaderListenerImpl);
if (CORBA::is_nil (listener2.in ()))
{
cerr << "ERROR: listener2 is nil." << endl;
exit(1);
}
DDS::DataReader_var dr2 =
sub2->create_datareader (topic.in (),
dr_qos,
listener2.in ());
if (CORBA::is_nil (dr1.in ()) || CORBA::is_nil (dr2.in ()))
{
cerr << "ERROR: create_datareader failed." << endl;
exit(1);
}
DataReaderListenerImpl* listener_servant1 =
dynamic_cast<DataReaderListenerImpl*>(listener1.in());
DataReaderListenerImpl* listener_servant2 =
dynamic_cast<DataReaderListenerImpl*>(listener2.in());
int expected = 10;
// Writer of PARTITION A -> Reader of PARTITION A
while ( listener_servant1->num_reads() < expected) {
ACE_OS::sleep (1);
}
// Writer switch from PARTITION A to B -> Reader of PARTITION B
while ( listener_servant2->num_reads() < expected) {
ACE_OS::sleep (1);
}
// ----------------------------------------------
// Now switch first reader/subscriber from A to B
// and it should be connected with DataWriter.
sub_qos1.partition.name[0] = PARTITION_B;
if (sub1->set_qos (sub_qos1) != ::DDS::RETCODE_OK)
{
cerr << "ERROR: failed to set partition" << endl;
exit (1);
}
// Continue receive 10 more messages each.
expected = 20;
while ( listener_servant1->num_reads() < expected) {
ACE_OS::sleep (1);
}
while ( listener_servant2->num_reads() < expected) {
ACE_OS::sleep (1);
}
if (listener_servant1->num_reads() > expected
|| listener_servant2->num_reads() > expected)
{
cerr << "ERROR: received more than excepted messages" << endl;
exit (1);
}
// Now shutdown
if (!CORBA::is_nil (participant.in ())) {
participant->delete_contained_entities();
}
if (!CORBA::is_nil (dpf.in ())) {
dpf->delete_participant(participant.in ());
}
TheTransportFactory->release();
TheServiceParticipant->shutdown ();
}
catch (CORBA::Exception& e)
{
cerr << "SUB: Exception caught in main ():" << endl << e << endl;
return 1;
}
return 0;
}
int ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
try {
// Initialize DomainParticipantFactory
DDS::DomainParticipantFactory_var dpf =
TheParticipantFactoryWithArgs(argc, argv);
if (parse_args (argc, argv) != 0) {
return 1;
}
TheServiceParticipant->monitor_factory_->initialize();
// Create DomainParticipant
DDS::DomainParticipant_var participant =
dpf->create_participant(411,
PARTICIPANT_QOS_DEFAULT,
DDS::DomainParticipantListener::_nil(),
OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil(participant.in())) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l: main()")
ACE_TEXT(" ERROR: create_participant failed!\n")),
-1);
}
// Register TypeSupport (Messenger::Message)
Messenger::MessageTypeSupport_var mts =
new Messenger::MessageTypeSupportImpl();
if (mts->register_type(participant.in(), "") != DDS::RETCODE_OK) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l: main()")
ACE_TEXT(" ERROR: register_type failed!\n")),
-1);
}
// Create Topic
DDS::Topic_var topic =
participant->create_topic("Movie Discussion List",
mts->get_type_name(),
TOPIC_QOS_DEFAULT,
DDS::TopicListener::_nil(),
OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil(topic.in())) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l: main()")
ACE_TEXT(" ERROR: create_topic failed!\n")),
-1);
}
// Create Publisher
DDS::Publisher_var pub =
participant->create_publisher(PUBLISHER_QOS_DEFAULT,
DDS::PublisherListener::_nil(),
OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil(pub.in())) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l: main()")
ACE_TEXT(" ERROR: create_publisher failed!\n")),
-1);
}
// Create DataWriter
DDS::DataWriter_var dw =
pub->create_datawriter(topic.in(),
DATAWRITER_QOS_DEFAULT,
DDS::DataWriterListener::_nil(),
OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil(dw.in())) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l: main()")
ACE_TEXT(" ERROR: create_datawriter failed!\n")),
-1);
}
// Start writing threads
Writer* writer = new Writer(dw.in());
writer->start();
while (!writer->is_finished()) {
ACE_Time_Value small_time(0, 250000);
ACE_OS::sleep(small_time);
}
writer->end();
delete writer;
// Clean-up!
participant->delete_contained_entities();
dpf->delete_participant(participant.in());
TheServiceParticipant->shutdown();
} catch (const CORBA::Exception& e) {
e._tao_print_exception("Exception caught in main():");
ACE_OS::exit(-1);
}
return 0;
}
int ACE_TMAIN(int argc, ACE_TCHAR* argv[])
{
try
{
DDS::DomainParticipantFactory_var dpf;
DDS::DomainParticipant_var participant;
dpf = TheParticipantFactoryWithArgs(argc, argv);
participant = dpf->create_participant(411,
PARTICIPANT_QOS_DEFAULT,
DDS::DomainParticipantListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (participant.in ())) {
cerr << "create_participant failed." << endl;
return 1 ;
}
Test::DataTypeSupportImpl * const dts_servant =
new Test::DataTypeSupportImpl;
if (DDS::RETCODE_OK != dts_servant->register_type(participant.in (),
""))
{
cerr << "Failed to register the DataTypeSupport." << endl;
exit(1);
}
CORBA::String_var type_name = dts_servant->get_type_name ();
DDS::TopicQos topic_qos;
participant->get_default_topic_qos(topic_qos);
DDS::Topic_var topic =
participant->create_topic("Data",
type_name.in (),
topic_qos,
DDS::TopicListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (topic.in ())) {
cerr << "Failed to create_topic." << endl;
exit(1);
}
size_t const num_partitions =
sizeof (Test::Requested::PartitionConfigs)
/ sizeof (Test::Requested::PartitionConfigs[0]);
Test::PartitionConfig const * const begin =
Test::Requested::PartitionConfigs;
Test::PartitionConfig const * const end =
begin + num_partitions;
// Keep the readers around long enough for the publications and
// subscriptions to match.
std::vector<DDS::DataReader_var> readers (num_partitions);
for (Test::PartitionConfig const * i = begin; i != end; ++i)
{
DDS::SubscriberQos sub_qos;
participant->get_default_subscriber_qos (sub_qos);
// Specify partitions we're requesting.
CORBA::ULong n = 0;
DDS::StringSeq & names = sub_qos.partition.name;
for (char const * const * s = (*i).partitions;
s != 0 && *s != 0;
++s, ++n)
{
CORBA::ULong const new_len = names.length () + 1;
names.length (new_len);
names[n] = *s;
}
// Create the subscriber and attach to the corresponding
// transport.
DDS::Subscriber_var sub =
participant->create_subscriber (sub_qos,
DDS::SubscriberListener::_nil (),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (sub.in ()))
{
cerr << "Failed to create_subscriber." << endl;
exit(1);
}
DDS::DataReaderListener_var listener (
new Test::DataReaderListener ((*i).expected_matches));
// Create the Datareaders
DDS::DataReaderQos dr_qos;
sub->get_default_datareader_qos (dr_qos);
DDS::DataReader_var dr = sub->create_datareader (topic.in (),
dr_qos,
listener.in (),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (dr.in ())) {
cerr << "create_datareader failed." << endl;
exit(1);
}
readers.push_back (dr);
}
ACE_OS::sleep (15);
// {
// // Force contents of writers vector to be destroyed now.
// std::vector<DDS::DataReader_var> tmp;
// tmp.swap (readers);
// }
if (!CORBA::is_nil (participant.in ())) {
participant->delete_contained_entities();
}
if (!CORBA::is_nil (dpf.in ())) {
dpf->delete_participant(participant.in ());
}
ACE_OS::sleep(2);
TheServiceParticipant->shutdown ();
}
catch (CORBA::Exception& e)
{
cerr << "SUB: Exception caught in main ():" << endl << e << endl;
return 1;
}
return 0;
}
int ACE_TMAIN (int argc, ACE_TCHAR *argv[]){
try
{
DDS::DomainParticipantFactory_var dpf =
TheParticipantFactoryWithArgs(argc, argv);
DDS::DomainParticipant_var participant =
dpf->create_participant(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;
}
MessageTypeSupportImpl* servant = new MessageTypeSupportImpl();
if (DDS::RETCODE_OK != servant->register_type(participant.in (), "")) {
cerr << "register_type failed." << endl;
exit(1);
}
CORBA::String_var type_name = servant->get_type_name ();
DDS::TopicQos topic_qos;
participant->get_default_topic_qos(topic_qos);
DDS::Topic_var topic =
participant->create_topic ("Movie Discussion List",
type_name.in (),
topic_qos,
DDS::TopicListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (topic.in ())) {
cerr << "create_topic failed." << endl;
exit(1);
}
DDS::Publisher_var pub =
participant->create_publisher(PUBLISHER_QOS_DEFAULT,
DDS::PublisherListener::_nil(), ::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (pub.in ())) {
cerr << "create_publisher failed." << endl;
exit(1);
}
// ----------------------------------------------
// Create the listener.
DDS::DataWriterListener_var listener (new DataWriterListenerImpl);
if (CORBA::is_nil (listener.in ()))
{
cerr << "ERROR: listener is nil." << endl;
exit(1);
}
DDS::DataWriterQos dw_qos; // Good QoS.
pub->get_default_datawriter_qos (dw_qos);
assert (DEADLINE_PERIOD.sec > 1); // Requirement for the test.
// First data writer will have a listener to test listener
// callback on deadline expiration.
DDS::DataWriter_var dw =
pub->create_datawriter (topic.in (),
dw_qos,
listener.in (),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (dw.in ()))
{
cerr << "ERROR: create_datawriter failed." << endl;
exit(1);
}
dw_qos.deadline.period.sec = DEADLINE_PERIOD.sec;
dw_qos.deadline.period.nanosec = DEADLINE_PERIOD.nanosec;
// Set qos with deadline. The watch dog starts now.
if (dw->set_qos (dw_qos) != ::DDS::RETCODE_OK)
{
cerr << "ERROR: set deadline qos failed." << endl;
exit(1);
}
{
// Two threads use same datawriter to write different instances.
std::auto_ptr<Writer> writer1 (new Writer (dw.in (), 99, SLEEP_DURATION));
std::auto_ptr<Writer> writer2 (new Writer (dw.in (), 100, SLEEP_DURATION));
writer1->start ();
writer2->start ();
// ----------------------------------------------
// Wait for fully associate with DataReaders.
if (writer1->wait_for_start () == false || writer2->wait_for_start () == false)
{
cerr << "ERROR: took too long to associate. " << endl;
exit (1);
}
ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%P|%t) Publisher: sleep for %d milliseconds\n"),
SLEEP_DURATION.msec ()));
// Wait for a set of deadline periods to expire.
ACE_OS::sleep (SLEEP_DURATION);
ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%P|%t) Publisher: now verify missed ")
ACE_TEXT ("deadline status \n")));
::DDS::InstanceHandle_t handle1 = writer1->get_instance_handle ();
::DDS::InstanceHandle_t handle2 = writer2->get_instance_handle ();
DDS::OfferedDeadlineMissedStatus deadline_status;
if (dw->get_offered_deadline_missed_status(deadline_status) != ::DDS::RETCODE_OK)
{
cerr << "ERROR: Failed to get offered deadline missed status" << endl;
exit (1);
}
ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%P|%t) Publisher: got missed")
ACE_TEXT ("deadline status \n")));
if (deadline_status.total_count != NUM_EXPIRATIONS * NUM_WRITE_THREADS)
{
cerr << "ERROR: Unexpected number of missed offered "
<< "deadlines (" << deadline_status.total_count
<< " instead of " << NUM_EXPIRATIONS * NUM_WRITE_THREADS << ") "
<< endl;
exit (1);
}
if (deadline_status.total_count_change != NUM_EXPIRATIONS * NUM_WRITE_THREADS)
{
cerr << "ERROR: Incorrect missed offered "
<< "deadline count change ("
<< deadline_status.total_count_change
<< ") instead of " << NUM_EXPIRATIONS * NUM_WRITE_THREADS
<< endl;
exit (1);
}
if (deadline_status.last_instance_handle != handle1
&& deadline_status.last_instance_handle != handle2)
{
cerr << "ERROR: Unexpected last instance handle "
<< deadline_status.last_instance_handle << " instead of "
<< handle1 << " or "
<< handle2 << endl;
exit (1);
}
writer1->wait ();
writer2->wait ();
ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%P|%t) Publisher: sleep for %d milliseconds\n"),
SLEEP_DURATION.msec()));
// Wait for another set of deadline periods to expire.
ACE_OS::sleep (SLEEP_DURATION);
ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%P|%t) Publisher: now verify missed ")
ACE_TEXT ("deadline status \n")));
if (dw->get_offered_deadline_missed_status(deadline_status) != ::DDS::RETCODE_OK)
{
cerr << "ERROR: Failed to get offered deadline missed status" << endl;
exit (1);
}
ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%P|%t) Publisher: got missed")
ACE_TEXT ("deadline status \n")));
if (deadline_status.total_count != (NUM_EXPIRATIONS + 2) * NUM_WRITE_THREADS)
{
cerr << "ERROR: Unexpected number of missed offered "
<< "deadlines (" << deadline_status.total_count
<< " instead of " << (NUM_EXPIRATIONS + 2) * NUM_WRITE_THREADS << ") "
<< endl;
exit (1);
}
if (deadline_status.total_count_change != NUM_WRITE_THREADS * 2)
{
cerr << "ERROR: Incorrect missed offered "
<< "deadline count change ("
<< deadline_status.total_count_change
<< ") instead of " << NUM_WRITE_THREADS * 2
<< endl;
exit (1);
}
if (deadline_status.last_instance_handle != handle1
&& deadline_status.last_instance_handle != handle2)
{
cerr << "ERROR: Unexpected last instance handle "
<< deadline_status.last_instance_handle << " instead of "
<< handle1 << " or "
<< handle2 << endl;
exit (1);
}
// Wait for datareader finish.
while (1)
{
::DDS::InstanceHandleSeq handles;
dw->get_matched_subscriptions (handles);
if (handles.length () == 0)
break;
else
ACE_OS::sleep(1);
}
}
participant->delete_contained_entities();
dpf->delete_participant(participant.in ());
TheServiceParticipant->shutdown ();
}
catch (CORBA::Exception& e)
{
cerr << "PUB: Exception caught in main.cpp:" << endl
<< e << endl;
exit(1);
}
return 0;
}
Publisher::Publisher( const Options& options)
: status_( 0),
options_( options),
participant_(0),
publisher_(0),
waiter_( new DDS::WaitSet)
{
DDS::DomainParticipantFactory_var dpf = TheParticipantFactory;
// Create the DomainParticipant
this->participant_
= dpf->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: Publisher::Publisher() - ")
ACE_TEXT("failed to create a participant.\n")
));
throw BadParticipantException();
} else if( this->options_.verbose()) {
ACE_DEBUG((LM_DEBUG,
ACE_TEXT("(%P|%t) Publisher::Publisher() - ")
ACE_TEXT("created participant in domain %d.\n"),
this->options_.domain()
));
}
// Create and register the type support.
DataTypeSupportImpl* testData = new DataTypeSupportImpl();
CORBA::String_var type_name = testData->get_type_name();
if( ::DDS::RETCODE_OK
!= testData->register_type( this->participant_.in(), 0)) {
ACE_ERROR((LM_ERROR,
ACE_TEXT("(%P|%t) ERROR: Publisher::Publisher() - ")
ACE_TEXT("unable to install type %C support.\n"),
type_name.in()
));
throw BadTypeSupportException ();
} else if( this->options_.verbose()) {
ACE_DEBUG((LM_DEBUG,
ACE_TEXT("(%P|%t) Publisher::Publisher() - ")
ACE_TEXT("created type %C support.\n"),
type_name.in()
));
}
// Create the topic.
DDS::Topic_var topic = this->participant_->create_topic(
this->options_.topicName().c_str(),
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: Publisher::Publisher() - ")
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) Publisher::Publisher() - ")
ACE_TEXT("created topic %C.\n"),
this->options_.topicName().c_str()
));
}
// Create the publisher.
this->publisher_ = this->participant_->create_publisher(
PUBLISHER_QOS_DEFAULT,
::DDS::PublisherListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK
);
if( CORBA::is_nil(this->publisher_.in())) {
ACE_ERROR((LM_ERROR,
ACE_TEXT("(%P|%t) ERROR: Publisher::Publisher() - ")
ACE_TEXT("failed to create publisher.\n")
));
throw BadPublisherException();
} else if( this->options_.verbose()) {
ACE_DEBUG((LM_DEBUG,
ACE_TEXT("(%P|%t) Publisher::Publisher() - ")
ACE_TEXT("created publisher.\n")
));
}
// Writer Qos policy values.
::DDS::DataWriterQos writerQos;
this->publisher_->get_default_datawriter_qos( writerQos);
writerQos.durability.kind = ::DDS::TRANSIENT_LOCAL_DURABILITY_QOS;
writerQos.history.kind = ::DDS::KEEP_ALL_HISTORY_QOS;
writerQos.resource_limits.max_samples_per_instance = ::DDS::LENGTH_UNLIMITED;
writerQos.reliability.kind = ::DDS::RELIABLE_RELIABILITY_QOS;
if( this->options_.verbose()) {
ACE_DEBUG((LM_DEBUG,
ACE_TEXT("(%P|%t) Publisher::Publisher() - ")
ACE_TEXT("starting to create %d publications.\n"),
this->options_.publications()
));
}
// Build as many publications as are specified.
for( int index = 0; index < this->options_.publications(); ++index) {
// Create the writer.
DDS::DataWriter_var writer
= this->publisher_->create_datawriter(
topic.in(),
writerQos,
DDS::DataWriterListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK
);
if( CORBA::is_nil( writer.in())) {
ACE_ERROR((LM_ERROR,
ACE_TEXT("(%P|%t) ERROR: Publisher::Publisher() - ")
ACE_TEXT("failed to create writer.\n")
));
throw BadWriterException();
} else if( this->options_.verbose()) {
ACE_DEBUG((LM_DEBUG,
ACE_TEXT("(%P|%t) Publisher::Publisher() - ")
ACE_TEXT("created publication %d.\n"),
(1+index)
));
}
// Create a publication and store it.
this->publications_.push_back(
new Writer( writer.in(), index, this->options_.verbose())
);
//
// Grab, enable and attach the status condition for test
// synchronization of the current publication.
//
DDS::StatusCondition_var status = writer->get_statuscondition();
status->set_enabled_statuses( DDS::PUBLICATION_MATCHED_STATUS);
this->waiter_->attach_condition( status.in());
if( this->options_.verbose()) {
ACE_DEBUG((LM_DEBUG,
ACE_TEXT("(%P|%t) Publisher::Publisher() - ")
ACE_TEXT("created StatusCondition for publication %d.\n"),
(1+index)
));
}
}
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
int status = EXIT_SUCCESS;
try {
// Initialize DomainParticipantFactory
DDS::DomainParticipantFactory_var dpf =
TheParticipantFactoryWithArgs(argc, argv);
bool reliable = true;
int num_messages_expected = 40;
parse_args(argc, argv, reliable, num_messages_expected);
// handle test performance issue on one platform
#if defined (sun)
const char* udpTransName = "udp";
OpenDDS::DCPS::TransportInst_rch inst = OpenDDS::DCPS::TransportRegistry::instance()->get_inst(udpTransName);
if (inst != 0) {
OpenDDS::DCPS::UdpInst_rch udp_inst = OpenDDS::DCPS::dynamic_rchandle_cast<OpenDDS::DCPS::UdpInst>(inst);
if (udp_inst == 0) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l main()")
ACE_TEXT(" ERROR: retrieving transport config for: %C failed!\n"),
udpTransName), -1);
}
udp_inst->rcv_buffer_size_ = 0x40000;
}
#endif
// Create DomainParticipant
DDS::DomainParticipant_var participant =
dpf->create_participant(411,
PARTICIPANT_QOS_DEFAULT,
DDS::DomainParticipantListener::_nil(),
OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil(participant.in())) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l main()")
ACE_TEXT(" ERROR: create_participant() failed!\n")), -1);
}
// Register Type (Messenger::Message)
Messenger::MessageTypeSupport_var ts =
new Messenger::MessageTypeSupportImpl();
if (ts->register_type(participant.in(), "") != DDS::RETCODE_OK) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l main()")
ACE_TEXT(" ERROR: register_type() failed!\n")), -1);
}
// Create Topic (Movie Discussion List)
CORBA::String_var type_name = ts->get_type_name();
DDS::Topic_var topic =
participant->create_topic("Movie Discussion List",
type_name.in(),
TOPIC_QOS_DEFAULT,
DDS::TopicListener::_nil(),
OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil(topic.in())) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l main()")
ACE_TEXT(" ERROR: create_topic() failed!\n")), -1);
}
// Create Subscriber
DDS::Subscriber_var sub =
participant->create_subscriber(SUBSCRIBER_QOS_DEFAULT,
DDS::SubscriberListener::_nil(),
OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil(sub.in())) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l main()")
ACE_TEXT(" ERROR: create_subscriber() failed!\n")), -1);
}
// Create DataReader
DataReaderListenerImpl* listener_svt = new DataReaderListenerImpl;
DDS::DataReaderListener_var listener(listener_svt);
DDS::DataReaderQos qos;
sub->get_default_datareader_qos(qos);
qos.liveliness.kind = DDS::AUTOMATIC_LIVELINESS_QOS;
qos.liveliness.lease_duration.sec = 10;
qos.liveliness.lease_duration.nanosec = 0;
qos.history.kind = DDS::KEEP_ALL_HISTORY_QOS;
qos.durability.kind = DDS::TRANSIENT_LOCAL_DURABILITY_QOS;
if (reliable) {
qos.reliability.kind = DDS::RELIABLE_RELIABILITY_QOS;
}
DDS::DataReader_var reader =
sub->create_datareader(topic.in(),
qos,
listener.in(),
OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil(reader.in())) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l main()")
ACE_TEXT(" ERROR: create_datareader() failed!\n")), -1);
}
for (int delay = 0; listener_svt->num_samples() != num_messages_expected
&& delay < 60; ++delay) {
ACE_OS::sleep(1);
}
const long received = listener_svt->num_samples();
const bool data_consistent = reliable ? listener_svt->data_consistent() : true;
std::string error = "";
bool show_data_loss = true;
if (reliable && data_consistent && received < num_messages_expected) {
error = "ERROR: ";
status = EXIT_FAILURE;
}
else if (!data_consistent) {
status = EXIT_FAILURE;
show_data_loss = false;
}
if (show_data_loss && num_messages_expected) {
const unsigned int missed_msgs = (num_messages_expected - received);
const unsigned int percent = (missed_msgs * 100) / num_messages_expected;
std::cout << error
<< "data loss == " << percent << "% (" << received << "/"
<< num_messages_expected << " received)\n";
}
// Clean-up!
ACE_DEBUG((LM_DEBUG, "Subscriber delete contained entities\n"));
participant->delete_contained_entities();
ACE_DEBUG((LM_DEBUG, "Subscriber delete participant\n"));
dpf->delete_participant(participant);
ACE_DEBUG((LM_DEBUG, "Subscriber shutdown\n"));
TheServiceParticipant->shutdown();
ACE_DEBUG((LM_DEBUG, "Subscriber wait for thread manager\n"));
ACE_Thread_Manager::instance()->wait();
ACE_DEBUG((LM_DEBUG, "Subscriber vars going out of scope\n"));
} catch (const CORBA::Exception& e) {
e._tao_print_exception("Exception caught in main():");
status = EXIT_FAILURE;
}
ACE_DEBUG((LM_DEBUG, "Subscriber exiting with status=%d\n", status));
return status;
}
int ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
try
{
DDS::DomainParticipantFactory_var dpf;
DDS::DomainParticipant_var participant;
dpf = TheParticipantFactoryWithArgs(argc, argv);
participant = dpf->create_participant(411,
PARTICIPANT_QOS_DEFAULT,
DDS::DomainParticipantListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (participant.in ())) {
cerr << "create_participant failed." << endl;
return 1 ;
}
if (parse_args (argc, argv) == -1) {
return -1;
}
MessageTypeSupport_var mts = new MessageTypeSupportImpl();
if (DDS::RETCODE_OK != mts->register_type(participant.in (), "")) {
cerr << "Failed to register the MessageTypeTypeSupport." << endl;
exit(1);
}
CORBA::String_var type_name = mts->get_type_name ();
DDS::Topic_var topic = participant->create_topic("Movie Discussion List",
type_name.in (),
TOPIC_QOS_DEFAULT,
DDS::TopicListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (topic.in ())) {
cerr << "ERROR Failed to create_topic." << endl;
exit(1);
}
// Create the subscriber and attach to the corresponding
// transport.
DDS::Subscriber_var sub =
participant->create_subscriber(SUBSCRIBER_QOS_DEFAULT,
DDS::SubscriberListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (sub.in ())) {
cerr << "ERROR Failed to create_subscriber." << endl;
exit(1);
}
// activate the listener
DDS::DataReaderListener_var listener = new DataReaderListenerImpl;
DataReaderListenerImpl &listener_servant =
*dynamic_cast<DataReaderListenerImpl*>(listener.in());
if (CORBA::is_nil (listener.in ())) {
cerr << "ERROR listener is nil." << endl;
exit(1);
}
::DDS::DataReaderQos dr_qos;
sub->get_default_datareader_qos (dr_qos);
dr_qos.liveliness.lease_duration.sec = LEASE_DURATION_SEC ;
dr_qos.liveliness.lease_duration.nanosec = 0 ;
// Create the Datareaders
DDS::DataReader_var dr = sub->create_datareader(topic.in (),
dr_qos,
listener.in (),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (dr.in ())) {
cerr << "ERROR create_datareader failed." << endl;
exit(1);
}
int count = 0;
while ((++count < 60) && ((listener_servant.num_reads() < total_num_messages)))
{
ACE_OS::sleep (1);
}
ACE_OS::sleep(2);
ACE_DEBUG((LM_INFO,
"Subscriber got %d of %d messages, "
"and %d of %d callbacks, deleting entities\n",
(int) listener_servant.num_reads(), total_num_messages,
listener_servant.num_liveliness_change_callbacks(), num_liveliness_change_callbacks));
if (!CORBA::is_nil (participant.in ())) {
participant->delete_contained_entities();
}
if (!CORBA::is_nil (dpf.in ())) {
dpf->delete_participant(participant.in ());
}
ACE_OS::sleep(2);
TheServiceParticipant->shutdown ();
if (listener_servant.num_liveliness_change_callbacks () != num_liveliness_change_callbacks)
{
cerr
<< "ERROR: did not receive liveliness change callbacks as expected.("
<< listener_servant.num_liveliness_change_callbacks () << "/"
<< num_liveliness_change_callbacks << ")" << endl;
return 1;
}
}
catch (CORBA::Exception& e)
{
cerr << "ERROR: subscriber Exception caught in main ():" << endl << e << endl;
return 1;
}
return 0;
}
int ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
try
{
DDS::DomainParticipantFactory_var dpf;
DDS::DomainParticipant_var participant;
dpf = TheParticipantFactoryWithArgs(argc, argv);
participant =
dpf->create_participant(11,
PARTICIPANT_QOS_DEFAULT,
DDS::DomainParticipantListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (participant.in ())) {
cerr << "create_participant failed." << endl;
return 1 ;
}
Messenger::MessageTypeSupportImpl* mts_servant =
new Messenger::MessageTypeSupportImpl;
if (DDS::RETCODE_OK != mts_servant->register_type(participant.in (),
""))
{
cerr << "Failed to register the MessageTypeTypeSupport." << endl;
exit(1);
}
CORBA::String_var type_name = mts_servant->get_type_name ();
DDS::TopicQos topic_qos;
participant->get_default_topic_qos(topic_qos);
DDS::Topic_var topic =
participant->create_topic("Movie Discussion List",
type_name.in (),
topic_qos,
DDS::TopicListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (topic.in ())) {
cerr << "Failed to create_topic." << endl;
exit(1);
}
// Create the subscriber and attach to the corresponding
// transport.
DDS::Subscriber_var sub =
participant->create_subscriber (SUBSCRIBER_QOS_DEFAULT,
DDS::SubscriberListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (sub.in ())) {
cerr << "Failed to create_subscriber." << endl;
exit(1);
}
// ----------------------------------------------
{
// Attempt to create a DataReader with intentionally
// incompatible QoS.
DDS::DataReaderQos bogus_qos;
sub->get_default_datareader_qos (bogus_qos);
// Set up a 2 second recurring deadline. DataReader creation
// should fail with this QoS since the requested deadline period
// will be less than the test configured offered deadline
// period.
bogus_qos.deadline.period.sec = 2;
bogus_qos.deadline.period.nanosec = 0;
DDS::DataReader_var tmp_dr =
sub->create_datareader (topic.in (),
bogus_qos,
DDS::DataReaderListener::_nil (),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (tmp_dr.in ()))
{
cerr << "ERROR: DataReader creation with bogus QoS failed."
<< endl;
exit (1);
}
DDS::StatusCondition_var cond = tmp_dr->get_statuscondition();
cond->set_enabled_statuses(DDS::REQUESTED_INCOMPATIBLE_QOS_STATUS);
DDS::WaitSet_var ws = new DDS::WaitSet;
ws->attach_condition(cond);
DDS::Duration_t four_sec = {4, 0};
DDS::ConditionSeq active;
ws->wait(active, four_sec);
// Check if the incompatible deadline was correctly flagged.
if ((active.length() == 0) || (active[0] != cond)) {
cerr << "ERROR: Failed to get requested incompatible qos status" << endl;
exit (1);
}
DDS::RequestedIncompatibleQosStatus incompatible_status;
if (tmp_dr->get_requested_incompatible_qos_status (incompatible_status) != ::DDS::RETCODE_OK)
{
cerr << "ERROR: Failed to get requested incompatible qos status" << endl;
exit (1);
}
DDS::QosPolicyCountSeq const & policies =
incompatible_status.policies;
bool incompatible_deadline = false;
CORBA::ULong const len = policies.length ();
for (CORBA::ULong i = 0; i < len; ++i)
{
if (policies[i].policy_id == DDS::DEADLINE_QOS_POLICY_ID)
{
incompatible_deadline = true;
break;
}
}
if (!incompatible_deadline)
{
cerr << "ERROR: A DataReader/Writer association was created " << endl
<< " despite use of deliberately incompatible deadline "
<< "QoS." << endl;
exit (1);
}
}
// ----------------------------------------------
// Create the listener.
DDS::DataReaderListener_var listener (new DataReaderListenerImpl);
DataReaderListenerImpl* listener_servant =
dynamic_cast<DataReaderListenerImpl*>(listener.in());
if (CORBA::is_nil (listener.in ()))
{
cerr << "ERROR: listener is nil." << endl;
exit(1);
}
DDS::DataReaderQos dr_qos; // Good QoS.
sub->get_default_datareader_qos (dr_qos);
assert (DEADLINE_PERIOD.sec > 1); // Requirement for the test.
// First data reader will have a listener to test listener
// callback on deadline expiration.
DDS::DataReader_var dr1 =
sub->create_datareader (topic.in (),
dr_qos,
listener.in (),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
// Second data reader will not have a listener to test proper
// handling of a nil listener in the deadline handling code.
DDS::DataReader_var dr2 =
sub->create_datareader (topic.in (),
dr_qos,
DDS::DataReaderListener::_nil (),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (dr1.in ()) || CORBA::is_nil (dr2.in ()))
{
cerr << "ERROR: create_datareader failed." << endl;
exit(1);
}
dr_qos.deadline.period.sec = DEADLINE_PERIOD.sec;
dr_qos.deadline.period.nanosec = DEADLINE_PERIOD.nanosec;
// Reset qos to have deadline. The watch dog now starts.
if (dr1->set_qos (dr_qos) != ::DDS::RETCODE_OK
|| dr2->set_qos (dr_qos) != ::DDS::RETCODE_OK)
{
cerr << "ERROR: set deadline qos failed." << endl;
exit(1);
}
Messenger::MessageDataReader_var message_dr1 =
Messenger::MessageDataReader::_narrow(dr1.in());
Messenger::MessageDataReader_var message_dr2 =
Messenger::MessageDataReader::_narrow(dr2.in());
int max_attempts = 10;
int attempts = 0;
// Synchronize with publisher. Wait until both associate with DataWriter.
while (attempts < max_attempts)
{
::DDS::SubscriptionMatchedStatus status1;
::DDS::SubscriptionMatchedStatus status2;
if (dr1->get_subscription_matched_status (status1) == ::DDS::RETCODE_OK
&& dr2->get_subscription_matched_status (status2) == ::DDS::RETCODE_OK)
{
if (status1.total_count == 1 && status2.total_count == 1)
break;
++ attempts;
ACE_OS::sleep (1);
}
else
{
cerr << "ERROR: Failed to get subscription matched status" << endl;
exit (1);
}
}
if (attempts >= max_attempts)
{
cerr << "ERROR: failed to make associations. " << endl;
exit (1);
}
// ----------------------------------------------
ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%P|%t) Subscriber: sleep for %d milliseconds\n"),
SLEEP_DURATION.msec()));
// Wait for deadline periods to expire.
ACE_OS::sleep (SLEEP_DURATION);
ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%P|%t) Subscriber: now verify missed ")
ACE_TEXT ("deadline status \n")));
DDS::RequestedDeadlineMissedStatus deadline_status1;
if (dr1->get_requested_deadline_missed_status(deadline_status1) != ::DDS::RETCODE_OK)
{
cerr << "ERROR: Failed to get requested deadline missed status" << endl;
exit (1);
}
DDS::RequestedDeadlineMissedStatus deadline_status2;
if (dr2->get_requested_deadline_missed_status(deadline_status2) != ::DDS::RETCODE_OK)
{
cerr << "ERROR: Failed to get requested deadline missed status" << endl;
exit (1);
}
ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%P|%t) Subscriber: got missed")
ACE_TEXT ("deadline status \n")));
Messenger::Message message;
message.subject_id = 99;
::DDS::InstanceHandle_t dr1_hd1 = message_dr1->lookup_instance (message);
::DDS::InstanceHandle_t dr2_hd1 = message_dr2->lookup_instance (message);
message.subject_id = 100;
::DDS::InstanceHandle_t dr1_hd2 = message_dr1->lookup_instance (message);
::DDS::InstanceHandle_t dr2_hd2 = message_dr2->lookup_instance (message);
if (deadline_status1.last_instance_handle != dr1_hd1
&& deadline_status1.last_instance_handle != dr1_hd2)
{
cerr << "ERROR: Expected DR1 last instance handle ("
<< dr1_hd1 << " or " << dr1_hd2 << ") did not occur ("
<< deadline_status1.last_instance_handle << ")" << endl;
exit (1);
}
if (deadline_status2.last_instance_handle != dr2_hd1
&& deadline_status2.last_instance_handle != dr2_hd2)
{
cerr << "ERROR: Expected DR2 last instance handle ("
<< dr2_hd1 << " or " << dr2_hd2 << ") did not occur ("
<< deadline_status2.last_instance_handle << endl;
exit (1);
}
//The reader deadline period is 5 seconds and writer writes
//each instance every 9 seconds, so after SLEEP_DURATION(11secs),
//the deadline missed should be 1 per instance
if (deadline_status1.total_count != NUM_INSTANCE
|| deadline_status2.total_count != NUM_INSTANCE)
{
cerr << "ERROR: Expected number of missed requested "
<< "deadlines (" << NUM_INSTANCE << ") " << "did " << endl
<< " not occur ("
<< deadline_status1.total_count << " and/or "
<< deadline_status2.total_count << ")." << endl;
exit (1);
}
if (deadline_status1.total_count_change != NUM_INSTANCE
|| deadline_status2.total_count_change != NUM_INSTANCE)
{
cerr << "ERROR: Incorrect missed requested "
<< "deadline count change" << endl
<< " ("
<< deadline_status1.total_count_change
<< " and/or "
<< deadline_status2.total_count_change
<< " instead of " << NUM_EXPIRATIONS * NUM_INSTANCE << ")."
<< endl;
exit (1);
}
// Here the writers should continue writes all samples with
// .5 second interval.
ACE_Time_Value no_miss_period = num_messages * write_interval;
ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%P|%t) Subscriber: sleep for %d msec\n"),
(SLEEP_DURATION + no_miss_period).msec()));
// Wait for another set of deadline periods(5 + 11 secs).
// During this period, the writers continue write all samples with
// .5 second interval.
ACE_OS::sleep (SLEEP_DURATION + no_miss_period);
ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%P|%t) Subscriber: now verify missed ")
ACE_TEXT ("deadline status \n")));
if ((dr1->get_requested_deadline_missed_status(deadline_status1) != ::DDS::RETCODE_OK)
|| (dr2->get_requested_deadline_missed_status(deadline_status2) != ::DDS::RETCODE_OK))
{
cerr << "ERROR: failed to get requested deadline missed status" << endl;
exit (1);
}
ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%P|%t) Subscriber: got missed")
ACE_TEXT ("deadline status \n")));
if (deadline_status1.last_instance_handle != dr1_hd1
&& deadline_status1.last_instance_handle != dr1_hd2)
{
cerr << "ERROR: Expected DR1 last instance handle ("
<< dr1_hd1 << " or " << dr1_hd2 << ") did not occur ("
<< deadline_status1.last_instance_handle << ")" << endl;
exit (1);
}
if (deadline_status2.last_instance_handle != dr2_hd1
&& deadline_status2.last_instance_handle != dr2_hd2)
{
cerr << "ERROR: Expected DR2 last instance handle ("
<< dr2_hd1 << " or " << dr2_hd2 << ") did not occur ("
<< deadline_status2.last_instance_handle << endl;
exit (1);
}
if (deadline_status1.total_count != 3 * NUM_INSTANCE
|| deadline_status2.total_count != 3 * NUM_INSTANCE)
{
cerr << "ERROR: Another expected number of missed requested "
<< "deadlines (" << NUM_INSTANCE << ")" << endl
<< " did not occur ("
<< deadline_status1.total_count << " and/or "
<< deadline_status2.total_count << ")." << endl;
exit (1);
}
if (deadline_status1.total_count_change != 2 * NUM_INSTANCE
|| deadline_status2.total_count_change != 2 * NUM_INSTANCE)
{
cerr << "ERROR: Incorrect missed requested "
<< "deadline count" << endl
<< " change ("
<< deadline_status1.total_count_change
<< "and/or "
<< deadline_status2.total_count_change
<< " instead of " << NUM_EXPIRATIONS << ")." << endl;
exit (1);
}
int expected = 10;
while ( listener_servant->num_arrived() < expected) {
ACE_OS::sleep (1);
}
if (!CORBA::is_nil (participant.in ())) {
participant->delete_contained_entities();
}
if (!CORBA::is_nil (dpf.in ())) {
dpf->delete_participant(participant.in ());
}
ACE_OS::sleep(2);
TheServiceParticipant->shutdown ();
}
catch (CORBA::Exception& e)
{
cerr << "SUB: Exception caught in main ():" << endl << e << endl;
return 1;
}
return 0;
}
int ACE_TMAIN (int argc, ACE_TCHAR *argv[]) {
int status = 0;
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;
}
DDS::DomainParticipant_var participant2 =
dpf->create_participant(411,
PARTICIPANT_QOS_DEFAULT,
DDS::DomainParticipantListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (participant2.in ())) {
cerr << "create_participant failed." << endl;
return 1;
}
OpenDDS::DCPS::TransportConfig_rch cfg = TheTransportRegistry->get_config("part1");
if (!cfg.is_nil()) {
TheTransportRegistry->bind_config(cfg, participant);
}
cfg = TheTransportRegistry->get_config("part2");
if (!cfg.is_nil()) {
TheTransportRegistry->bind_config(cfg, participant2);
}
if (parse_args (argc, argv) == -1) {
return -1;
}
MessageTypeSupport_var mts = new MessageTypeSupportImpl();
MessageTypeSupport_var mts2 = new MessageTypeSupportImpl();
if (DDS::RETCODE_OK != mts->register_type(participant.in (), "")) {
cerr << "register_type failed." << endl;
exit(1);
}
if (DDS::RETCODE_OK != mts2->register_type(participant2.in (), "")) {
cerr << "register_type failed." << endl;
exit(1);
}
CORBA::String_var type_name = mts->get_type_name ();
CORBA::String_var type_name2 = mts2->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 << "create_topic failed." << endl;
exit(1);
}
DDS::Topic_var topic2 =
participant2->create_topic ("Movie Discussion List",
type_name2.in (),
TOPIC_QOS_DEFAULT,
DDS::TopicListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (topic2.in ())) {
cerr << "create_topic failed." << endl;
exit(1);
}
DDS::Publisher_var pub =
participant->create_publisher(PUBLISHER_QOS_DEFAULT,
DDS::PublisherListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (pub.in ())) {
cerr << "create_publisher failed." << endl;
exit(1);
}
DDS::Publisher_var pub2 =
participant2->create_publisher(PUBLISHER_QOS_DEFAULT,
DDS::PublisherListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (pub2.in ())) {
cerr << "create_publisher failed." << endl;
exit(1);
}
DataWriterListenerImpl * dwl1_servant = new DataWriterListenerImpl;
::DDS::DataWriterListener_var dwl1 (dwl1_servant);
DataWriterListenerImpl * dwl2_servant = new DataWriterListenerImpl;
::DDS::DataWriterListener_var dwl2 (dwl2_servant);
DataWriterListenerImpl * dwl3_servant = new DataWriterListenerImpl;
::DDS::DataWriterListener_var dwl3 (dwl3_servant);
DataWriterListenerImpl * dwl4_servant = new DataWriterListenerImpl;
::DDS::DataWriterListener_var dwl4 (dwl4_servant);
// Create the datawriters
::DDS::DataWriterQos dw_qos;
pub->get_default_datawriter_qos (dw_qos);
::DDS::DataWriterQos dw2_qos;
pub2->get_default_datawriter_qos (dw2_qos);
dw_qos.liveliness.kind = ::DDS::MANUAL_BY_PARTICIPANT_LIVELINESS_QOS;
dw_qos.liveliness.lease_duration.sec = LEASE_DURATION_SEC;
dw_qos.liveliness.lease_duration.nanosec = 0;
dw2_qos.liveliness.kind = ::DDS::MANUAL_BY_PARTICIPANT_LIVELINESS_QOS;
dw2_qos.liveliness.lease_duration.sec = LEASE_DURATION_SEC;
dw2_qos.liveliness.lease_duration.nanosec = 0;
// Create the datawriter
DDS::DataWriter_var dw1 =
pub->create_datawriter(topic.in (),
dw_qos,
dwl1.in(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (dw1.in ())) {
cerr << "create_datawriter failed." << endl;
exit(1);
}
// Create the datawriter
DDS::DataWriter_var dw2 =
pub2->create_datawriter(topic2.in (),
dw2_qos,
dwl2.in(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (dw2.in ())) {
cerr << "create_datawriter failed." << endl;
exit(1);
}
dw_qos.liveliness.kind = ::DDS::MANUAL_BY_TOPIC_LIVELINESS_QOS;
// Create the datawriter
DDS::DataWriter_var dw3 =
pub->create_datawriter(topic.in (),
dw_qos,
dwl3.in(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (dw3.in ())) {
cerr << "create_datawriter failed." << endl;
exit(1);
}
// Create the datawriter
DDS::DataWriter_var dw4 =
pub->create_datawriter(topic.in (),
dw_qos,
dwl4.in(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (dw4.in ())) {
cerr << "create_datawriter failed." << endl;
exit(1);
}
{
Write_Samples writer1(dw1, "Manual_By_Participant_Writer_1");
Assert_Participant_Liveliness writer2(dw2, "Manual_By_Participant_Writer_2");
Write_Samples writer3(dw3, "Manual_By_Topic_Writer_1");
Assert_Writer_Liveliness writer4(dw4, "Manual_By_Topic_Writer_2");
writer1.start();
writer2.start();
writer3.start();
writer4.start();
writer1.end();
writer2.end();
writer3.end();
writer4.end();
}
const unsigned long actual = dwl1_servant->num_liveliness_lost_callbacks() +
dwl2_servant->num_liveliness_lost_callbacks() +
dwl3_servant->num_liveliness_lost_callbacks() +
dwl4_servant->num_liveliness_lost_callbacks();
if (liveliness_lost_test
&& static_cast<int>(actual) != num_liveliness_lost_callbacks)
{
cerr << "ERROR: did not receive expected liveliness lost callbacks. "
<< actual << "/" <<
num_liveliness_lost_callbacks << endl;
status = 1;
}
ACE_OS::sleep(1);
ACE_DEBUG((LM_INFO, "publisher deleting entities\n"));
participant->delete_contained_entities();
dpf->delete_participant(participant.in ());
participant2->delete_contained_entities();
dpf->delete_participant(participant2.in ());
TheServiceParticipant->shutdown ();
}
catch (CORBA::Exception& e)
{
cerr << "PUB: Exception caught in main.cpp:" << endl
<< e << endl;
exit(1);
}
return status;
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
try {
// Initialize DomainParticipantFactory
DDS::DomainParticipantFactory_var dpf =
TheParticipantFactoryWithArgs(argc, argv);
int error;
if ((error = parse_args(argc, argv)) != 0) {
return error;
}
// Create DomainParticipant
DDS::DomainParticipant_var participant =
dpf->create_participant(411,
PARTICIPANT_QOS_DEFAULT,
DDS::DomainParticipantListener::_nil(),
OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil(participant.in())) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l main()")
ACE_TEXT(" ERROR: create_participant() failed!\n")), -1);
}
// Register Type (Messenger::Message)
Messenger::MessageTypeSupport_var ts =
new Messenger::MessageTypeSupportImpl();
if (ts->register_type(participant.in(), "") != DDS::RETCODE_OK) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l main()")
ACE_TEXT(" ERROR: register_type() failed!\n")), -1);
}
// Create Topic (Movie Discussion List)
DDS::Topic_var topic =
participant->create_topic("Movie Discussion List",
ts->get_type_name(),
TOPIC_QOS_DEFAULT,
DDS::TopicListener::_nil(),
OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil(topic.in())) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l main()")
ACE_TEXT(" ERROR: create_topic() failed!\n")), -1);
}
::DDS::SubscriberQos subscriber_qos;
participant->get_default_subscriber_qos (subscriber_qos);
subscriber_qos.presentation.access_scope
= (::DDS::PresentationQosPolicyAccessScopeKind)acess_scope;
subscriber_qos.presentation.coherent_access = true;
subscriber_qos.presentation.ordered_access = true;
SubscriberListenerImpl* subscriber_listener_svt = new SubscriberListenerImpl();
DDS::SubscriberListener_var subscriber_listener(subscriber_listener_svt);
// Create Subscriber
DDS::Subscriber_var sub =
participant->create_subscriber(subscriber_qos,
subscriber_listener.in(),
OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil(sub.in())) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l main()")
ACE_TEXT(" ERROR: create_subscriber() failed!\n")), -1);
}
// Initialize Transport
OpenDDS::DCPS::TransportImpl_rch transport_impl =
TheTransportFactory->create_transport_impl(transport_impl_id,
OpenDDS::DCPS::AUTO_CONFIG);
OpenDDS::DCPS::AttachStatus status = transport_impl->attach(sub.in());
if (status != OpenDDS::DCPS::ATTACH_OK) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l main()")
ACE_TEXT(" ERROR: attach() failed!\n")), -1);
}
// Create DataReader
DataReaderListenerImpl* listener_svt1 = new DataReaderListenerImpl("DataReader1");
DataReaderListenerImpl* listener_svt2 = new DataReaderListenerImpl("DataReader2");
DDS::DataReaderListener_var listener1(listener_svt1);
DDS::DataReaderListener_var listener2(listener_svt2);
::DDS::DataReaderQos readerQos;
sub->get_default_datareader_qos( readerQos);
readerQos.history.kind = ::DDS::KEEP_ALL_HISTORY_QOS;
readerQos.resource_limits.max_samples_per_instance = ::DDS::LENGTH_UNLIMITED;
DDS::DataReader_var reader1 =
sub->create_datareader(topic.in(),
readerQos,
listener1.in(),
OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil(reader1.in())) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l main()")
ACE_TEXT(" ERROR: create_datareader() failed!\n")), -1);
}
DDS::DataReader_var reader2 =
sub->create_datareader(topic.in(),
readerQos,
listener2.in(),
OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil(reader2.in())) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l main()")
ACE_TEXT(" ERROR: create_datareader() failed!\n")), -1);
}
// Block until Publisher completes
DDS::StatusCondition_var condition1 = reader1->get_statuscondition();
DDS::StatusCondition_var condition2 = reader2->get_statuscondition();
condition1->set_enabled_statuses(DDS::SUBSCRIPTION_MATCHED_STATUS);
condition2->set_enabled_statuses(DDS::SUBSCRIPTION_MATCHED_STATUS);
DDS::WaitSet_var ws1 = new DDS::WaitSet;
DDS::WaitSet_var ws2 = new DDS::WaitSet;
ws1->attach_condition(condition1);
ws2->attach_condition(condition2);
DDS::Duration_t timeout =
{ DDS::DURATION_INFINITE_SEC, DDS::DURATION_INFINITE_NSEC };
DDS::ConditionSeq conditions1;
DDS::ConditionSeq conditions2;
DDS::SubscriptionMatchedStatus matches1 = { 0, 0, 0, 0, 0 };
DDS::SubscriptionMatchedStatus matches2 = { 0, 0, 0, 0, 0 };
do {
if (matches1.current_count == 0 && ws1->wait(conditions1, timeout) != DDS::RETCODE_OK) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l main()")
ACE_TEXT(" ERROR: wait() failed!\n")), -1);
}
if (matches2.current_count == 0 && ws2->wait(conditions2, timeout) != DDS::RETCODE_OK) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l main()")
ACE_TEXT(" ERROR: wait() failed!\n")), -1);
}
if (reader1->get_subscription_matched_status(matches1) != DDS::RETCODE_OK) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l main()")
ACE_TEXT(" ERROR: get_subscription_matched_status() failed!\n")), -1);
}
if (reader2->get_subscription_matched_status(matches2) != DDS::RETCODE_OK) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l main()")
ACE_TEXT(" ERROR: get_subscription_matched_status() failed!\n")), -1);
}
} while (matches1.current_count > 0 && matches2.current_count > 0);
if (! subscriber_listener_svt->verify_result ()
|| ! listener_svt1->verify_result()
|| ! listener_svt2->verify_result()) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l main()")
ACE_TEXT(" ERROR: failed to verify message!\n")), -1);
}
ws1->detach_condition(condition1);
ws2->detach_condition(condition2);
// Clean-up!
participant->delete_contained_entities();
dpf->delete_participant(participant.in());
TheTransportFactory->release();
TheServiceParticipant->shutdown();
} catch (const CORBA::Exception& e) {
e._tao_print_exception("Exception caught in main():");
return -1;
}
return 0;
}
void init ()
{
participant
= dpf->create_participant(domain_id,
PARTICIPANT_QOS_DEFAULT,
::DDS::DomainParticipantListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (participant.in ()))
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT("(%P|%t) create_participant failed.\n")));
throw TestException ();
}
::Xyz::FooTypeSupportImpl* fts_servant
= new ::Xyz::FooTypeSupportImpl();
if (::DDS::RETCODE_OK != fts_servant->register_type(participant.in (), type_name))
{
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);
topic[0]
= participant->create_topic (topic_name[0],
type_name,
topic_qos,
::DDS::TopicListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (topic[0].in ()))
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT("(%P|%t) create_topic failed.\n")));
throw TestException ();
}
topic[1]
= participant->create_topic (topic_name[1],
type_name,
topic_qos,
::DDS::TopicListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (topic[1].in ()))
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT("(%P|%t) create_topic failed.\n")));
throw TestException ();
}
writer_impl
= TheTransportFactory->create_transport_impl (PUB_TRAFFIC_TCP,
ACE_TEXT("SimpleTcp"),
OpenDDS::DCPS::DONT_AUTO_CONFIG);
OpenDDS::DCPS::TransportConfiguration_rch writer_config
= TheTransportFactory->create_configuration (PUB_TRAFFIC_TCP, ACE_TEXT("SimpleTcp"));
OpenDDS::DCPS::SimpleTcpConfiguration* writer_tcp_config
= static_cast <OpenDDS::DCPS::SimpleTcpConfiguration*> (writer_config.in ());
if (writer_address_given)
{
ACE_INET_Addr writer_address (writer_address_str.c_str ());
writer_tcp_config->local_address_ = writer_address;
writer_tcp_config->local_address_str_ = writer_address_str.c_str ();
}
// else use default address - OS assigned.
if (writer_impl->configure(writer_config.in()) != 0)
{
ACE_ERROR((LM_ERROR,
ACE_TEXT("(%P|%t) init_writer_tranport: pub TCP")
ACE_TEXT(" Failed to configure the transport.\n")));
throw TestException ();
}
// Create the default publisher
publisher = participant->create_publisher(PUBLISHER_QOS_DEFAULT,
::DDS::PublisherListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (publisher.in ()))
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT("(%P|%t) create_publisher failed.\n")));
throw TestException ();
}
// Attach the publisher to the transport.
OpenDDS::DCPS::PublisherImpl* pub_impl
= dynamic_cast<OpenDDS::DCPS::PublisherImpl*>
(publisher.in ());
if (0 == pub_impl)
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT("(%P|%t) Failed to obtain publisher servant \n")));
throw TestException ();
}
ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) attach to tcp \n")));
OpenDDS::DCPS::AttachStatus attach_status
= pub_impl->attach_transport(writer_impl.in());
if (attach_status != OpenDDS::DCPS::ATTACH_OK)
{
// We failed to attach to the transport for some reason.
ACE_TString status_str;
switch (attach_status)
{
case OpenDDS::DCPS::ATTACH_BAD_TRANSPORT:
status_str = ACE_TEXT("ATTACH_BAD_TRANSPORT");
break;
case OpenDDS::DCPS::ATTACH_ERROR:
status_str = ACE_TEXT("ATTACH_ERROR");
break;
case OpenDDS::DCPS::ATTACH_INCOMPATIBLE_QOS:
status_str = ACE_TEXT("ATTACH_INCOMPATIBLE_QOS");
break;
default:
status_str = ACE_TEXT("Unknown Status");
break;
}
ACE_ERROR ((LM_ERROR,
ACE_TEXT("(%P|%t) Failed to attach to the transport. ")
ACE_TEXT("AttachStatus == %s\n"),
status_str.c_str()));
throw TestException ();
}
// Create the datawriters
::DDS::DataWriterQos dw_qos;
publisher->get_default_datawriter_qos (dw_qos);
// Make it KEEP_ALL history so we can verify the received
// data without dropping.
dw_qos.history.kind = ::DDS::KEEP_ALL_HISTORY_QOS;
dw_qos.reliability.kind = ::DDS::RELIABLE_RELIABILITY_QOS;
dw_qos.resource_limits.max_samples_per_instance = ::DDS::LENGTH_UNLIMITED;
dw_qos.reliability.max_blocking_time.sec = 0;
dw_qos.reliability.max_blocking_time.nanosec = 0;
for (int i = 0; i < 2; ++i)
{
datawriter[i] = publisher->create_datawriter(topic[i].in (),
dw_qos,
::DDS::DataWriterListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (datawriter[i].in ()))
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT("(%P|%t) create_datawriter failed.\n")));
throw TestException ();
}
writers[i] = new Writer (datawriter[i].in (), i);
}
}
int
ParticipantTask::svc()
{
try
{
ACE_DEBUG((LM_INFO, ACE_TEXT("(%P|%t) -> PARTICIPANT STARTED\n")));
DDS::DomainParticipantFactory_var dpf = TheParticipantFactory;
DDS::DomainParticipant_var participant;
DDS::Publisher_var publisher;
DDS::DataWriter_var writer;
FooDataWriter_var writer_i;
DDS::StatusCondition_var cond;
DDS::WaitSet_var ws = new DDS::WaitSet;
{ // Scope for guard to serialize creating Entities.
GuardType guard(lock_);
// Create Participant
participant =
dpf->create_participant(42,
PARTICIPANT_QOS_DEFAULT,
DDS::DomainParticipantListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
#ifdef OPENDDS_SAFETY_PROFILE
// RTPS cannot be shared
char config_name[64], inst_name[64];
ACE_OS::snprintf(config_name, 64, "cfg_%d", thread_index_);
ACE_OS::snprintf(inst_name, 64, "rtps_%d", thread_index_);
++thread_index_;
ACE_DEBUG((LM_INFO,
"(%P|%t) -> PARTICIPANT creating transport config %C\n",
config_name));
OpenDDS::DCPS::TransportConfig_rch config =
TheTransportRegistry->create_config(config_name);
OpenDDS::DCPS::TransportInst_rch inst =
TheTransportRegistry->create_inst(inst_name, "rtps_udp");
config->instances_.push_back(inst);
TheTransportRegistry->bind_config(config_name, participant);
#endif
} // End of lock scope.
if (CORBA::is_nil(participant.in()))
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l: svc()")
ACE_TEXT(" create_participant failed!\n")), 1);
{
// Create Publisher
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: svc()")
ACE_TEXT(" create_publisher 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: svc()")
ACE_TEXT(" 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: svc()")
ACE_TEXT(" create_topic failed!\n")), 1);
// Create DataWriter
DDS::DataWriterQos writer_qos;
publisher->get_default_datawriter_qos(writer_qos);
#ifndef OPENDDS_NO_OWNERSHIP_PROFILE
writer_qos.history.depth = samples_per_thread_;
#endif
writer =
publisher->create_datawriter(topic.in(),
writer_qos,
DDS::DataWriterListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil(writer.in()))
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l: svc()")
ACE_TEXT(" create_datawriter failed!\n")), 1);
writer_i = FooDataWriter::_narrow(writer);
if (CORBA::is_nil(writer_i))
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l: svc()")
ACE_TEXT(" _narrow failed!\n")), 1);
// Block until Subscriber is available
cond = writer->get_statuscondition();
cond->set_enabled_statuses(DDS::PUBLICATION_MATCHED_STATUS);
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: svc()")
ACE_TEXT(" wait failed!\n")), 1);
if (writer->get_publication_matched_status(matches) != ::DDS::RETCODE_OK)
{
ACE_ERROR ((LM_ERROR,
"(%P|%t) ERROR: failed to get publication matched status\n"));
ACE_OS::exit (1);
}
}
while (matches.current_count < 1);
ws->detach_condition(cond);
// The following is intentionally inefficient to stress various
// pathways related to publication; we should be especially dull
// and write only one sample at a time per writer.
ProgressIndicator progress("(%P|%t) PARTICIPANT %d%% (%d samples sent)\n",
samples_per_thread_);
for (std::size_t i = 0; i < samples_per_thread_; ++i)
{
Foo foo;
foo.key = 3;
DDS::InstanceHandle_t handle = writer_i->register_instance(foo);
if (writer_i->write(foo, handle) != DDS::RETCODE_OK) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("%N:%l: svc()")
ACE_TEXT(" write failed!\n")), 1);
}
++progress;
}
DDS::Duration_t interval = { 30, 0};
if( DDS::RETCODE_OK != writer->wait_for_acknowledgments( interval)) {
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT("(%P:%t) ERROR: svc() - ")
ACE_TEXT("timed out waiting for acks!\n")
), 1);
}
}
// Clean-up!
ACE_DEBUG((LM_INFO, ACE_TEXT("(%P|%t) <- PUBLISHER PARTICIPANT DEL CONT ENTITIES\n")));
participant->delete_contained_entities();
ACE_DEBUG((LM_INFO, ACE_TEXT("(%P|%t) <- PUBLISHER DELETE PARTICIPANT\n")));
dpf->delete_participant(participant.in());
ACE_DEBUG((LM_INFO, ACE_TEXT("(%P|%t) <- PUBLISHER PARTICIPANT VARS GOING OUT OF SCOPE\n")));
}
catch (const CORBA::Exception& e)
{
e._tao_print_exception("caught in svc()");
return 1;
}
ACE_DEBUG((LM_INFO, ACE_TEXT("(%P|%t) <- PARTICIPANT FINISHED\n")));
return 0;
}
int ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
try
{
DDS::DomainParticipantFactory_var dpf;
DDS::DomainParticipant_var participant;
dpf = TheParticipantFactoryWithArgs(argc, argv);
participant =
dpf->create_participant(311,
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 first subscriber belongs to PARTITION A
DDS::SubscriberQos sub_qos1;
participant->get_default_subscriber_qos (sub_qos1);
sub_qos1.partition.name.length (1);
sub_qos1.partition.name[0] = PARTITION_A;
DDS::Subscriber_var sub1 =
participant->create_subscriber (sub_qos1,
DDS::SubscriberListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (sub1.in ())) {
cerr << "Failed to create_subscriber." << endl;
exit(1);
}
// Create the second subscriber belongs to PARTITION B
DDS::SubscriberQos sub_qos2;
participant->get_default_subscriber_qos (sub_qos2);
sub_qos2.partition.name.length (1);
sub_qos2.partition.name[0] = PARTITION_B;
DDS::Subscriber_var sub2 =
participant->create_subscriber (sub_qos2,
DDS::SubscriberListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (sub2.in ())) {
cerr << "Failed to create_subscriber." << endl;
exit(1);
}
DDS::DataReaderQos dr_qos;
sub1->get_default_datareader_qos (dr_qos);
// Create first DataReader with listener.
DDS::DataReaderListener_var listener1 (new DataReaderListenerImpl);
if (CORBA::is_nil (listener1.in ()))
{
cerr << "ERROR: listener1 is nil." << endl;
exit(1);
}
DDS::DataReader_var dr1 =
sub1->create_datareader (topic.in (),
dr_qos,
listener1.in (),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
// Create second DataReader with listener.
DDS::DataReaderListener_var listener2 (new DataReaderListenerImpl);
if (CORBA::is_nil (listener2.in ()))
{
cerr << "ERROR: listener2 is nil." << endl;
exit(1);
}
DDS::DataReader_var dr2 =
sub2->create_datareader (topic.in (),
dr_qos,
listener2.in (),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (dr1.in ()) || CORBA::is_nil (dr2.in ()))
{
cerr << "ERROR: create_datareader failed." << endl;
exit(1);
}
DataReaderListenerImpl* listener_servant1 =
dynamic_cast<DataReaderListenerImpl*>(listener1.in());
DataReaderListenerImpl* listener_servant2 =
dynamic_cast<DataReaderListenerImpl*>(listener2.in());
int expected = 10;
cout << "subscriber waiting for partition A completion" << endl;
// Writer of PARTITION A -> Reader of PARTITION A
while ( listener_servant1->num_reads() < expected) {
ACE_OS::sleep (1);
}
cout << "subscriber waiting for partition B completion" << endl;
// Writer switch from PARTITION A to B -> Reader of PARTITION B
while ( listener_servant2->num_reads() < expected) {
ACE_OS::sleep (1);
}
// ----------------------------------------------
// Now switch first reader/subscriber from A to B
// and it should be connected with DataWriter.
cout << "subscriber switching from A to B partition" << endl;
sub_qos1.partition.name[0] = PARTITION_B;
if (sub1->set_qos (sub_qos1) != ::DDS::RETCODE_OK)
{
cerr << "ERROR: failed to set partition" << endl;
exit (1);
}
// Continue receive 10 more messages each.
expected = 20;
cout << "subscriber waiting for 2nd partition B completion" << endl;
while ( listener_servant1->num_reads() < expected) {
ACE_OS::sleep (1);
}
while ( listener_servant2->num_reads() < expected) {
ACE_OS::sleep (1);
}
if (listener_servant1->num_reads() > expected
|| listener_servant2->num_reads() > expected)
{
cerr << "ERROR: received more than excepted messages" << endl;
exit (1);
}
// Now shutdown
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 << "SUB: Exception caught in main ():" << endl << e << endl;
return 1;
}
TheServiceParticipant->shutdown ();
return 0;
}
int ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
try
{
DDS::DomainParticipantFactory_var dpf;
DDS::DomainParticipant_var participant;
if( OpenDDS::DCPS::DCPS_debug_level > 0) {
ACE_DEBUG((LM_DEBUG,
ACE_TEXT("(%P|%t) subscriber: ")
ACE_TEXT("initialization starting.\n")
));
}
dpf = TheParticipantFactoryWithArgs(argc, argv);
participant = dpf->create_participant(411,
PARTICIPANT_QOS_DEFAULT,
DDS::DomainParticipantListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (participant.in ())) {
cerr << "create_participant failed." << endl;
return 1 ;
}
if( OpenDDS::DCPS::DCPS_debug_level > 0) {
ACE_DEBUG((LM_DEBUG,
ACE_TEXT("(%P|%t) subscriber: ")
ACE_TEXT("participant created.\n")
));
}
if (parse_args (argc, argv) == -1) {
return -1;
}
if( OpenDDS::DCPS::DCPS_debug_level > 0) {
ACE_DEBUG((LM_DEBUG,
ACE_TEXT("(%P|%t) subscriber: ")
ACE_TEXT("command line parsed.\n")
));
}
MessageTypeSupportImpl* mts_servant = new MessageTypeSupportImpl();
if (DDS::RETCODE_OK != mts_servant->register_type(participant.in (), "")) {
cerr << "Failed to register the MessageTypeTypeSupport." << endl;
exit(1);
}
CORBA::String_var type_name = mts_servant->get_type_name ();
if( OpenDDS::DCPS::DCPS_debug_level > 0) {
ACE_DEBUG((LM_DEBUG,
ACE_TEXT("(%P|%t) subscriber: ")
ACE_TEXT("type support installed.\n")
));
}
DDS::TopicQos topic_qos;
participant->get_default_topic_qos(topic_qos);
DDS::Topic_var topic = participant->create_topic("Movie Discussion List",
type_name.in (),
topic_qos,
DDS::TopicListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (topic.in ())) {
cerr << "Failed to create_topic." << endl;
exit(1);
}
if( OpenDDS::DCPS::DCPS_debug_level > 0) {
ACE_DEBUG((LM_DEBUG,
ACE_TEXT("(%P|%t) subscriber: ")
ACE_TEXT("topic created.\n")
));
}
// Initialize the transport
OpenDDS::DCPS::TransportImpl_rch tcp_impl =
TheTransportFactory->create_transport_impl (transport_impl_id,
::OpenDDS::DCPS::AUTO_CONFIG);
if( OpenDDS::DCPS::DCPS_debug_level > 0) {
ACE_DEBUG((LM_DEBUG,
ACE_TEXT("(%P|%t) subscriber: ")
ACE_TEXT("transport created.\n")
));
}
// Create the subscriber and attach to the corresponding
// transport.
DDS::Subscriber_var sub =
participant->create_subscriber(SUBSCRIBER_QOS_DEFAULT,
DDS::SubscriberListener::_nil(),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (sub.in ())) {
cerr << "Failed to create_subscriber." << endl;
exit(1);
}
if( OpenDDS::DCPS::DCPS_debug_level > 0) {
ACE_DEBUG((LM_DEBUG,
ACE_TEXT("(%P|%t) subscriber: ")
ACE_TEXT("subscriber created.\n")
));
}
// Attach the subscriber to the transport.
OpenDDS::DCPS::SubscriberImpl* sub_impl =
dynamic_cast<OpenDDS::DCPS::SubscriberImpl*> (sub.in ());
if (0 == sub_impl) {
cerr << "Failed to obtain subscriber servant\n" << endl;
exit(1);
}
if( OpenDDS::DCPS::DCPS_debug_level > 0) {
ACE_DEBUG((LM_DEBUG,
ACE_TEXT("(%P|%t) subscriber: ")
ACE_TEXT("servant extracted.\n")
));
}
OpenDDS::DCPS::AttachStatus status = sub_impl->attach_transport(tcp_impl.in());
if (status != OpenDDS::DCPS::ATTACH_OK) {
std::string status_str;
switch (status) {
case OpenDDS::DCPS::ATTACH_BAD_TRANSPORT:
status_str = "ATTACH_BAD_TRANSPORT";
break;
case OpenDDS::DCPS::ATTACH_ERROR:
status_str = "ATTACH_ERROR";
break;
case OpenDDS::DCPS::ATTACH_INCOMPATIBLE_QOS:
status_str = "ATTACH_INCOMPATIBLE_QOS";
break;
default:
status_str = "Unknown Status";
break;
}
cerr << "Failed to attach to the transport. Status == "
<< status_str.c_str() << endl;
exit(1);
}
if( OpenDDS::DCPS::DCPS_debug_level > 0) {
ACE_DEBUG((LM_DEBUG,
ACE_TEXT("(%P|%t) subscriber: ")
ACE_TEXT("transport attached.\n")
));
}
// activate the listener
DDS::DataReaderListener_var listener (new DataReaderListenerImpl);
DataReaderListenerImpl* listener_servant =
dynamic_cast<DataReaderListenerImpl*>(listener.in());
if (CORBA::is_nil (listener.in ())) {
cerr << "listener is nil." << endl;
exit(1);
}
if( OpenDDS::DCPS::DCPS_debug_level > 0) {
ACE_DEBUG((LM_DEBUG,
ACE_TEXT("(%P|%t) subscriber: ")
ACE_TEXT("listener created.\n")
));
}
// Create the Datareaders
DDS::DataReaderQos dr_qos;
sub->get_default_datareader_qos (dr_qos);
DDS::DataReader_var dr = sub->create_datareader(topic.in (),
dr_qos,
listener.in (),
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil (dr.in ())) {
cerr << "create_datareader failed." << endl;
exit(1);
}
if( OpenDDS::DCPS::DCPS_debug_level > 0) {
ACE_DEBUG((LM_DEBUG,
ACE_TEXT("(%P|%t) subscriber: ")
ACE_TEXT("processing starting.\n")
));
}
int expected = 5;
while ( listener_servant->num_reads() < expected) {
ACE_OS::sleep (1);
}
if (!CORBA::is_nil (participant.in ())) {
participant->delete_contained_entities();
}
if (!CORBA::is_nil (dpf.in ())) {
dpf->delete_participant(participant.in ());
}
ACE_OS::sleep(2);
TheTransportFactory->release();
TheServiceParticipant->shutdown ();
}
catch (CORBA::Exception& e)
{
cerr << "SUB: Exception caught in main ():" << endl << e << endl;
return 1;
}
return 0;
}