void test_setup(const DomainParticipant_var& dp,
const MessageTypeSupport_var& ts, const Publisher_var& pub,
const Subscriber_var& sub, const char* topicName, DataWriter_var& dw,
DataReader_var& dr)
{
Topic_var topic = dp->create_topic(topicName, ts->get_type_name(),
TOPIC_QOS_DEFAULT, 0,
DEFAULT_STATUS_MASK);
DataWriterQos dw_qos;
pub->get_default_datawriter_qos(dw_qos);
dw_qos.history.kind = KEEP_ALL_HISTORY_QOS;
dw = pub->create_datawriter(topic, dw_qos, 0, DEFAULT_STATUS_MASK);
DataReaderQos dr_qos;
sub->get_default_datareader_qos(dr_qos);
dr_qos.history.kind = KEEP_ALL_HISTORY_QOS;
dr = sub->create_datareader(topic, dr_qos, 0, DEFAULT_STATUS_MASK);
StatusCondition_var dw_sc = dw->get_statuscondition();
dw_sc->set_enabled_statuses(PUBLICATION_MATCHED_STATUS);
WaitSet_var ws = new WaitSet;
ws->attach_condition(dw_sc);
Duration_t infinite = {DURATION_INFINITE_SEC, DURATION_INFINITE_NSEC};
ConditionSeq active;
ws->wait(active, infinite);
ws->detach_condition(dw_sc);
}
int run_test(int argc, ACE_TCHAR *argv[])
{
DomainParticipantFactory_var dpf = TheParticipantFactoryWithArgs(argc, argv);
DomainParticipant_var dp =
dpf->create_participant(23, PARTICIPANT_QOS_DEFAULT, 0,
DEFAULT_STATUS_MASK);
MessageTypeSupport_var ts = new MessageTypeSupportImpl;
ts->register_type(dp, "");
Publisher_var pub = dp->create_publisher(PUBLISHER_QOS_DEFAULT, 0,
DEFAULT_STATUS_MASK);
TransportImpl_rch pub_tport =
TheTransportFactory->create_transport_impl(1, AUTO_CONFIG);
PublisherImpl* pub_impl = dynamic_cast<PublisherImpl*>(pub.in());
pub_impl->attach_transport(pub_tport.in());
Subscriber_var sub = dp->create_subscriber(SUBSCRIBER_QOS_DEFAULT, 0,
DEFAULT_STATUS_MASK);
TransportImpl_rch sub_tport =
TheTransportFactory->create_transport_impl(2, AUTO_CONFIG);
SubscriberImpl* sub_impl = dynamic_cast<SubscriberImpl*>(sub.in());
sub_impl->attach_transport(sub_tport.in());
bool passed = run_sorting_test(dp, ts, pub, sub);
passed &= run_filtering_test(dp, ts, pub, sub);
dp->delete_contained_entities();
dpf->delete_participant(dp);
return passed ? 0 : 1;
}
void recreate_data_writer_and_topic(DataWriter_var& dw, const DataReader_var& dr)
{
DataWriterQos dw_qos;
dw->get_qos(dw_qos);
Topic_var topic = dw->get_topic();
TopicQos topic_qos;
topic->get_qos(topic_qos);
CORBA::String_var topic_name = topic->get_name(),
type_name = topic->get_type_name();
Publisher_var pub = dw->get_publisher();
DomainParticipant_var dp = pub->get_participant();
pub->delete_datawriter(dw);
dw = 0;
dp->delete_topic(topic);
topic = 0;
// Wait until the data reader is not associated with the writer.
wait_match (dr, 0);
topic = dp->create_topic(topic_name, type_name, topic_qos, 0, 0);
if (!topic) {
ACE_DEBUG((LM_ERROR, "ERROR: %P failed to re-create topic\n"));
return;
}
dw = pub->create_datawriter(topic, dw_qos, 0, 0);
if (!dw) {
ACE_DEBUG((LM_ERROR, "ERROR: %P failed to re-create data writer\n"));
}
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
try
{
CORBA::ORB_var orb = CORBA::ORB_init (argc, argv);
if (parse_args (argc, argv) != 0)
return 1;
CORBA::Object_var poa_object = orb->resolve_initial_references("RootPOA");
if (CORBA::is_nil (poa_object.in ()))
ACE_ERROR_RETURN ((LM_ERROR,
" (%P|%t) Unable to initialize the POA.\n"),
1);
PortableServer::POA_var root_poa = PortableServer::POA::_narrow (
poa_object.in ());
PortableServer::POAManager_var poa_manager =
root_poa->the_POAManager();
Subscriber_impl subscriber(orb.in ());
PortableServer::ObjectId_var id =
root_poa->activate_object (&subscriber);
CORBA::Object_var object = root_poa->id_to_reference (id.in ());
Subscriber_var subscriber_var = Subscriber::_narrow (object.in ());
object = orb->string_to_object(ior);
Publisher_var publisher = Publisher::_narrow(object.in());
publisher->subscribe(subscriber_var.in());
poa_manager->activate();
ThreadPool pool (orb.in ());
if (pool.activate(THR_NEW_LWP | THR_JOINABLE, 5) != 0)
ACE_ERROR_RETURN ((LM_ERROR,
"Cannot activate client threads\n"),
1);
pool.thr_mgr ()->wait ();
ACE_DEBUG ((LM_DEBUG, "event loop finished\n"));
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Exception caught:");
return 1;
}
return 0;
}
Writer(const Publisher_var& pub, const char* topic_name,
const DomainParticipant_var& other_participant)
: ts_(new typename ::OpenDDS::DCPS::DDSTraits<MessageType>::TypeSupportTypeImpl())
{
DomainParticipant_var dp = pub->get_participant();
check(ts_->register_type(dp, ""));
check(ts_->register_type(other_participant, ""));
CORBA::String_var type_name = ts_->get_type_name();
Topic_var topic = dp->create_topic(topic_name, type_name,
TOPIC_QOS_DEFAULT, 0, DEFAULT_STATUS_MASK);
Topic_var topic2 = other_participant->create_topic(topic_name, type_name,
TOPIC_QOS_DEFAULT, 0, DEFAULT_STATUS_MASK);
dw_ = pub->create_datawriter(topic,
DATAWRITER_QOS_DEFAULT, 0, DEFAULT_STATUS_MASK);
}
DataWriter_var create_data_writer(const DomainParticipant_var& dp2)
{
TypeSupport_var ts = new TestMsgTypeSupportImpl;
if (ts->register_type(dp2, "") != RETCODE_OK) {
ACE_DEBUG((LM_ERROR, "ERROR: %P failed to register type support\n"));
return 0;
}
TopicQos topic_qos;
dp2->get_default_topic_qos(topic_qos);
set_qos(topic_qos.topic_data.value, TestConfig::TOPIC_DATA());
CORBA::String_var type_name = ts->get_type_name();
Topic_var topic = dp2->create_topic("Movie Discussion List",
type_name,
topic_qos,
0,
DEFAULT_STATUS_MASK);
if (!topic) {
ACE_DEBUG((LM_ERROR, "ERROR: %P failed to create topic\n"));
return 0;
}
Publisher_var pub = dp2->create_publisher(PUBLISHER_QOS_DEFAULT,
0,
DEFAULT_STATUS_MASK);
if (!pub) {
ACE_DEBUG((LM_ERROR, "ERROR: %P failed to create publisher\n"));
return 0;
}
DataWriterQos dw_qos;
pub->get_default_datawriter_qos(dw_qos);
set_qos(dw_qos.user_data.value, TestConfig::DATA_WRITER_USER_DATA());
DataWriter_var dw = pub->create_datawriter(topic,
dw_qos,
0,
DEFAULT_STATUS_MASK);
if (!dw) {
ACE_DEBUG((LM_ERROR, "ERROR: %P failed to create data writer\n"));
return 0;
}
return dw;
}
int run_test(int argc, ACE_TCHAR *argv[])
{
using namespace DDS;
using namespace OpenDDS::DCPS;
WaitSet_var ws = new WaitSet;
DomainParticipantFactory_var dpf = TheParticipantFactoryWithArgs(argc, argv);
DomainParticipant_var dp = dpf->create_participant(23,
PARTICIPANT_QOS_DEFAULT, 0, ::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
Messenger::MessageTypeSupport_var ts = new Messenger::MessageTypeSupportImpl;
ts->register_type(dp, ts->get_type_name());
Topic_var topic = dp->create_topic("MyTopic", ts->get_type_name(),
TOPIC_QOS_DEFAULT, 0, ::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
Publisher_var pub = dp->create_publisher(PUBLISHER_QOS_DEFAULT, 0,
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
TransportImpl_rch pub_tport =
TheTransportFactory->create_transport_impl(1, AUTO_CONFIG);
PublisherImpl* pub_impl = dynamic_cast<PublisherImpl*> (pub.in());
pub_impl->attach_transport(pub_tport.in());
DataWriter_var dw = pub->create_datawriter(topic, DATAWRITER_QOS_DEFAULT, 0,
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
StatusCondition_var cond = dw->get_statuscondition();
cond->set_enabled_statuses(OFFERED_INCOMPATIBLE_QOS_STATUS);
ws->attach_condition(cond);
Subscriber_var sub = dp->create_subscriber(SUBSCRIBER_QOS_DEFAULT, 0,
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
TransportImpl_rch sub_tport =
TheTransportFactory->create_transport_impl(2, AUTO_CONFIG);
SubscriberImpl* sub_impl = dynamic_cast<SubscriberImpl*> (sub.in());
sub_impl->attach_transport(sub_tport.in());
DataReaderQos dr_qos;
sub->get_default_datareader_qos(dr_qos);
dr_qos.durability.kind = PERSISTENT_DURABILITY_QOS;
Waiter w(ws);
w.activate();
DataReader_var dr = sub->create_datareader(topic, dr_qos, 0,
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
w.wait();
bool passed = (w.result() == RETCODE_OK);
ws->detach_condition(cond);
dp->delete_contained_entities();
dpf->delete_participant(dp);
return passed ? 0 : 1;
}
int run_test_instance(DDS::DomainParticipant_ptr dp)
{
using namespace DDS;
using namespace OpenDDS::DCPS;
using namespace Messenger;
WaitSet_var ws = new WaitSet;
MessageTypeSupport_var ts = new MessageTypeSupportImpl;
ts->register_type(dp, "");
CORBA::String_var type_name = ts->get_type_name();
Topic_var topic = dp->create_topic("MyTopic", type_name,
TOPIC_QOS_DEFAULT, 0, ::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
Publisher_var pub = dp->create_publisher(PUBLISHER_QOS_DEFAULT, 0,
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
DataWriter_var dw = pub->create_datawriter(topic, DATAWRITER_QOS_DEFAULT, 0,
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
Subscriber_var sub = dp->create_subscriber(SUBSCRIBER_QOS_DEFAULT, 0,
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
DataReader_var dr = sub->create_datareader(topic, DATAREADER_QOS_DEFAULT, 0,
::OpenDDS::DCPS::DEFAULT_STATUS_MASK);
StatusCondition_var dw_sc = dw->get_statuscondition();
dw_sc->set_enabled_statuses(PUBLICATION_MATCHED_STATUS);
ws->attach_condition(dw_sc);
Duration_t infinite = {DURATION_INFINITE_SEC, DURATION_INFINITE_NSEC};
ConditionSeq active;
ReturnCode_t ret = ws->wait(active, infinite);
if (ret != RETCODE_OK) return ret;
ret = ws->detach_condition(dw_sc);
if (ret != RETCODE_OK) return ret;
MessageDataWriter_var mdw = MessageDataWriter::_narrow(dw);
Message msg = {0};
for (int i(0); i < 12; ++i) {
++msg.subject_id;
ret = mdw->write(msg, HANDLE_NIL);
if (ret != RETCODE_OK) return ret;
}
ReadCondition_var dr_rc = dr->create_readcondition(NOT_READ_SAMPLE_STATE,
NEW_VIEW_STATE, ALIVE_INSTANCE_STATE);
ReadCondition_var dr_rc2 = dr->create_readcondition(ANY_SAMPLE_STATE,
ANY_VIEW_STATE, NOT_ALIVE_DISPOSED_INSTANCE_STATE);
ws->attach_condition(dr_rc);
ws->attach_condition(dr_rc2);
MessageDataReader_var mdr = MessageDataReader::_narrow(dr);
bool passed = true, done = false;
while (!done) {
ret = ws->wait(active, infinite);
if (ret != RETCODE_OK) {
passed = false;
break;
}
cout << "wait returned" << endl;
for (CORBA::ULong i(0); i < active.length(); ++i) {
if (active[i] == dr_rc) {
// To test both take_w_condition and
// take_next_instance_w_condition, we'll limit the "take" to 3
// samples and then use take_next_instance_w_condition.
MessageSeq data;
SampleInfoSeq info;
ret = mdr->take_w_condition(data, info, 3, dr_rc);
if (ret == RETCODE_NO_DATA) break;
if (ret != RETCODE_OK) {
cout << "ERROR: take_w_condition returned " << ret << endl;
passed = false;
done = true;
}
InstanceHandle_t handle = HANDLE_NIL;
received_data(data, mdw, msg);
handle = info[info.length() - 1].instance_handle;
if (handle == HANDLE_NIL) {
cout << "ERROR: instance handle is nil" << endl;
passed = false;
done = true;
break;
}
cout << "testing take_instance_w_condition" << endl;
while (true) {
ret = mdr->take_instance_w_condition(data, info, 1,
handle, dr_rc);
if (ret == RETCODE_NO_DATA) break;
if (ret != RETCODE_OK) {
cout << "ERROR: take_instance_w_condition returned "
<< ret << endl;
passed = false;
done = true;
break;
}
received_data(data, mdw, msg);
}
} else if (active[i] == dr_rc2) {
cout << "an instance has been disposed, exiting" << endl;
done = true;
}
}
}
ws->detach_condition(dr_rc);
ws->detach_condition(dr_rc2);
dp->delete_contained_entities();
return passed ? 0 : 1;
}
int
OSPL_MAIN (
int argc,
char *argv[])
{
/* Generic DDS entities */
DomainParticipantFactory_var dpf;
DomainParticipant_var participant;
Topic_var chatMessageTopic;
Publisher_var chatPublisher;
DataWriter_ptr parentWriter;
/* QosPolicy holders */
TopicQos reliable_topic_qos;
PublisherQos pub_qos;
DataWriterQos dw_qos;
/* DDS Identifiers */
DomainId_t domain = 0;
InstanceHandle_t userHandle;
ReturnCode_t status;
/* Type-specific DDS entities */
ChatMessageTypeSupport_var chatMessageTS;
ChatMessageDataWriter_var talker;
/* Sample definitions */
ChatMessage *msg; /* Example on Heap */
/* Others */
int ownID = 1;
int i;
const char *partitionName = "ChatRoom1";
char *chatMessageTypeName = NULL;
char buf[MAX_MSG_LEN];
#ifdef INTEGRITY
#ifdef CHATTER_QUIT
ownID = -1;
#else
ownID = 1;
#endif
#else
/* Options: Chatter [ownID] */
if (argc > 1) {
ownID = atoi(argv[1]);
}
#endif
/* Create a DomainParticipantFactory and a DomainParticipant (using Default QoS settings. */
dpf = DomainParticipantFactory::get_instance ();
checkHandle(dpf.in(), "DDS::DomainParticipantFactory::get_instance");
participant = dpf->create_participant(domain, PARTICIPANT_QOS_DEFAULT, NULL, STATUS_MASK_NONE);
checkHandle(participant.in(), "DDS::DomainParticipantFactory::create_participant");
/* Register the required datatype for ChatMessage. */
chatMessageTS = new ChatMessageTypeSupport();
checkHandle(chatMessageTS.in(), "new ChatMessageTypeSupport");
chatMessageTypeName = chatMessageTS->get_type_name();
status = chatMessageTS->register_type(
participant.in(),
chatMessageTypeName);
checkStatus(status, "NetworkPartitionsData::ChatMessageTypeSupport::register_type");
/* Set the ReliabilityQosPolicy to RELIABLE. */
status = participant->get_default_topic_qos(reliable_topic_qos);
checkStatus(status, "DDS::DomainParticipant::get_default_topic_qos");
reliable_topic_qos.reliability.kind = RELIABLE_RELIABILITY_QOS;
/* Make the tailored QoS the new default. */
status = participant->set_default_topic_qos(reliable_topic_qos);
checkStatus(status, "DDS::DomainParticipant::set_default_topic_qos");
/* Use the changed policy when defining the ChatMessage topic */
chatMessageTopic = participant->create_topic(
"Chat_ChatMessage",
chatMessageTypeName,
reliable_topic_qos,
NULL,
STATUS_MASK_NONE);
checkHandle(chatMessageTopic.in(), "DDS::DomainParticipant::create_topic (ChatMessage)");
/* Adapt the default PublisherQos to write into the "ChatRoom1" Partition. */
status = participant->get_default_publisher_qos (pub_qos);
checkStatus(status, "DDS::DomainParticipant::get_default_publisher_qos");
pub_qos.partition.name.length(1);
pub_qos.partition.name[0] = partitionName;
/* Create a Publisher for the chatter application. */
chatPublisher = participant->create_publisher(pub_qos, NULL, STATUS_MASK_NONE);
checkHandle(chatPublisher.in(), "DDS::DomainParticipant::create_publisher");
/* Create a DataWriter for the ChatMessage Topic (using the appropriate QoS). */
parentWriter = chatPublisher->create_datawriter(
chatMessageTopic.in(),
DATAWRITER_QOS_USE_TOPIC_QOS,
NULL,
STATUS_MASK_NONE);
checkHandle(parentWriter, "DDS::Publisher::create_datawriter (chatMessage)");
/* Narrow the abstract parent into its typed representative. */
talker = ChatMessageDataWriter::_narrow(parentWriter);
checkHandle(talker.in(), "NetworkPartitionsData::ChatMessageDataWriter::_narrow");
/* Initialize the chat messages on Heap. */
msg = new ChatMessage();
checkHandle(msg, "new ChatMessage");
msg->userID = ownID;
msg->index = 0;
if (ownID == TERMINATION_MESSAGE) {
snprintf(buf, MAX_MSG_LEN, "Termination message.");
} else {
snprintf(buf, MAX_MSG_LEN, "Hi there, I will send you %d more messages.", NUM_MSG);
}
msg->content = string_dup(buf);
cout << "Writing message: \"" << msg->content << "\"" << endl;
/* Register a chat message for this user (pre-allocating resources for it!!) */
userHandle = talker->register_instance(*msg);
/* Write a message using the pre-generated instance handle. */
status = talker->write(*msg, userHandle);
checkStatus(status, "NetworkPartitionsData::ChatMessageDataWriter::write");
sleep (1); /* do not run so fast! */
/* Write any number of messages, re-using the existing string-buffer: no leak!!. */
for (i = 1; i <= NUM_MSG && ownID != TERMINATION_MESSAGE; i++) {
msg->index = i;
snprintf(buf, MAX_MSG_LEN, "Message no. %d", i);
msg->content = string_dup(buf);
cout << "Writing message: \"" << msg->content << "\"" << endl;
status = talker->write(*msg, userHandle);
checkStatus(status, "NetworkPartitionsData::ChatMessageDataWriter::write");
sleep (1); /* do not run so fast! */
}
/* Leave the room by disposing and unregistering the message instance. */
status = talker->dispose(*msg, userHandle);
checkStatus(status, "NetworkPartitionsData::ChatMessageDataWriter::dispose");
status = talker->unregister_instance(*msg, userHandle);
checkStatus(status, "NetworkPartitionsData::ChatMessageDataWriter::unregister_instance");
/* Release the data-samples. */
delete msg; // msg allocated on heap: explicit de-allocation required!!
/* Remove the DataWriters */
status = chatPublisher->delete_datawriter( talker.in() );
checkStatus(status, "DDS::Publisher::delete_datawriter (talker)");
/* Remove the Publisher. */
status = participant->delete_publisher( chatPublisher.in() );
checkStatus(status, "DDS::DomainParticipant::delete_publisher");
status = participant->delete_topic( chatMessageTopic.in() );
checkStatus(status, "DDS::DomainParticipant::delete_topic (chatMessageTopic)");
/* Remove the type-names. */
string_free(chatMessageTypeName);
/* Remove the DomainParticipant. */
status = dpf->delete_participant( participant.in() );
checkStatus(status, "DDS::DomainParticipantFactory::delete_participant");
cout << "Completed Chatter example" << endl;
return 0;
}