void
DDS_Write_T<CCM_TYPE, TYPED_WRITER, VALUE_TYPE, SEQ_VALUE_TYPE>::configuration_complete (
::DDS::Topic_ptr topic,
::DDS::Publisher_ptr publisher,
const char * qos_profile,
DDS_XML_QOS_PARSER_TYPE* qos_xml)
{
DDS4CCM_TRACE ("DDS_Write_T<CCM_TYPE, TYPED_WRITER, VALUE_TYPE, SEQ_VALUE_TYPE>::configuration_complete");
::DDS::DataWriter_var dw = this->dds_write_->get_dds_writer ();
if (::CORBA::is_nil (dw.in ()))
{
::DDS::DataWriter_var dwv_tmp;
#if (CIAO_DDS4CCM_NDDS==1)
if (qos_profile)
{
dwv_tmp = publisher->create_datawriter_with_profile (
topic,
qos_profile,
::DDS::DataWriterListener::_nil (),
0);
}
else
#endif
{
::DDS::DataWriterQos dwqos;
DDS::ReturnCode_t const retcode =
publisher->get_default_datawriter_qos (dwqos);
if (retcode != DDS::RETCODE_OK)
{
DDS4CCM_ERROR (DDS4CCM_LOG_LEVEL_ERROR, (LM_ERROR, DDS4CCM_INFO
"DDS_Write_T::configuration_complete - "
"Error: Unable to retrieve get_default_datawriter_qos: <%C>\n",
::CIAO::DDS4CCM::translate_retcode (retcode)));
throw ::CCM_DDS::InternalError (retcode, 0);
}
if (qos_profile && qos_xml)
{
CORBA::String_var name = topic->get_name ();
DDS::ReturnCode_t const retcode_dw_qos = qos_xml->get_datawriter_qos (
dwqos,
qos_profile,
name.in ());
if (retcode_dw_qos != DDS::RETCODE_OK)
{
DDS4CCM_ERROR (DDS4CCM_LOG_LEVEL_ERROR, (LM_ERROR, DDS4CCM_INFO
"DDS_Write_T::configuration_complete - "
"Error: Unable to retrieve datawriter QOS from XML: <%C>\n",
::CIAO::DDS4CCM::translate_retcode (retcode_dw_qos)));
throw ::CCM_DDS::InternalError (retcode_dw_qos, 0);
}
}
#if defined GEN_OSTREAM_OPS
if (DDS4CCM_debug_level >= DDS4CCM_LOG_LEVEL_DDS_STATUS)
{
std::stringstream output;
output << dwqos;
std::string message = output.str();
DDS4CCM_DEBUG (DDS4CCM_LOG_LEVEL_DDS_STATUS, (LM_INFO, DDS4CCM_INFO
ACE_TEXT ("DDS_Update_T::configuration_complete - ")
ACE_TEXT ("Using datawriter QOS <%C>\n"), message.c_str()));
}
#endif
dwv_tmp = publisher->create_datawriter (
topic,
dwqos,
::DDS::DataWriterListener::_nil (),
0);
}
if (!::CORBA::is_nil (dwv_tmp.in ()))
{
DDS4CCM_DEBUG (DDS4CCM_LOG_LEVEL_ACTION, (LM_TRACE, DDS4CCM_INFO
"DDS_Write_T::configuration_complete - "
"Created datawriter "
DDS_ENTITY_FORMAT_SPECIFIER
" using publisher "
DDS_ENTITY_FORMAT_SPECIFIER
"\n",
DDS_ENTITY_LOG (dwv_tmp.in ()),
DDS_ENTITY_LOG (publisher)));
}
else
{
DDS4CCM_ERROR (DDS4CCM_LOG_LEVEL_DDS_NIL_RETURN, (LM_ERROR, DDS4CCM_INFO
"DDS_Write_T::configuration_complete - "
"Error: DDS returned a nil datawriter.\n"));
throw ::CORBA::INTERNAL ();
}
this->dds_write_->set_dds_writer (dwv_tmp.in ());
this->ccm_data_writer_->set_dds_entity (dwv_tmp.in ());
DDS::ReturnCode_t const retcode = dwv_tmp->enable ();
if (retcode != ::DDS::RETCODE_OK)
{
DDS4CCM_ERROR (DDS4CCM_LOG_LEVEL_ERROR, (LM_ERROR, DDS4CCM_INFO
"DDS_Write_T::configuration_complete - "
"Error: Unable to enable the datawriter: <%C>\n",
::CIAO::DDS4CCM::translate_retcode (retcode)));
throw ::CORBA::INTERNAL ();
}
}
}
void
DDS_Base_Connector_T<CCM_TYPE>::passivate_publisher (
::DDS::Publisher_ptr publisher,
::DDS::PublisherListener_ptr publisher_listener)
{
DDS4CCM_TRACE ("DDS_Base_Connector_T::passivate_publisher");
if (!::CORBA::is_nil (publisher_listener))
{
DDS4CCM_DEBUG (DDS4CCM_LOG_LEVEL_ACTION, (LM_DEBUG, DDS4CCM_INFO
"DDS_Base_Connector_T::passivate_publisher - "
"Setting the listener on the publisher to nil\n"));
DDS::ReturnCode_t const retcode =
publisher->set_listener (::DDS::PublisherListener::_nil (), 0);
if (retcode != ::DDS::RETCODE_OK)
{
DDS4CCM_ERROR (DDS4CCM_LOG_LEVEL_ERROR, (LM_ERROR, DDS4CCM_INFO
"DDS_Base_Connector_T::passivate_publisher - "
"Error while setting the listener on the publisher - <%C>\n",
::CIAO::DDS4CCM::translate_retcode (retcode)));
throw ::CORBA::INTERNAL ();
}
}
}
DDS::DataWriter_ptr
MonitorFactoryImpl::create_data_writer(DDS::DomainParticipant_ptr participant,
DDS::Publisher_ptr publisher,
const char* type_name,
const char* topic_name,
const DDS::DataWriterQos& dw_qos)
{
DDS::Topic_var topic =
participant->create_topic(topic_name,
type_name,
TOPIC_QOS_DEFAULT,
DDS::TopicListener::_nil(),
OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil(topic)) {
ACE_DEBUG((LM_DEBUG, "MonitorFactoryImpl::create_data_writer(): Failed to create topic, name = %s\n", topic_name));
}
DDS::DataWriter_var writer =
publisher->create_datawriter(topic.in(),
dw_qos,
DDS::DataWriterListener::_nil(),
OpenDDS::DCPS::DEFAULT_STATUS_MASK);
if (CORBA::is_nil(writer)) {
ACE_DEBUG((LM_DEBUG, "MonitorFactoryImpl::create_data_writer(): Failed to create data writer\n"));
}
return writer._retn();
}
void
DDS_Write_T<CCM_TYPE, TYPED_WRITER, VALUE_TYPE, SEQ_VALUE_TYPE>::remove (
::DDS::Publisher_ptr publisher)
{
DDS4CCM_TRACE ("DDS_Write_T<CCM_TYPE, TYPED_WRITER, VALUE_TYPE, SEQ_VALUE_TYPE>::remove");
::DDS::DataWriter_var writer = this->dds_write_->get_dds_writer ();
this->dds_write_->set_dds_writer (::DDS::DataWriter::_nil ());
this->ccm_data_writer_->set_dds_entity (::DDS::DataWriter::_nil ());
if (!::CORBA::is_nil (writer.in ()))
{
DDS4CCM_DEBUG (DDS4CCM_LOG_LEVEL_ACTION_STARTING, (LM_TRACE, DDS4CCM_INFO
"DDS_Write_T::remove - "
"Going to delete DataWriter "
DDS_ENTITY_FORMAT_SPECIFIER
" from publisher "
DDS_ENTITY_FORMAT_SPECIFIER
"\n",
DDS_ENTITY_LOG (writer.in ()),
DDS_ENTITY_LOG (publisher)));
DDS::ReturnCode_t const retval =
publisher->delete_datawriter (writer.in ());
if (retval != ::DDS::RETCODE_OK)
{
DDS4CCM_ERROR (DDS4CCM_LOG_LEVEL_ERROR, (LM_ERROR, DDS4CCM_INFO
"DDS_Write_T::remove - "
"Unable to delete DataWriter: <%C>\n",
::CIAO::DDS4CCM::translate_retcode (retval)));
throw ::CORBA::INTERNAL ();
}
else
{
DDS4CCM_DEBUG (DDS4CCM_LOG_LEVEL_DDS_STATUS, (LM_INFO, DDS4CCM_INFO
"DDS_Write_T::remove - "
"Deleted DataWriter: <%C>\n",
::CIAO::DDS4CCM::translate_retcode (retval)));
}
}
}
void
DDS_Base_Connector_T<CCM_TYPE>::activate_publisher (
ACE_Reactor* reactor,
::DDS::Publisher_ptr publisher,
::DDS::PublisherListener_ptr & publisher_listener)
{
DDS4CCM_TRACE ("DDS_Base_Connector_T::activate_publisher");
::CCM_DDS::ConnectorStatusListener_var error_listener =
this->context_->get_connection_error_listener ();
::DDS::StatusMask const mask =
::CIAO::DDS4CCM::PublisherListener::get_mask (error_listener.in ());
if (mask != 0)
{
if (::CORBA::is_nil (publisher_listener))
{
ACE_NEW_THROW_EX (publisher_listener,
::CIAO::DDS4CCM::PublisherListener (
error_listener.in (),
reactor),
::CORBA::NO_MEMORY ());
}
DDS::ReturnCode_t const retcode = publisher->set_listener (publisher_listener,
mask);
if (retcode != ::DDS::RETCODE_OK)
{
DDS4CCM_ERROR (DDS4CCM_LOG_LEVEL_ERROR, (LM_ERROR, DDS4CCM_INFO
"DDS_Base_Connector_T::activate_publisher - "
"Error while setting the listener on the publisher - <%C>\n",
::CIAO::DDS4CCM::translate_retcode (retcode)));
throw ::CORBA::INTERNAL ();
}
}
}
DDS::Streams::StreamDataWriter_impl::StreamDataWriter_impl(
DDS::Publisher_ptr publisher_in,
DDS::DomainId_t domainId,
DDS::Streams::StreamDataWriterQos &qos_in,
DDS::TypeSupport_ptr typeSupport,
const char *streamName)
{
DDS::DomainParticipant_var myParticipant;
DDS::Publisher_var myPublisher;
DDS::String_var typeName;
DDS::ReturnCode_t result;
assert(typeSupport);
assert(streamName);
assert(domainId);
if(!publisher_in) {
os_mutexLock(&classLock.lfMutex);
if (this->nrParticipantUsers == 0) {
myParticipant = DDS::DomainParticipantFactory::get_instance()->create_participant(domainId, PARTICIPANT_QOS_DEFAULT, NULL, 0);
if (myParticipant) {
this->participant = myParticipant;
nrParticipantUsers = 1;
} else {
OS_REPORT(OS_ERROR, "DDS::Streams::StreamDataWriter_impl", 0, "Failed to create internal participant");
os_mutexUnlock(&classLock.lfMutex);
throw StreamsException("Failed to create internal participant. Is the domain running?", DDS::RETCODE_PRECONDITION_NOT_MET);
}
} else {
myParticipant = this->participant;
nrParticipantUsers++;
}
myPublisher = myParticipant->create_publisher(DDS::Streams::default_publisher_qos, NULL, 0);
if (myPublisher) {
publisher = myPublisher;
} else {
OS_REPORT(OS_ERROR, "DDS::Streams::StreamDataWriter_impl", 0, "Failed to create internal publisher");
os_mutexUnlock(&classLock.lfMutex);
throw StreamsException("Failed to create internal publisher", DDS::RETCODE_PRECONDITION_NOT_MET);
}
os_mutexUnlock(&classLock.lfMutex);
} else {
publisher = NULL;
myParticipant = publisher_in->get_participant();
if (myParticipant == NULL) {
OS_REPORT(OS_ERROR, "DDS::Streams::StreamDataWriter_impl", 0, "Failed to get participant");
throw StreamsException("Failed to get participant. Is the domain running?", DDS::RETCODE_PRECONDITION_NOT_MET);
}
}
typeName = typeSupport->get_type_name();
result = typeSupport->register_type(myParticipant, typeName);
/* TypeSupport is released here because caller is the parent constructor which cannot release it in the member init list */
release(typeSupport);
if (result != DDS::RETCODE_OK) {
OS_REPORT(OS_ERROR, "DDS::Streams::StreamDataWriter_impl", 0, "Failed to register streams topic for type %s", typeName.in());
throw StreamsException("Failed to register streams topic", result);
}
topic = myParticipant->create_topic(streamName, typeName, DDS::Streams::default_topic_qos, NULL, 0);
if (!topic.in()) {
OS_REPORT(OS_ERROR, "DDS::Streams::StreamDataWriter_impl", 0, "Failed to create topic %s", streamName);
throw StreamsException("Failed to create streams topic", result);
}
/* Check if QoS is valid */
if ((qos_in.flush.max_delay.sec < 0) ||
((qos_in.flush.max_delay.sec == 0) &&
(qos_in.flush.max_delay.nanosec == 0))) {
throw StreamsException("Invalid QoS: auto-flush delay is not a valid duration", DDS::RETCODE_BAD_PARAMETER);
} else if ((qos_in.flush.max_samples <= 0) ||
(qos_in.flush.max_samples == DDS::LENGTH_UNLIMITED)) {
throw StreamsException("Invalid QoS: auto-flush sample limit must be a positive number and cannot be DDS::LENGTH_UNLIMITED", DDS::RETCODE_BAD_PARAMETER);
} else {
qos = qos_in;
}
}