void _checkUint16Property
(CIMInstance & instance, const String & name, Uint16 value)
{
Uint32 pos = instance.findProperty (name);
PEGASUS_TEST_ASSERT (pos != PEG_NOT_FOUND);
CIMProperty theProperty = instance.getProperty (pos);
CIMValue theValue = theProperty.getValue ();
PEGASUS_TEST_ASSERT (theValue.getType () == CIMTYPE_UINT16);
PEGASUS_TEST_ASSERT (!theValue.isArray ());
PEGASUS_TEST_ASSERT (!theValue.isNull ());
Uint16 result;
theValue.get (result);
if (verbose)
{
if (result != value)
{
cerr << "Property value comparison failed. ";
cerr << "Expected " << value << "; ";
cerr << "Actual property value was " << result << "." << endl;
}
}
PEGASUS_TEST_ASSERT (result == value);
}
void setPropertyValue(CIMInstance& instance, const CIMName& propertyName,
const Uint32 value)
{
Uint32 pos;
PEGASUS_ASSERT(pos = instance.findProperty(propertyName) != PEG_NOT_FOUND);
instance.getProperty(pos).setValue(CIMValue(value));
}
/**
***************************************************************************
_filterAssociationInstances is used to filter the set of possible return
instances against the filters (resultClass and resultRole) provided with
the associators and associatorNames operations. It returns the ObjectPaths
of the set of objects that pass the filter tests.
@param assocInstance - The target association class instance
@param sourceObjectPath - The source ObjectPath
@param resultClass - The result class. If there is no resultClass,
this is String::EMPTY.
@param resultRole - The result role. If there is no role, this is
String::EMPTY
@return the ObjectPaths of the set of association instances that pass
the filter tests.
***************************************************************************
*/
Array<CIMObjectPath> RUEpProvider::_filterAssociationInstances(
CIMInstance& assocInstance,
const CIMObjectPath& sourceObjectPath,
CIMName resultClass,
String resultRole)
{
Array<CIMObjectPath> returnPaths;
// get all Reference properties
for (Uint32 i = 0, n = assocInstance.getPropertyCount(); i < n; i++)
{
CIMProperty p = assocInstance.getProperty(i);
if (p.getType() == CIMTYPE_REFERENCE)
{
CIMValue v = p.getValue();
CIMObjectPath path;
v.get(path);
if (!sourceObjectPath.identical(path))
{
if (resultClass.isNull() || resultClass == path.getClassName())
{
if (resultRole == String::EMPTY ||
(p.getName() == CIMName(resultRole)))
{
returnPaths.append(path);
}
}
}
}
}
return returnPaths;
}
static void checkBlocked(CIMInstance &pm)
{
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "checkBlocked");
Array<Uint16> operationalStatus;
Uint32 pos = pm.findProperty(CIMName ("OperationalStatus"));
if(pos == PEG_NOT_FOUND) {
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
"OperationalStatus not found.");
PEG_METHOD_EXIT();
//l10n
//throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, "provider lookup failed.");
throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED, MessageLoaderParms(
"ProviderManager.ProviderManagerService.PROVIDER_LOOKUP_FAILED",
"provider lookup failed."));
}
pm.getProperty(pos).getValue().get(operationalStatus);
for(Uint32 i = 0; i < operationalStatus.size(); i++) {
if(operationalStatus[i] == _MODULE_STOPPED ||
operationalStatus[i] == _MODULE_STOPPING) {
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
"Provider blocked.");
PEG_METHOD_EXIT();
//l10n
//throw PEGASUS_CIM_EXCEPTION(CIM_ERR_ACCESS_DENIED, "provider blocked.");
throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_ACCESS_DENIED, MessageLoaderParms(
"ProviderManager.ProviderManagerService.PROVIDER_BLOCKED",
"provider blocked."));
}
}
}
CIMInstance CIMClient::getInstance(
const CIMNamespaceName& nameSpace,
const CIMObjectPath& instanceName,
Boolean localOnly,
Boolean includeQualifiers,
Boolean includeClassOrigin,
const CIMPropertyList& propertyList)
{
CIMInstance inst = _rep->getInstance(
nameSpace,
instanceName,
localOnly,
includeQualifiers,
includeClassOrigin,
propertyList).getInstance();
if (!inst.isUninitialized())
{
// remove key bindings, name space and host name form object path.
CIMObjectPath& p =
const_cast<CIMObjectPath&>(inst.getPath());
CIMName cls = p.getClassName();
p.clear();
p.setClassName(cls);
}
return inst;
}
void testUserContextPrivileged()
{
try
{
CIMClient client;
client.connectLocal();
// Test a provider running in Privileged user context
CIMObjectPath instName =
CIMObjectPath("TST_UserContextPrivileged.Id=1");
// ATTN: use of the localOnly flag is deprecated, but nor reliably
// applied by the CIMOM. An explicit parameter is required for now.
CIMInstance cimInstance =
client.getInstance(NAMESPACE, instName, false);
String userContext;
cimInstance.getProperty(cimInstance.findProperty("UserContext"))
.getValue().get(userContext);
if (verbose)
{
cout << "Privileged test: UserContext = " << userContext << endl;
}
PEGASUS_TEST_ASSERT(userContext == testUserContext);
}
catch (Exception& e)
{
cerr << "Error: " << e.getMessage() << endl;
exit(1);
}
}
CIMValue CIMHelper::getPropertyValue(const CIMInstance &instanceObject, String name)
{
CIMName cname(name);
Uint32 index = instanceObject.findProperty(cname);
if (index == PEG_NOT_FOUND) return CIMValue();
CIMConstProperty property = instanceObject.getProperty(index);
return property.getValue();
}
void CIMExportClient::exportIndication(
const String& url,
const CIMInstance& instanceName,
const ContentLanguageList& contentLanguages)
{
PEG_METHOD_ENTER (TRC_EXPORT_CLIENT, "CIMExportClient::exportIndication()");
try
{
// encode request
CIMRequestMessage* request = new CIMExportIndicationRequestMessage(
String::EMPTY,
url,
instanceName,
QueueIdStack(),
String::EMPTY,
String::EMPTY);
request->operationContext.set
(ContentLanguageListContainer(contentLanguages));
PEG_TRACE ((TRC_INDICATION_GENERATION, Tracer::LEVEL4,
"Exporting %s Indication for destination %s:%d%s",
(const char*)(instanceName.getClassName().getString().
getCString()),
(const char*)(_connectHost.getCString()), _connectPortNumber,
(const char*)(url.getCString())));
Message* message = _doRequest(request,
CIM_EXPORT_INDICATION_RESPONSE_MESSAGE);
PEG_TRACE ((TRC_INDICATION_GENERATION, Tracer::LEVEL4,
"%s Indication for destination %s:%d%s exported successfully",
(const char*)(instanceName.getClassName().getString().
getCString()),
(const char*)(_connectHost.getCString()), _connectPortNumber,
(const char*)(url.getCString())));
CIMExportIndicationResponseMessage* response =
(CIMExportIndicationResponseMessage*)message;
AutoPtr<CIMExportIndicationResponseMessage> ap(response);
}
catch (const Exception& e)
{
PEG_TRACE((TRC_DISCARDED_DATA, Tracer::LEVEL1,
"Failed to export indication: %s",
(const char*)e.getMessage().getCString()));
throw;
}
catch (...)
{
PEG_TRACE_CSTRING (TRC_DISCARDED_DATA, Tracer::LEVEL1,
"Failed to export indication");
throw;
}
PEG_METHOD_EXIT();
}
static Boolean _checkValue(
CIMInstance &instance,
const String &prop,
T value)
{
T lvalue;
instance.getProperty(instance.findProperty(prop)).getValue().get(lvalue);
return lvalue == value;
}
void _testPropertyValue(
CIMInstance& instance,
const CIMName& propertyName,
const CIMValue & testValue)
{
CIMValue value =
instance.getProperty(instance.findProperty(propertyName)).getValue();
PEGASUS_TEST_ASSERT(testValue == value);
}
/**
gatherProperties method of the nisinfo Test Client
*/
void NISInfo::gatherProperties(CIMInstance &inst)
{
#ifdef DEBUG
cout << "NISInfo::gatherProperties()" << endl;
#endif
// don't have a try here - want it to be caught by caller
// loop through the properties
for (Uint32 j=0; j < inst.getPropertyCount(); j++)
{
CIMName propertyName = inst.getProperty(j).getName();
// only pull out those properties of interest (do not remove)
if (propertyName.equal (CIMName ("SystemCreationClassName")))
{
inst.getProperty(j).getValue().get(nisSystemCreationClassName);
} // end if SystemCreationClassName
if (propertyName.equal (CIMName ("SystemName")))
{
inst.getProperty(j).getValue().get(nisSystemName);
} // end if SystemName
if (propertyName.equal (CIMName ("CreationClassName")))
{
inst.getProperty(j).getValue().get(nisCreationClassName);
} // end if CreationClassName
if (propertyName.equal (CIMName ("Name")))
{
inst.getProperty(j).getValue().get(nisName);
} // end if Name
if (propertyName.equal (CIMName ("Caption")))
{
inst.getProperty(j).getValue().get(nisCaption);
} // end if Caption
if (propertyName.equal (CIMName ("Description")))
{
inst.getProperty(j).getValue().get(nisDescription);
} // end if Description
if (propertyName.equal (CIMName ("ServerType")))
{
inst.getProperty(j).getValue().get(nisServerType);
} // end if ServerType
if (propertyName.equal (CIMName ("ServerWaitFlag")))
{
inst.getProperty(j).getValue().get(nisServerWaitFlag);
} // end if ServerWaitFlag
} // end of for looping through properties
}
Boolean _propertyIdentical(
const char* propertyName,
CIMInstance& instance1,
CIMInstance& instance2)
{
Uint32 pos = instance1.findProperty(propertyName);
CIMConstProperty p1 = instance1.getProperty(pos);
pos = instance2.findProperty(propertyName);
CIMConstProperty p2 = instance2.getProperty(pos);
return (p1.identical(p2));
}
/**
gatherProperties method of the dnsinfo Test Client
*/
void DNSInfo::gatherProperties(CIMInstance &inst, Boolean cimFormat)
{
#ifdef DEBUG
cout << "DNSInfo::gatherProperties()" << endl;
#endif
// don't have a try here - want it to be caught by caller
// loop through the properties
for (Uint32 j=0; j < inst.getPropertyCount(); j++)
{
CIMName propertyName = inst.getProperty(j).getName();
// only pull out those properties of interest
if (propertyName.equal (CIMName ("SystemName")))
{
inst.getProperty(j).getValue().get(dnsSystemName);
} // end if SystemName
if (propertyName.equal (CIMName ("SystemCreationClassName")))
{
inst.getProperty(j).getValue().get(dnsSystemCreationClassName);
} // end if SystemCreationClassName
if (propertyName.equal (CIMName ("Name")))
{
inst.getProperty(j).getValue().get(dnsName);
} // end if Name
if (propertyName.equal (CIMName ("CreationClassName")))
{
inst.getProperty(j).getValue().get(dnsCreationClassName);
} // end if CreationClassName
if (propertyName.equal (CIMName ("Caption")))
{
inst.getProperty(j).getValue().get(dnsCaption);
} // end if Caption
if (propertyName.equal (CIMName ("Description")))
{
inst.getProperty(j).getValue().get(dnsDescription);
} // end if Description
if (propertyName.equal (CIMName ("SearchList")))
{
inst.getProperty(j).getValue().get(dnsSearchList);
} // end if SearchList
if (propertyName.equal (CIMName ("Addresses")))
{
inst.getProperty(j).getValue().get(dnsAddresses);
} // end if ServerAddress
} // end of for looping through properties
}
bool setPropertyValue(CIMInstance& instance, const CIMName& propertyName,
const CIMValue & value)
{
unsigned int pos = instance.findProperty(propertyName);
if(pos != PEG_NOT_FOUND)
{
instance.getProperty(pos).setValue(value);
return true;
}
return false;
}
CIMObjectPath _createHandler
(CIMClient & client,
const String & name,
const String & destination)
{
CIMInstance handler (HANDLER_CLASSNAME);
handler.addProperty (CIMProperty (CIMName ("Name"), name));
handler.addProperty (CIMProperty (CIMName ("Destination"), destination));
CIMObjectPath path = client.createInstance (INTEROPNAMESPACE, handler);
return path;
}
/////////////////////////////////////////////////////////////////////////////
// WMIInstanceProvider::getProperty
//
// ///////////////////////////////////////////////////////////////////////////
CIMValue WMIInstanceProvider::getProperty(
const String& nameSpace,
const String& userName,
const String& password,
const CIMObjectPath& instanceName,
const String& propertyName)
{
CIMInstance cimInstance;
Array<CIMName> propertyNames;
PEG_METHOD_ENTER(TRC_WMIPROVIDER,"WMIInstanceProvider::getProperty()");
setup(nameSpace,userName,password);
if (!m_bInitialized)
{
throw CIMException(CIM_ERR_FAILED, "[getProperty] m_bInitialized");
}
CIMName propName = propertyName;
propertyNames.append(propName);
CIMPropertyList propertyList = CIMPropertyList(propertyNames);
// get the relevant CIMInstance object
cimInstance = getCIMInstance(nameSpace,
userName,
password,
instanceName,
propertyList);
// now fetch the property
Uint32 pos = cimInstance.findProperty(propName);
if (PEG_NOT_FOUND == pos)
{
throw CIMException(CIM_ERR_NO_SUCH_PROPERTY,
"[getProperty] findproperty");
}
CIMProperty property = cimInstance.getProperty(pos);
// and return the value
CIMValue value = property.getValue();
PEG_METHOD_EXIT();
return value;
}
void CIMError::setInstance(const CIMInstance& instance)
{
for (Uint32 i = 0; i < instance.getPropertyCount(); i++)
{
CIMConstProperty p = instance.getProperty(i);
_Check("ErrorType", p, (Uint16*)0);
_Check("OtherErrorType", p, (String*)0);
_Check("OwningEntity", p, (String*)0);
_Check("MessageID", p, (String*)0);
_Check("Message", p, (String*)0);
_Check("MessageArguments", p, (Array<String>*)0);
_Check("PerceivedSeverity", p, (Uint16*)0);
_Check("ProbableCause", p, (Uint16*)0);
_Check("ProbableCauseDescription", p, (String*)0);
_Check("RecommendedActions", p, (Array<String>*)0);
_Check("ErrorSource", p, (String*)0);
_Check("ErrorSourceFormat", p, (Uint16*)0);
_Check("OtherErrorSourceFormat", p, (String*)0);
_Check("CIMStatusCode", p, (Uint32*)0);
_Check("CIMStatusCodeDescription", p, (String*)0);
}
// Verify that the instance contains all of the required properties.
for (Uint32 i = 0; i < _numRequiredProperties; i++)
{
// Does inst have this property?
Uint32 pos = instance.findProperty(_requiredProperties[i]);
if (pos == PEG_NOT_FOUND)
{
char buffer[80];
sprintf(buffer, "required property does not exist: %s",
_requiredProperties[i]);
throw CIMException(CIM_ERR_NO_SUCH_PROPERTY, buffer);
}
// is required property non-null?
CIMConstProperty p = instance.getProperty(pos);
CIMValue v = p.getValue();
if (v.isNull())
{
char buffer[80];
sprintf(buffer, "required property MUST NOT be Null: %s",
_requiredProperties[i]);
throw CIMException(CIM_ERR_FAILED, buffer);
}
}
_inst = instance;
}
static CIMValue _getPropertyValue(const CIMInstance & cimInstance, const String & propertyName)
{
CIMValue value;
Uint32 pos = 0;
// get ClassName property
if((pos = cimInstance.findProperty(propertyName)) != PEG_NOT_FOUND)
{
value = cimInstance.getProperty(pos).getValue();
}
return(value);
}
void _getKeyValue (
const CIMInstance& namespaceInstance,
CIMNamespaceName& childNamespaceName,
Boolean& isRelativeName)
{
//Validate key property
Uint32 pos;
CIMValue propertyValue;
// [Key, MaxLen (256), Description (
// "A string that uniquely identifies the Namespace "
// "within the ObjectManager.") ]
// string Name;
pos = namespaceInstance.findProperty(NAMESPACE_PROPERTYNAME);
if (pos == PEG_NOT_FOUND)
{
throw CIMPropertyNotFoundException
(NAMESPACE_PROPERTYNAME.getString());
}
propertyValue = namespaceInstance.getProperty(pos).getValue();
if (propertyValue.getType() != CIMTYPE_STRING)
{
//l10n
//throw CIMInvalidParameterException("Invalid type for property: "
//+ NAMESPACE_PROPERTYNAME.getString());
throw CIMInvalidParameterException(MessageLoaderParms(
"ControlProviders.NamespaceProvider.NamespaceProvider.INVALID_TYPE_FOR_PROPERTY",
"Invalid type for property: $0",
NAMESPACE_PROPERTYNAME.getString()));
}
String cnsName;
propertyValue.get(cnsName);
if (cnsName == String::EMPTY)
{
childNamespaceName = CIMNamespaceName();
}
else
{
childNamespaceName = CIMNamespaceName(cnsName);
}
isRelativeName = !(childNamespaceName.isNull());
}
CIMObjectPath _createSubscription
(CIMClient & client,
const CIMObjectPath & filterPath,
const CIMObjectPath & handlerPath)
{
CIMInstance subscription (SUBSCRIPTION_CLASSNAME);
subscription.addProperty (CIMProperty (CIMName ("Filter"),
filterPath, 0, FILTER_CLASSNAME));
subscription.addProperty (CIMProperty (CIMName ("Handler"),
handlerPath, 0, HANDLER_CLASSNAME));
CIMObjectPath path = client.createInstance (INTEROPNAMESPACE, subscription);
return path;
}
CIMInstance _buildSubscriptionInstance
(const CIMObjectPath & filterPath,
const CIMName & handlerClass, const CIMObjectPath & handlerPath)
{
CIMInstance subscriptionInstance (PEGASUS_CLASSNAME_INDSUBSCRIPTION);
subscriptionInstance.addProperty (CIMProperty (CIMName ("Filter"),
filterPath, 0,
PEGASUS_CLASSNAME_INDFILTER));
subscriptionInstance.
addProperty (CIMProperty
(CIMName ("Handler"), handlerPath, 0, handlerClass));
return subscriptionInstance;
}
void GetInstanceResponseHandler::deliver(const CIMInstance& cimInstance)
{
if (cimInstance.isUninitialized())
{
MessageLoaderParms message(
"Common.Exception.UNINITIALIZED_OBJECT_EXCEPTION",
"The object is not initialized.");
throw CIMException(CIM_ERR_FAILED, message);
}
if (SimpleInstanceResponseHandler::size() != 0)
{
MessageLoaderParms message(
"Server.OperationResponseHandler.TOO_MANY_OBJECTS_DELIVERED",
"Too many objects delivered.");
throw CIMException(CIM_ERR_FAILED, message);
}
CIMInstance localInstance(cimInstance);
#ifdef PEGASUS_ENABLE_OBJECT_NORMALIZATION
// The normalizer expects an object path embedded in instances even
// though it is not required by this operation. Use the requested
// object path is missing from the instance.
if (localInstance.getPath().getKeyBindings().size() == 0)
{
// ATTN: should clone before modification
localInstance.setPath(static_cast<CIMGetInstanceRequestMessage*>(
getRequest())->instanceName);
}
#endif
SimpleInstanceResponseHandler::deliver(
_normalizer.processInstance(localInstance));
}
CIMObjectPath _createSubscriptionInstance(
CIMClient & client,
const CIMObjectPath & filterPath,
const CIMObjectPath & handlerPath)
{
CIMInstance subscriptionInstance (PEGASUS_CLASSNAME_INDSUBSCRIPTION);
subscriptionInstance.addProperty (CIMProperty (CIMName ("Filter"),
filterPath, 0, PEGASUS_CLASSNAME_INDFILTER));
subscriptionInstance.addProperty (CIMProperty (CIMName ("Handler"),
handlerPath, 0, PEGASUS_CLASSNAME_INDHANDLER_SNMP));
subscriptionInstance.addProperty (CIMProperty
(CIMName ("SubscriptionState"), CIMValue ((Uint16) 2)));
return client.createInstance(
PEGASUS_NAMESPACENAME_INTEROP, subscriptionInstance);
}
void InstanceProvider::createInstance(
const OperationContext & context,
const CIMObjectPath & instanceReference,
const CIMInstance & instanceObject,
ObjectPathResponseHandler & handler)
{
// Validate the class name
if (!instanceObject.getClassName().equal("Sample_InstanceProviderClass"))
{
throw CIMNotSupportedException(
instanceObject.getClassName().getString());
}
// Find the key property
Uint32 idIndex = instanceObject.findProperty("Identifier");
if (idIndex == PEG_NOT_FOUND)
{
throw CIMInvalidParameterException("Missing key value");
}
CIMInstance cimInstance = instanceObject.clone();
// Create the new instance name
CIMValue idValue = instanceObject.getProperty(idIndex).getValue();
Array<CIMKeyBinding> keys;
keys.append(CIMKeyBinding("Identifier", idValue));
CIMObjectPath instanceName = CIMObjectPath(
String(),
CIMNamespaceName(),
instanceObject.getClassName(),
keys);
cimInstance.setPath(instanceName);
// Determine whether this instance already exists
for(Uint32 i = 0, n = _instances.size(); i < n; i++)
{
if(instanceName == _instances[i].getPath())
{
throw CIMObjectAlreadyExistsException(instanceName.toString());
}
}
// begin processing the request
handler.processing();
// add the new instance to the array
_instances.append(cimInstance);
// deliver the new instance name
handler.deliver(instanceName);
// complete processing the request
handler.complete();
}
void _createSubscriptionInstance
(CIMClient & client,
const CIMObjectPath & filterPath,
const CIMObjectPath & handlerPath,
const CIMNamespaceName & subscriptionNS)
{
CIMInstance subscriptionInstance (PEGASUS_CLASSNAME_INDSUBSCRIPTION);
subscriptionInstance.addProperty (CIMProperty (CIMName ("Filter"),
filterPath, 0, PEGASUS_CLASSNAME_INDFILTER));
subscriptionInstance.addProperty (CIMProperty (CIMName ("Handler"),
handlerPath, 0, PEGASUS_CLASSNAME_INDHANDLER_CIMXML));
subscriptionInstance.addProperty (CIMProperty
(CIMName ("SubscriptionState"), CIMValue ((Uint16) 2)));
CIMObjectPath path = client.createInstance (subscriptionNS,
subscriptionInstance);
}
/**
Stores a copy of the provided instance locally in the errorInstance
class property, and also creates a copy of the instance in the static
repository namespace. The instance is then read back out of the repository
and compared against the one stored by the class.
*/
void EmbeddedInstanceProvider::createInstance(
const OperationContext& context,
const CIMObjectPath& ref,
const CIMInstance& obj,
ObjectPathResponseHandler& handler)
{
handler.processing();
errorInstance.reset(new CIMInstance(obj));
Array<CIMName> propNameList;
propNameList.append(CIMName("errorKey"));
propNameList.append(CIMName("EmbeddedInst"));
CIMPropertyList propList(propNameList);
CIMClass objClass = cimom.getClass(
context,
STATIC_REPOSITORY,
obj.getClassName(),
false,
true,
false,
propList);
CIMObjectPath objPath = obj.buildPath(objClass);
errorInstance->setPath(objPath);
repositoryPath = cimom.createInstance(
context, STATIC_REPOSITORY, *errorInstance);
CIMInstance repositoryInstance = cimom.getInstance(
context,
STATIC_REPOSITORY,
repositoryPath,
false,
false,
false,
propList);
repositoryInstance.setPath(repositoryPath);
if (!errorInstance->identical(repositoryInstance))
{
throw Exception(
"Repository instance and local instance for embedded error not "
"identical");
}
handler.deliver(objPath);
handler.complete();
}
Boolean UNIX_BlockStatisticsManifestCollection::loadInstance(const CIMInstance &instance)
{
clearInstance();
Uint32 propertyCount = instance.getPropertyCount();
for(Uint32 i = 0; i < propertyCount; i++) {
CIMConstProperty property = instance.getProperty(i);
if (String::equal(property.getName().getString(), "InstanceID"))
{
String instanceIDValue;
property.getValue().get(instanceIDValue);
setInstanceID(instanceIDValue);
}
else if (String::equal(property.getName().getString(), "Caption"))
{
String captionValue;
property.getValue().get(captionValue);
setCaption(captionValue);
}
else if (String::equal(property.getName().getString(), "Description"))
{
String descriptionValue;
property.getValue().get(descriptionValue);
setDescription(descriptionValue);
}
else if (String::equal(property.getName().getString(), "ElementName"))
{
String elementNameValue;
property.getValue().get(elementNameValue);
setElementName(elementNameValue);
}
else if (String::equal(property.getName().getString(), "Generation"))
{
Uint64 generationValue;
property.getValue().get(generationValue);
setGeneration(generationValue);
}
else if (String::equal(property.getName().getString(), "IsDefault"))
{
Boolean isDefaultValue;
property.getValue().get(isDefaultValue);
setIsDefault(isDefaultValue);
}
}
return true;
}
CIMObjectPath _createFilter
(CIMClient & client,
const String & name,
const String & query,
const String & queryLanguage,
const String & sourceNamespace)
{
CIMInstance filter (FILTER_CLASSNAME);
filter.addProperty (CIMProperty (CIMName ("Name"), name));
filter.addProperty (CIMProperty (CIMName ("Query"), query));
filter.addProperty (CIMProperty (CIMName ("QueryLanguage"), queryLanguage));
filter.addProperty (CIMProperty (CIMName ("SourceNamespace"),
sourceNamespace));
CIMObjectPath path = client.createInstance (INTEROPNAMESPACE, filter);
return path;
}
void InstanceProvider::modifyInstance(
const OperationContext & context,
const CIMObjectPath & instanceReference,
const CIMInstance & instanceObject,
const Boolean includeQualifiers,
const CIMPropertyList & propertyList,
ResponseHandler & handler)
{
// convert a potential fully qualified reference into a local reference
// (class name and keys only).
CIMObjectPath localReference = CIMObjectPath(
String(),
CIMNamespaceName(),
instanceReference.getClassName(),
instanceReference.getKeyBindings());
// begin processing the request
handler.processing();
// instance index corresponds to reference index
for(Uint32 i = 0, n = _instances.size(); i < n; i++)
{
if(localReference == _instances[i].getPath())
{
CIMInstance cimInstance = instanceObject.clone();
CIMObjectPath instanceName = CIMObjectPath(
String(),
CIMNamespaceName(),
instanceReference.getClassName(),
instanceReference.getKeyBindings());
cimInstance.setPath(instanceName);
// overwrite existing instance
_instances[i] = instanceObject;
break;
}
}
// complete processing the request
handler.complete();
}
void _testDeliveryRetryIntervalValue(
CIMInstance& instance)
{
CIMValue value =
instance.getProperty(
instance.findProperty(
_PROPERTY_DELIVERYRETRYINTERVAL)).getValue();
if (value.getType() == CIMTYPE_UINT64)
{
// CIM Schema 2.17 experimental class
PEGASUS_TEST_ASSERT(
Uint64(_PROPERTY_DELIVERYRETRYINTERVAL_VALUE) == value);
}
else
{
// CIM Schema 2.22 and up
PEGASUS_TEST_ASSERT(_PROPERTY_DELIVERYRETRYINTERVAL_VALUE == value);
}
}