CORBA::ULong
CDBPropertySet::get_number_of_properties ()
{
ACS_TRACE("baci::CDBPropertySet::get_number_of_properties");
// check if characteristic model is registered
CORBA::String_var objId = getObjectId();
CharacteristicModelImplMap::iterator iter = modelMap.find(objId.in());
if (iter == modelMap.end())
throw CORBA::NO_RESOURCES();
DAONode * node = iter->second->getDAONode();
if (!node)
throw CORBA::NO_RESOURCES();
try
{
CDB::stringSeq_var properties = node->get_string_seq("");
return properties->length();
}
catch (...)
{
throw CORBA::NO_RESOURCES();
}
}
CDB::stringSeq* DAOProxy::get_string_seq (const char * propertyName)
{
//ACS_TRACE("cdb::DAOProxy::get_string_seq");
// check remote mode
if (m_dao.ptr() != CDB::DAO::_nil())
return m_dao->get_string_seq(propertyName);
string value;
try{
get_field(propertyName, value);
}catch(cdbErrType::CDBFieldDoesNotExistExImpl ex){
throw ex.getCDBFieldDoesNotExistEx();
}
VectorString array;
split(value.c_str(), array);
CDB::stringSeq_var seq = new CDB::stringSeq();
seq->length(array.size());
CORBA::ULong i = 0;
for (VectorString::const_iterator iter = array.begin();
iter != array.end(); iter++)
{
seq[i++] = CORBA::string_dup(iter->c_str());
}
return seq._retn();
}
//------------------------------------------------------
CDBProperties::EventHandlerTimeoutMap
CDBProperties::getEventHandlerTimeoutMap(const std::string& channelName)
{
EventHandlerTimeoutMap retVal;
//sanity check
if (cdbChannelConfigExists(channelName)==false)
{
return retVal;
}
//CDB
//complete name of the channel within the CDB
std::string cdbChannelName = "MACI/Channels/" + channelName;
CDB::DAL_var cdbRef = getCDB();
CDB::DAO_var tempDAO = cdbRef->get_DAO_Servant(cdbChannelName.c_str());
CDB::stringSeq_var keys;
//names of all the events
try {
keys = tempDAO->get_string_seq("Events");
}
catch(...){
return retVal;
}
//another sanity check
if (keys.ptr()==0)
{
return retVal;
}
//populate the map
for (CORBA::ULong i=0; i<keys->length(); i++)
{
//get the key's value
std::string timeoutLocation = "Events/";
timeoutLocation = timeoutLocation + (const char*)keys[i] + "/MaxProcessTime";
double value = tempDAO->get_double(timeoutLocation.c_str());
//set the map's contents
retVal[(const char*)keys[i]] = value;
}
return retVal;
}
CDB::stringSeq* DAOImpl::get_string_seq (
const char * propertyName
)
{
Field fld;
if( !get_field(propertyName, fld) )
{
throw CDBFieldDoesNotExistExImpl (
__FILE__, __LINE__,
"DAOImpl::get_long").getCDBFieldDoesNotExistEx();
}
if(fld.GetType() != Field::tyStringArray)
{
throw WrongCDBDataTypeExImpl (
__FILE__, __LINE__,
"DAOImpl::get_long").getWrongCDBDataTypeEx();
}
// create return value
CDB::stringSeq_var retSeq;
ACE_NEW_THROW_EX (retSeq, CDB::stringSeq, CORBA::NO_MEMORY ());
ACE_CHECK_RETURN (0);
StringArray * ary = fld.GetStringArray();
retSeq->length( ary->size() );
CORBA::ULong n=0;
for(StringArray::const_iterator aiter = ary->begin(); aiter != ary->end(); ++aiter)
{
retSeq[n++] = CORBA::string_dup( aiter->c_str() );
}
return retSeq._retn();
}
//-----------------------------------------------------------------------------
char*
BaseHelper::getNotificationFactoryNameForChannel(CDB::DAL_ptr cdbRef, const char* channelName, const char* domainName)
{
//sanity check
if(CORBA::is_nil(cdbRef))
{
ACS_STATIC_SHORT_LOG((LM_DEBUG,
"BaseHelper::getNotificationFactoryNameForChannel",
"CDB ref null."));
return 0;
}
std::string cdbChannelsName = "MACI/Channels";
CDB::DAO_var tempDAO;
//try reading the entry from the CDB
try
{
tempDAO = cdbRef->get_DAO_Servant(cdbChannelsName.c_str());
//sanity check, should not happen
if (tempDAO.in()==0)
return 0;
//DAL throws exceptions if the entry being searched for does not
//exist
}
catch(...)
{
ACS_STATIC_SHORT_LOG((LM_DEBUG,
"BaseHelper::getNotificationFactoryNameForChannel",
"No CDB entry found for '%s' channel. OK.",
cdbChannelsName.c_str()));
return 0;
}
// if channel mapping exists take it, wildchars are also supported
try
{
CDB::stringSeq_var channelNameList = tempDAO->get_string_seq("NotificationServiceMapping/Channels_");
for (CORBA::ULong n = 0; n < channelNameList->length(); n++)
if (Wildcard::wildcardfit(channelNameList[n], channelName))
return CORBA::string_dup(tempDAO->get_string((std::string("NotificationServiceMapping/Channels_/") + channelNameList[n].in() + "/NotificationService").c_str()));
}
catch(...)
{
ACS_STATIC_SHORT_LOG((LM_DEBUG,
"BaseHelper::getNotificationFactoryNameForChannel",
"No Channel to NotificationService mapping found for channel'%s' channel.",
channelName));
}
// if domain mapping, if given
if (domainName)
try
{
return CORBA::string_dup(tempDAO->get_string((std::string("NotificationServiceMapping/Domains/") + domainName + "/NotificationService").c_str()));
}
catch(...)
{
ACS_STATIC_SHORT_LOG((LM_DEBUG,
"BaseHelper::getNotificationFactoryNameForChannel",
"No Domain to NotificationService mapping found for domain/channel'%s/%s' channel. OK.",
domainName, channelName));
}
// if default
try
{
return CORBA::string_dup(tempDAO->get_string("NotificationServiceMapping/DefaultNotificationService"));
}
catch(...)
{
ACS_STATIC_SHORT_LOG((LM_DEBUG,
"BaseHelper::getNotificationFactoryNameForChannel",
"No NotificationServiceMapping/DefaultNotificationService attribute found. OK.",
domainName, channelName));
}
// not found
return 0;
}
void
CDBPropertySet::get_all_properties (CORBA::ULong how_many,
CosPropertyService::Properties_out nproperties,
CosPropertyService::PropertiesIterator_out rest)
{
ACS_TRACE("baci::CDBPropertySet::get_all_properties");
// Allocate memory for the out parameter.
ACE_NEW (nproperties,
CosPropertyService::Properties);
// check if characteristic model is registered
CORBA::String_var objId = getObjectId();
CharacteristicModelImplMap::iterator iter = modelMap.find(objId.in());
if (iter == modelMap.end())
throw CORBA::NO_RESOURCES();
DAONode * node = iter->second->getDAONode();
if (!node)
throw CORBA::NO_RESOURCES();
CDB::stringSeq_var properties;
try
{
properties = node->get_string_seq("");
}
catch (...)
{
throw CORBA::NO_RESOURCES();
}
// Validate the length.
CORBA::ULong numOfProperties = properties->length();
if (numOfProperties == 0)
{
// Nothing to do.
return;
}
// Set the length for the nproperties if how_many > 0.
CORBA::ULong sequenceLength = 0UL;
if (how_many > 0)
{
if (how_many >= numOfProperties)
{
sequenceLength = numOfProperties;
}
else
{
sequenceLength = how_many;
}
nproperties->length(sequenceLength);
}
// Prepare an iterator and iterate through the PropertySet. Retrive
// the values.
CORBA::Any anyval;
CORBA::ULong ni = 0UL;
for (; ni < sequenceLength;
ni++)
{
nproperties[ni].property_name = CORBA::string_dup (properties[ni].in());
try
{
CORBA::String_var strVal = node->get_string(properties[ni].in());
anyval <<= strVal.in();
nproperties[ni].property_value = anyval;
}
catch (...)
{
CORBA::Any voidany;
voidany.type(CORBA::_tc_void);
nproperties[ni].property_value = voidany; //CORBA::Any(CORBA::_tc_void);
}
}
// If there are more properties, put them in the <PropertiesIterator>.
// Make a new <TAO_PropertySet> and use that to create an Properties
// iterator. put that in a iterator and assign that to the out
// paramerter.
if (numOfProperties > how_many)
{
TAO_PropertySet *propSet_p=0;
ACE_NEW (propSet_p, TAO_PropertySet);
for (CORBA::ULong i = how_many;
i < numOfProperties;
i++, ni++)
{
try
{
CORBA::String_var strVal = node->get_string(properties[ni].in());
anyval <<= strVal.in();
propSet_p->define_property(properties[ni].in(), anyval);
}
catch (...)
{
CORBA::Any voidany;
voidany.type(CORBA::_tc_void);
propSet_p->define_property(properties[ni].in(), voidany /*CORBA::Any(CORBA::_tc_void)*/);
}
}
// Make the iterator out of the new TAO_Propset.
TAO_PropertiesIterator *iterator_p = 0;
ACE_NEW (iterator_p,
TAO_PropertiesIterator (*propSet_p));
// Init the out parameter.
// Get the interface ptr.
CosPropertyService::PropertiesIterator_ptr iterator2_p =
iterator_p->_this ();
// POA stuff todo here, since we have <destroy> method in the
// <NamesIterator> interface.
// Give ownership of this servant to the POA.
iterator_p->_remove_ref ();
// Init the out parameter.
rest = iterator2_p;
}
}
void
CDBPropertySet::get_all_property_names (CORBA::ULong how_many,
CosPropertyService::PropertyNames_out property_names,
CosPropertyService::PropertyNamesIterator_out rest)
{
ACS_TRACE("baci::CDBPropertySet::get_all_property_names");
// Allocating storage is a must.
ACE_NEW (property_names,
CosPropertyService::PropertyNames);
// check if characteristic model is registered
CORBA::String_var objId = getObjectId();
CharacteristicModelImplMap::iterator iter = modelMap.find(objId.in());
if (iter == modelMap.end())
throw CORBA::NO_RESOURCES();
DAONode * node = iter->second->getDAONode();
if (!node)
throw CORBA::NO_RESOURCES();
CDB::stringSeq_var properties;
try
{
properties = node->get_string_seq("");
}
catch (...)
{
throw CORBA::NO_RESOURCES();
}
// Validate the length.
CORBA::ULong numOfProperties = properties->length();
if (numOfProperties == 0)
{
// Nothing to do.
return;
}
// Set the length of the property_names appropriately.
CORBA::ULong sequenceLength = 0UL;
if (how_many > 0)
{
if (how_many >= numOfProperties)
{
sequenceLength = numOfProperties;
}
else
{
sequenceLength = how_many;
}
property_names->length (sequenceLength);
}
// Iterate thru names and put them in the property_names.
CORBA::ULong ni = 0UL;
for (; ni < sequenceLength;
ni++)
{
property_names [ni] = CORBA::string_dup (properties[ni].in());
}
// If there are some more properties, put them in the
// iterator. How?? Make a new PropertySet and use that to create
// propertyNames Iterator.
if (numOfProperties > how_many)
{
TAO_PropertySet *propertySet_p=0;
ACE_NEW (propertySet_p, TAO_PropertySet);
CORBA::Any anyval;
anyval.type(CORBA::_tc_void);
for (CORBA::ULong i = how_many;
i < numOfProperties;
i++, ni++)
{
propertySet_p->define_property(properties[ni].in(), anyval);
}
// Make the NamesIterator out of this TAO_PropertySet.
TAO_PropertyNamesIterator *namesIterator_p=0;
ACE_NEW (namesIterator_p, TAO_PropertyNamesIterator (*propertySet_p));
// Init the out parameter.
// Get the Interface ptr.
CosPropertyService::PropertyNamesIterator_ptr iterator_p =
namesIterator_p->_this ();
// POA stuff todo here, since we have <destroy> method in the
// <NamesIterator> interface.
// Give ownership of this servant to the POA.
namesIterator_p->_remove_ref ();
// Init the out parameter.
rest = iterator_p;
}
}
