void UNIX_ApplicationSystemDirectoryFixture::Run()
{
CIMName className("UNIX_ApplicationSystemDirectory");
CIMNamespaceName nameSpace("root/cimv2");
UNIX_ApplicationSystemDirectory _p;
UNIX_ApplicationSystemDirectoryProvider _provider;
Uint32 propertyCount;
CIMOMHandle omHandle;
_provider.initialize(omHandle);
_p.initialize();
for(int pIndex = 0; _p.load(pIndex); pIndex++)
{
CIMInstance instance = _provider.constructInstance(className,
nameSpace,
_p);
CIMObjectPath path = instance.getPath();
cout << path.toString() << endl;
propertyCount = instance.getPropertyCount();
for(Uint32 i = 0; i < propertyCount; i++)
{
CIMProperty propertyItem = instance.getProperty(i);
if (propertyItem.getType() == CIMTYPE_REFERENCE) {
CIMValue subValue = propertyItem.getValue();
CIMInstance subInstance;
subValue.get(subInstance);
CIMObjectPath subPath = subInstance.getPath();
cout << " Name: " << propertyItem.getName().getString() << ": " << subPath.toString() << endl;
Uint32 subPropertyCount = subInstance.getPropertyCount();
for(Uint32 j = 0; j < subPropertyCount; j++)
{
CIMProperty subPropertyItem = subInstance.getProperty(j);
cout << " Name: " << subPropertyItem.getName().getString() << " - Value: " << subPropertyItem.getValue().toString() << endl;
}
}
else {
cout << " Name: " << propertyItem.getName().getString() << " - Value: " << propertyItem.getValue().toString() << endl;
}
}
cout << "------------------------------------" << endl;
cout << endl;
}
_p.finalize();
}
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;
}
//////////////////////////////////////////////////////////////////////
// TERRY: ADDED: helper function, maybe should go in a utilities or base class?
//////////////////////////////////////////////////////////////////////
bool WMIInstanceProvider::GetKeyBindingsFromCIMInstance(
const CIMInstance& newInstance,
BSTR* pbsKeyBindings)
{
// might check for any NULL keys, just returning success always for now:
bool bSuccess = true;
String relPath = getObjectName(newInstance.getPath());
*pbsKeyBindings = SysAllocString((const OLECHAR*)relPath.getChar16Data());
return bSuccess;
}
void ProviderIndicationCountTable::getProviderKeys(
const CIMInstance& providerInstance,
String& providerModuleName,
String& providerName)
{
Array<CIMKeyBinding> keys = providerInstance.getPath().getKeyBindings();
for (Uint32 i = 0; i < keys.size(); i++)
{
if (keys[i].getName() == PEGASUS_PROPERTYNAME_NAME)
{
providerName = keys[i].getValue();
}
else if (keys[i].getName() == _PROPERTY_PROVIDERMODULENAME)
{
providerModuleName = keys[i].getValue();
}
}
}
Boolean setObjectManagerStatistics(CIMClient & client, Boolean newState)
{
CIMName gathStatName ("GatherStatisticalData");
Array<CIMInstance> instancesObjectManager;
CIMInstance instObjectManager;
Uint32 prop_num;
Array<CIMName> plA;
plA.append(gathStatName);
CIMPropertyList statPropertyList(plA);
// Create property list that represents correct request
// get instance. Get only the gatherstatitistics property
instancesObjectManager =
client.enumerateInstances(PEGASUS_NAMESPACENAME_INTEROP,
"CIM_ObjectManager",
true, false, false, false, statPropertyList);
PEGASUS_TEST_ASSERT(instancesObjectManager.size() == 1);
instObjectManager = instancesObjectManager[0];
// set correct path into instance
instObjectManager.setPath(instancesObjectManager[0].getPath());
prop_num = instObjectManager.findProperty(gathStatName);
PEGASUS_TEST_ASSERT(prop_num != PEG_NOT_FOUND);
instObjectManager.getProperty(prop_num).setValue(CIMValue(newState));
client.modifyInstance(PEGASUS_NAMESPACENAME_INTEROP, instObjectManager,
false, statPropertyList);
CIMInstance updatedInstance =
client.getInstance(PEGASUS_NAMESPACENAME_INTEROP,
instObjectManager.getPath(),
false, false, false, statPropertyList);
prop_num = updatedInstance.findProperty(gathStatName);
PEGASUS_TEST_ASSERT(prop_num != PEG_NOT_FOUND);
CIMProperty p = updatedInstance.getProperty(prop_num);
CIMValue v = p.getValue();
Boolean rtn;
v.get(rtn);
//// Need to get it again
cout << "Updated Status= " << ((rtn)? "true" : "false") << endl;
return(rtn);
}
CIMObjectPath CIMClientRep::createInstance(
const CIMNamespaceName& nameSpace,
const CIMInstance& newInstance
)
{
compareObjectPathtoCurrentConnection(newInstance.getPath());
AutoPtr<CIMRequestMessage> request(new CIMCreateInstanceRequestMessage(
String::EMPTY,
nameSpace,
newInstance,
QueueIdStack()));
Message* message = _doRequest(request, CIM_CREATE_INSTANCE_RESPONSE_MESSAGE);
CIMCreateInstanceResponseMessage* response =
(CIMCreateInstanceResponseMessage*)message;
AutoPtr<CIMCreateInstanceResponseMessage> destroyer(response);
return(response->instanceName);
}
void CIMClientRep::modifyInstance(
const CIMNamespaceName& nameSpace,
const CIMInstance& modifiedInstance,
Boolean includeQualifiers,
const CIMPropertyList& propertyList
)
{
compareObjectPathtoCurrentConnection(modifiedInstance.getPath());
AutoPtr<CIMRequestMessage> request(new CIMModifyInstanceRequestMessage(
String::EMPTY,
nameSpace,
modifiedInstance,
includeQualifiers,
propertyList,
QueueIdStack()));
Message* message = _doRequest(request, CIM_MODIFY_INSTANCE_RESPONSE_MESSAGE);
CIMModifyInstanceResponseMessage* response =
(CIMModifyInstanceResponseMessage*)message;
AutoPtr<CIMModifyInstanceResponseMessage> destroyer(response);
}
//
// Enumerates all of the ElementConformsToProfile association instances.
//
Array<CIMInstance> InteropProvider::enumElementConformsToProfileInstances(
const OperationContext & opContext, const CIMNamespaceName & opNamespace)
{
CIMClass elementConformsClass = repository->getClass(
PEGASUS_NAMESPACENAME_INTEROP,
PEGASUS_CLASSNAME_PG_ELEMENTCONFORMSTOPROFILE,
false, true, false);
AutoMutex holder(interopMut);
Array<CIMInstance> instances;
verifyCachedInfo();
// Loop through the cached profile Id's and related info about its
// conforming elements.
for (Uint32 i = 0, n = profileIds.size(); i < n; ++i)
{
String & profileId = profileIds[i];
Array<CIMName> & elementList = conformingElements[i];
Array<CIMNamespaceName> & namespaceList = elementNamespaces[i];
Array<CIMObjectPath> conformingElementPaths;
for (Uint32 j = 0, m = elementList.size(); j < m; ++j)
{
CIMName & currentElement = elementList[j];
CIMNamespaceName & currentNamespace = namespaceList[j];
if (opNamespace == PEGASUS_NAMESPACENAME_INTEROP ||
opNamespace == currentNamespace)
{
String currentElementStr(currentElement.getString());
if (currentElementStr.find(PEGASUS_DYNAMIC) == 0)
{
// If the provider profile registration did not provide a
// list of conforming elements (presumably because there is
// no such definite list), then the provider is required
// to provide instances of ElementConformsToProfile in the
// vendor namespace, so we do not generate instances.
if (opNamespace != PEGASUS_NAMESPACENAME_INTEROP)
{
continue;
}
CIMName subclassName(
currentElementStr.subString(PEGASUS_DYNAMIC_LEN));
Array<CIMInstance> elementConformsInstances =
cimomHandle.enumerateInstances(opContext,
currentNamespace, subclassName, true, false, false,
true, CIMPropertyList());
// Retrieve the Conforming Element
for (Uint32 k = 0, x = elementConformsInstances.size();
k < x; ++k)
{
CIMInstance & currentInstance =
elementConformsInstances[k];
// NOCHKSRC
// Make sure that the current instance points to the
// current profile ID.
CIMObjectPath profilePath =
getRequiredValue<CIMObjectPath>(
elementConformsInstances[k],
ELEMENTCONFORMSTOPROFILE_PROPERTY_CONFORMANTSTANDARD);
// DOCHKSRC
const Array<CIMKeyBinding> & keys =
profilePath.getKeyBindings();
if (keys.size() != 1)
continue;
if (keys.size() == 1 && keys[0].getValue() == profileId)
{
// NOCHKSRC
conformingElementPaths.append(
getRequiredValue<CIMObjectPath>(
currentInstance,
ELEMENTCONFORMSTOPROFILE_PROPERTY_MANAGEDELEMENT));
// DOCHKSRC
}
}
}
else
{
// All of the instances of the current element in the
// corresponding namespace conform to the current profile.
Array<CIMObjectPath> paths =
cimomHandle.enumerateInstanceNames(opContext,
currentNamespace, currentElement);
// Set the namespace in the paths just in case
for (Uint32 k = 0, x = paths.size();
k < x; ++k)
{
CIMObjectPath & curPath = paths[k];
curPath.setNameSpace(currentNamespace);
curPath.setHost(hostName);
}
conformingElementPaths.appendArray(paths);
}
}
}
// Create the object path for the RegisteredProfile using the given
// profileId.
CIMObjectPath profilePath = buildDependencyReference(
hostName, profileIds[i], PEGASUS_CLASSNAME_PG_REGISTEREDPROFILE);
// Build all of the ElementConformsToProfile instances for the current
// profile.
for (Uint32 k = 0, x = conformingElementPaths.size(); k < x; ++k)
{
instances.append(buildElementConformsToProfile(profilePath,
conformingElementPaths[k], elementConformsClass));
}
}
// Now add the default instance: the association between the Server Profile
// and the ObjectManager (if we're in the Interop namespace)
if (opNamespace == PEGASUS_NAMESPACENAME_INTEROP)
{
// Build up the Object Path for the server profile version 1.1.0
CIMObjectPath serverProfile = buildDependencyReference(
hostName,
buildProfileInstanceId(SNIA_NAME, "Server", SNIA_VER_110),
PEGASUS_CLASSNAME_PG_REGISTEREDPROFILE);
// Retrieve the Object Manager instance
CIMInstance objManager = getObjectManagerInstance();
instances.append(
buildElementConformsToProfile(
serverProfile,
objManager.getPath(),
elementConformsClass));
// Build up the Object Path for the server profile ver 1.2.0
// and add the elementconformstoprofile association instance
serverProfile = buildDependencyReference(
hostName,
buildProfileInstanceId(SNIA_NAME, "Server", SNIA_VER_120),
PEGASUS_CLASSNAME_PG_REGISTEREDPROFILE);
instances.append(
buildElementConformsToProfile(
serverProfile,
objManager.getPath(),
elementConformsClass));
}
return instances;
}
CIMInstance ObjectNormalizer::processInstance(
const CIMInstance& cimInstance) const
{
// pre-checks
if (!_enableNormalization || _cimClass.isUninitialized())
{
// do nothing
return cimInstance;
}
/*
// ATTN: moving similar logic to the response handlers because this
// type of error should be checked regardless with or without
// normalization enabled.
if (cimInstance.isUninitialized())
{
throw CIMException(CIM_ERR_FAILED, "unintialized instance object.");
}
*/
CIMInstance normalizedInstance(_cimClass.getClassName());
// proces object path
normalizedInstance.setPath(
processInstanceObjectPath(cimInstance.getPath()));
// process instance qualifiers
if (_includeQualifiers)
{
// propagate class qualifiers
for (Uint32 i = 0, n = _cimClass.getQualifierCount(); i < n; i++)
{
CIMConstQualifier referenceQualifier = _cimClass.getQualifier(i);
Uint32 pos =
cimInstance.findQualifier(referenceQualifier.getName());
// update value if qualifier is present in the specified property
if (pos != PEG_NOT_FOUND)
{
CIMConstQualifier cimQualifier = cimInstance.getQualifier(pos);
CIMQualifier normalizedQualifier =
_processQualifier(
referenceQualifier,
cimQualifier);
normalizedInstance.addQualifier(normalizedQualifier);
}
else
{
normalizedInstance.addQualifier(referenceQualifier.clone());
}
}
}
// check property names and types. any properties in the class but not
// in the instance are implicitly dropped.
for (Uint32 i = 0, n = cimInstance.getPropertyCount(); i < n; i++)
{
CIMConstProperty instProperty = cimInstance.getProperty(i);
Uint32 pos = _cimClass.findProperty(instProperty.getName());
if (pos != PEG_NOT_FOUND)
{
CIMConstProperty cimProperty = _cimClass.getProperty(pos);
CIMProperty normalizedProperty =
processProperty(
cimProperty,
instProperty,
_includeQualifiers,
_includeClassOrigin,
_context.get(),
_nameSpace);
normalizedInstance.addProperty(normalizedProperty);
}
}
return normalizedInstance;
}
void testInstanceClass(CIMClient & client, const CIMName & className)
{
cout << "Testing Instance Class "
<< (const char *)className.getString().getCString()
<< "...";
Array<CIMInstance> instances = testAnyClass(client, className);
for(unsigned int i = 0, n = instances.size(); i < n; ++i)
{
CIMInstance currentInstance = instances[i];
CIMObjectPath currentPath = currentInstance.getPath();
if(currentPath.getNameSpace().isNull())
currentPath.setNameSpace(interopNamespace);
//
// Now test association traversal
// Note that the "TestAssociationClass" method does a very good job
// of testing association traversal between references contained in
// instances of the supplied association class. Therefore, all we
// really have to do here is make sure that the results of the
// associators, associatorNames, references, and referenceNames
// operations are consistent.
//
Boolean failure = false;
try
{
Array<CIMObject> associatorsResults = client.associators(
currentPath.getNameSpace(), currentPath);
Array<CIMObjectPath> associatorNamesResults =
client.associatorNames(
currentPath.getNameSpace(), currentPath);
Array<CIMObject> referencesResults = client.references(
currentPath.getNameSpace(), currentPath);
Array<CIMObjectPath> referenceNamesResults = client.referenceNames(
currentPath.getNameSpace(), currentPath);
Uint32 numResults = associatorsResults.size();
if(numResults != associatorNamesResults.size() ||
numResults != referencesResults.size() ||
numResults != referenceNamesResults.size())
{
failure = true;
}
else
{
// Check that the results for the references and referenceNames
// operations are consistent.
unsigned int j = 0;
for(j = 0; j < numResults; ++j)
{
CIMObjectPath currentReferenceName =
referenceNamesResults[j];
Boolean found = false;
for(unsigned int k = 0; k < numResults; ++k)
{
if(currentReferenceName ==
referencesResults[k].getPath())
{
found = true;
break;
}
}
if(!found)
{
failure = true;
break;
}
}
// Check that that results for the associatorNames call is
// consistent with the associators call and the references
// call.
for(j = 0; j < numResults; ++j)
{
CIMObjectPath currentAssociatorName =
associatorNamesResults[j];
Boolean found = false;
unsigned int k = 0;
for(k = 0; k < numResults; ++k)
{
if(currentAssociatorName ==
associatorsResults[k].getPath())
{
found = true;
break;
}
}
if(!found)
{
failure = true;
break;
}
found = false;
for(k = 0; k < numResults; ++k)
{
CIMObject referenceInstance = referencesResults[k];
for(unsigned int x = 0,
m = referenceInstance.getPropertyCount();
x < m; ++x)
{
CIMProperty currentProp =
referenceInstance.getProperty(x);
if(currentProp.getType() == CIMTYPE_REFERENCE)
{
CIMObjectPath currentRef;
currentProp.getValue().get(currentRef);
currentRef.setHost(
currentAssociatorName.getHost());
if(currentRef == currentAssociatorName)
{
found = true;
break;
}
}
}
if(found)
break;
}
if(!found)
{
failure = true;
break;
}
}
}
if(failure)
{
exitFailure(
String("Association Operations returned inconsistent ") +
String("results for instance ") +
currentPath.toString());
}
}
catch(CIMException & e)
{
exitFailure(String("Caught exception while performing ") +
String("association operations on instance ") +
currentPath.toString() + String(": ") + e.getMessage());
}
}
cout << "Test Complete" << endl;
}
void testAssociationClass(CIMClient & client, const CIMName & className)
{
cout << "Testing Association Class "
<< (const char *)className.getString().getCString()
<< "...";
Array<CIMInstance> instances = testAnyClass(client, className);
for(unsigned int i = 0, n = instances.size(); i < n; ++i)
{
//
// Now make sure that the references are valid and that association
// traversal between them is working properly.
//
CIMObjectPath referenceA;
CIMObjectPath referenceB;
CIMInstance currentInstance = instances[i];
CIMObjectPath currentInstanceName = currentInstance.getPath();
if(currentInstanceName.getNameSpace().isNull())
currentInstanceName.setNameSpace(interopNamespace);
for(unsigned int j = 0, m = currentInstance.getPropertyCount();
j < m; ++j)
{
CIMProperty currentProp = currentInstance.getProperty(j);
if(currentProp.getValue().getType() == CIMTYPE_REFERENCE)
{
if(referenceA.getKeyBindings().size() == 0)
{
currentProp.getValue().get(referenceA);
}
else
{
currentProp.getValue().get(referenceB);
break;
}
}
}
if(referenceA.getKeyBindings().size() == 0 ||
referenceB.getKeyBindings().size() == 0)
{
exitFailure(
String("Could not find reference properties for ") +
String("association: ") +
currentInstanceName.toString());
}
try
{
client.getInstance(referenceA.getNameSpace(), referenceA);
client.getInstance(referenceB.getNameSpace(), referenceB);
}
catch(CIMException &)
{
exitFailure(String("Could not get instances for association : ") +
currentInstanceName.toString());
}
Boolean associationFailure = false;
try
{
Array<CIMObjectPath> results = client.associatorNames(
referenceA.getNameSpace(), referenceA, className);
Boolean found = false;
for(unsigned int j = 0, m = results.size(); j < m; ++j)
{
CIMObjectPath result = results[j];
result.setHost(referenceB.getHost());
result.setNameSpace(referenceB.getNameSpace());
if(result == referenceB)
{
found = true;
break;
}
}
if(found)
{
results = client.associatorNames(referenceB.getNameSpace(),
referenceB, className);
for(unsigned int j = 0, m = results.size(); j < m; ++j)
{
CIMObjectPath result = results[j];
result.setHost(referenceA.getHost());
result.setNameSpace(referenceA.getNameSpace());
if(result == referenceA)
{
found = true;
break;
}
}
}
if(!found)
{
associationFailure = true;
}
}
catch(CIMException & e)
{
cout << "Exception: " << e.getMessage() << endl;
associationFailure = true;
}
if(associationFailure)
{
exitFailure(String("Association traversal failed between ") +
String("instances of association: ") +
currentInstanceName.toString());
}
Boolean referencesFailure = false;
try
{
Array<CIMObjectPath> results = client.referenceNames(
referenceA.getNameSpace(), referenceA, className);
Boolean found = false;
for(unsigned int j = 0, m = results.size(); j < m; ++j)
{
CIMObjectPath currentPath = results[j];
if(currentPath.getNameSpace().isNull())
currentPath.setNameSpace(interopNamespace);
if(currentPath.getHost().size() != 0)
currentPath.setHost(String::EMPTY);
if(currentPath == currentInstanceName)
{
found = true;
break;
}
}
if(found)
{
results = client.referenceNames(referenceB.getNameSpace(),
referenceB, className);
for(unsigned int j = 0, m = results.size(); j < m; ++j)
{
CIMObjectPath currentPath = results[j];
if(currentPath.getNameSpace().isNull())
currentPath.setNameSpace(interopNamespace);
if(currentPath.getHost().size() != 0)
currentPath.setHost(String::EMPTY);
if(currentPath == currentInstanceName)
{
found = true;
break;
}
}
}
if(!found)
{
referencesFailure = true;
}
}
catch(CIMException &)
{
referencesFailure = true;
}
if(referencesFailure)
{
exitFailure(String("References operation failed for ") +
String("instances of association: ") +
currentInstanceName.toString());
}
}
cout << "Test Complete" << endl;
}
/**
When the "PropagateError" method is invoked, this function
will read a CIM_Error embedded instance from the inParameters and use
that instance to create an InstMethodIndication populating the Error[]
property with the CIM_Error parameter and errorInstance stored in this
class (if it's been created already). The output parameter of this method
will contain the embedded instance received as input, and the newly
created InstMethodIndication will be sent by the provider to any
registered listeners.
*/
void EmbeddedInstanceProvider::invokeMethod(
const OperationContext& context,
const CIMObjectPath& objectReference,
const CIMName& methodName,
const Array<CIMParamValue>& inParameters,
MethodResultResponseHandler& handler)
{
// This should start sending indications with the stored Job instance
// embedded in the InstMethodIndication
handler.processing();
if (!methodName.equal(CIMName("PropagateError")))
throw CIMException(CIM_ERR_METHOD_NOT_AVAILABLE);
if (inParameters.size() != 1)
{
throw CIMException(
CIM_ERR_INVALID_PARAMETER, "Did not receive exactly 1 parameter");
}
CIMParamValue errorParam = inParameters[0];
if (!String::equal(errorParam.getParameterName(), String("error")))
{
throw CIMException(
CIM_ERR_INVALID_PARAMETER, "Did not find \"error\" parameter");
}
CIMInstance errorParamInst;
errorParam.getValue().get(errorParamInst);
if (errorParamInst.getPath().getClassName() != "PG_EmbeddedError")
{
throw CIMException(CIM_ERR_INVALID_PARAMETER);
}
errorParamInst.setPath(errorInstance->getPath());
Array<CIMName> propList;
for (unsigned int i = 0, n = errorParamInst.getPropertyCount(); i < n; i++)
{
propList.append(errorParamInst.getProperty(i).getName());
}
CIMInstance tmpErrorInstance(errorInstance->clone());
if (!tmpErrorInstance.identical(errorParamInst))
{
throw Exception("Did not receive expected ErrorInstance");
}
// Build new indication instance
CIMObjectPath indicationPath(System::getHostName(),
CIMNamespaceName("test/EmbeddedInstance/Dynamic"),
CIMName("PG_InstMethodIndication"));
indicationInstance.reset(new CIMInstance("PG_InstMethodIndication"));
indicationInstance->setPath(indicationPath);
indicationInstance->addProperty(CIMProperty("MethodName",
CIMValue(String("PropagateError"))));
indicationInstance->addProperty(CIMProperty("PreCall",
CIMValue(Boolean(false))));
indicationInstance->addProperty(CIMProperty("SourceInstance",
CIMValue(CIMObject(*errorInstance))));
Array<CIMInstance> errorInstances;
errorInstances.append(*errorInstance);
errorInstances.append(*errorInstance);
indicationInstance->addProperty(CIMProperty("Error",
CIMValue(errorInstances)));
handler.deliverParamValue(CIMParamValue(String("sameError"),
CIMValue(errorParamInst)));
handler.deliver(CIMValue(Uint32(1)));
handler.complete();
indicationHandler->deliver(*indicationInstance);
}
void test14 (CIMClient & client)
{
CIMObjectPath instanceName;
instanceName.setNameSpace (providerNamespace);
instanceName.setClassName (CLASSNAME);
Array < CIMParamValue > inParams;
Array < CIMInstance> eObjs;
Array < CIMParamValue > outParams;
CIMValue retValue = client.invokeMethod (providerNamespace,
instanceName,
"returnInstance",
inParams,
outParams);
PEGASUS_TEST_ASSERT (retValue.getType () == CIMTYPE_OBJECT);
PEGASUS_TEST_ASSERT (!retValue.isArray ());
PEGASUS_TEST_ASSERT (!retValue.isNull ());
CIMObject result;
retValue.get (result);
CIMObjectPath objPath = result.getPath();
CIMInstance inputInstance(result);
CIMInstance outputInstance;
eObjs.append(inputInstance);
eObjs.append(inputInstance);
eObjs.append(inputInstance);
inParams.append (
CIMParamValue(String("inputInstances"), CIMValue(eObjs)));
retValue = client.invokeMethod (providerNamespace,
instanceName,
"processArrayEmbeddedInstance",
inParams,
outParams);
// First test the return value
PEGASUS_TEST_ASSERT(retValue.getType() == CIMTYPE_INSTANCE);
PEGASUS_TEST_ASSERT(!retValue.isArray());
PEGASUS_TEST_ASSERT(!retValue.isNull());
retValue.get(outputInstance);
PEGASUS_TEST_ASSERT(objPath.toString() ==
outputInstance.getPath().toString());
PEGASUS_TEST_ASSERT(outputInstance.getPropertyCount() ==
inputInstance.getPropertyCount());
for(unsigned int i = 0, n = outputInstance.getPropertyCount(); i < n; ++i)
{
CIMProperty outputProp(outputInstance.getProperty(i));
CIMProperty inputProp(inputInstance.getProperty(i));
PEGASUS_TEST_ASSERT(outputProp.getName() == inputProp.getName());
PEGASUS_TEST_ASSERT(outputProp.getValue() == inputProp.getValue());
}
// Now test the output parameters
PEGASUS_TEST_ASSERT(outParams.size() == 3);
CIMValue outParamValue = outParams[0].getValue();
PEGASUS_TEST_ASSERT(outParamValue.isArray());
PEGASUS_TEST_ASSERT(!outParamValue.isNull());
Array<CIMInstance> instances;
outParamValue.get(instances);
for (unsigned int j = 0; j < instances.size () ; ++j)
{
outputInstance = instances[j];
PEGASUS_TEST_ASSERT(objPath.toString() ==
outputInstance.getPath().toString());
PEGASUS_TEST_ASSERT(outputInstance.getPropertyCount() ==
eObjs[j].getPropertyCount());
for(unsigned int i = 0, n = outputInstance.getPropertyCount();
i < n; ++i)
{
CIMProperty outputProp(outputInstance.getProperty(i));
CIMProperty inputProp(eObjs[j].getProperty(i));
PEGASUS_TEST_ASSERT(outputProp.getName() == inputProp.getName());
PEGASUS_TEST_ASSERT(outputProp.getValue() == inputProp.getValue());
}
}
outParamValue = outParams[1].getValue();
PEGASUS_TEST_ASSERT(outParamValue.isArray());
PEGASUS_TEST_ASSERT(!outParamValue.isNull());
Array<CIMObject> objs;
outParamValue.get(objs);
for (unsigned int j = 0; j < objs.size () ; ++j)
{
outputInstance = CIMInstance(objs[j]);
PEGASUS_TEST_ASSERT(objPath.toString() ==
outputInstance.getPath().toString());
PEGASUS_TEST_ASSERT(outputInstance.getPropertyCount() ==
eObjs[j].getPropertyCount());
for(unsigned int i = 0, n = outputInstance.getPropertyCount();
i < n; ++i)
{
CIMProperty outputProp(outputInstance.getProperty(i));
CIMProperty inputProp(eObjs[j].getProperty(i));
PEGASUS_TEST_ASSERT(outputProp.getName() == inputProp.getName());
PEGASUS_TEST_ASSERT(outputProp.getValue() == inputProp.getValue());
}
}
outParamValue = outParams[2].getValue();
PEGASUS_TEST_ASSERT(outParamValue.isArray());
PEGASUS_TEST_ASSERT(!outParamValue.isNull());
outParamValue.get(objs);
for (Uint32 j = 0, m = objs.size(); j < m ; ++j)
{
outputInstance = CIMInstance(objs[j]);
Uint32 id;
CIMInstance emInstance;
CIMObject emObject;
outputInstance.getProperty(
outputInstance.findProperty("id")).getValue().get(id);
outputInstance.getProperty(
outputInstance.findProperty("emInstance")).
getValue().get(emInstance);
outputInstance.getProperty(
outputInstance.findProperty("emObject")).getValue().get(emObject);
PEGASUS_TEST_ASSERT(eObjs[j].identical(emInstance));
PEGASUS_TEST_ASSERT(eObjs[j].identical(CIMInstance(emObject)));
PEGASUS_TEST_ASSERT(id == j+1);
}
}
/**
* This tests the embedded instance functionality through the CMPI Test
* Method Provider. It first invokes the returnInstance() method to retrieve
* an instance that can be used
*/
void test09 (CIMClient & client)
{
CIMObjectPath instanceName;
instanceName.setNameSpace (providerNamespace);
instanceName.setClassName (CLASSNAME);
Array < CIMParamValue > inParams;
Array < CIMParamValue > outParams;
/* [EmbeddedObject] String returnInstance(); */
CIMValue retValue = client.invokeMethod (providerNamespace,
instanceName,
"returnInstance",
inParams,
outParams);
PEGASUS_TEST_ASSERT (retValue.getType () == CIMTYPE_OBJECT);
PEGASUS_TEST_ASSERT (!retValue.isArray ());
PEGASUS_TEST_ASSERT (!retValue.isNull ());
CIMObject result;
retValue.get (result);
CIMObjectPath objPath = result.getPath();
CIMInstance inputInstance(result);
CIMInstance outputInstance;
inParams.append(
CIMParamValue(String("inputInstance"), CIMValue(inputInstance)));
retValue = client.invokeMethod (providerNamespace,
instanceName,
"processEmbeddedInstance",
inParams,
outParams);
// First test the return value
PEGASUS_TEST_ASSERT(retValue.getType() == CIMTYPE_INSTANCE);
PEGASUS_TEST_ASSERT(!retValue.isArray());
PEGASUS_TEST_ASSERT(!retValue.isNull());
retValue.get(outputInstance);
PEGASUS_TEST_ASSERT(objPath.toString() ==
outputInstance.getPath().toString());
PEGASUS_TEST_ASSERT(outputInstance.getPropertyCount() ==
inputInstance.getPropertyCount());
for(unsigned int i = 0, n = outputInstance.getPropertyCount(); i < n; ++i)
{
CIMProperty outputProp(outputInstance.getProperty(i));
CIMProperty inputProp(inputInstance.getProperty(i));
PEGASUS_TEST_ASSERT(outputProp.getName() == inputProp.getName());
PEGASUS_TEST_ASSERT(outputProp.getValue() == inputProp.getValue());
}
// Now test the output parameter
PEGASUS_TEST_ASSERT(outParams.size() == 1);
retValue = outParams[0].getValue();
PEGASUS_TEST_ASSERT(retValue.getType() == CIMTYPE_INSTANCE);
PEGASUS_TEST_ASSERT(!retValue.isArray());
PEGASUS_TEST_ASSERT(!retValue.isNull());
retValue.get(outputInstance);
PEGASUS_TEST_ASSERT(objPath.toString() ==
outputInstance.getPath().toString());
PEGASUS_TEST_ASSERT(outputInstance.getPropertyCount() ==
inputInstance.getPropertyCount());
for(unsigned int i = 0, n = outputInstance.getPropertyCount(); i < n; ++i)
{
CIMProperty outputProp(outputInstance.getProperty(i));
CIMProperty inputProp(inputInstance.getProperty(i));
PEGASUS_TEST_ASSERT(outputProp.getName() == inputProp.getName());
PEGASUS_TEST_ASSERT(outputProp.getValue() == inputProp.getValue());
}
}
int retrieveErrorInstance(CIMClient& client)
{
try
{
PEGASUS_STD(cout) << "Getting error instance: " << errorPath.toString()
<< PEGASUS_STD(endl);
CIMInstance ret = client.getInstance(
TEST_NAMESPACE, errorPath, true, false, false, errorPropList);
ret.setPath(errorPath);
if (!errorInstance->identical(ret))
{
if (!ret.getPath().identical(errorInstance->getPath()))
{
PEGASUS_STD(cout) << "Object Paths not identical"
<< PEGASUS_STD(endl);
}
PEGASUS_STD(cout) << "Error Instance and instance retrieved "
<< "through GetInstance operation not the same\n"
<< PEGASUS_STD(endl);
PEGASUS_STD(cout) << "Local Error Instance: "
<< errorInstance->getPath().toString() << PEGASUS_STD(endl);
for (unsigned int i = 0, n = errorInstance->getPropertyCount();
i < n; i++)
{
CIMProperty prop = errorInstance->getProperty(i);
PEGASUS_STD(cout) << i << ". " << prop.getName().getString()
<< prop.getValue().toString() << PEGASUS_STD(endl);
}
PEGASUS_STD(cout) << "Retrieved Error Instance: " <<
ret.getPath().toString() << PEGASUS_STD(endl);
for (unsigned int i = 0, n = ret.getPropertyCount();
i < n; i++)
{
CIMProperty prop = ret.getProperty(i);
PEGASUS_STD(cout) << i << ". " << prop.getName().getString()
<< prop.getValue().toString() << PEGASUS_STD(endl);
}
CIMProperty localEmbeddedProp = errorInstance->getProperty(
errorInstance->findProperty("EmbeddedInst"));
CIMProperty retEmbeddedProp = ret.getProperty(
ret.findProperty("EmbeddedInst"));
CIMInstance localEmbeddedInst;
CIMInstance retEmbeddedInst;
localEmbeddedProp.getValue().get(localEmbeddedInst);
retEmbeddedProp.getValue().get(retEmbeddedInst);
CIMObjectPath localEmbeddedPath = localEmbeddedInst.getPath();
CIMObjectPath retEmbeddedPath = retEmbeddedInst.getPath();
PEGASUS_STD(cout) << "Local Embedded Path: " <<
localEmbeddedPath.toString() << PEGASUS_STD(endl);
PEGASUS_STD(cout) << "Ret Embedded Path: " <<
retEmbeddedPath.toString() << PEGASUS_STD(endl);
return -1;
}
}
catch (Exception& e)
{
cout << "Exception caught while getting error instance: "
<< e.getMessage() << endl;
return -1;
}
try
{
Array<CIMInstance> ret = client.enumerateInstances(
TEST_NAMESPACE,
"PG_EmbeddedError",
true,
true,
false,
false,
errorPropList);
int count = ret.size();
for (int i = 0; i < count; i++)
{
if (!errorInstance->identical(ret[i]))
{
printf("Error instance and instance retrieved through "
"EnumerateInstances operation not the same\n");
return -1;
}
}
}
catch (Exception& e)
{
cout << "Exception caught while enumerating error instances: "
<< e.getMessage() << endl;
return -1;
}
return 0;
}
/////////////////////////////////////////////////////////////////////////////
// WMIInstanceProvider::modifyInstance
//
// ///////////////////////////////////////////////////////////////////////////
void WMIInstanceProvider::modifyInstance(
const String& nameSpace,
const String& userName,
const String& password,
const CIMInstance& modifiedInstance,
Boolean includeQualifiers,
const CIMPropertyList& propertylist)
{
PEG_METHOD_ENTER(TRC_WMIPROVIDER,"WMIClassProvider::modifyInstance()");
HRESULT hr;
CComPtr<IWbemClassObject> pClass;
CComPtr<IWbemClassObject> pInstance;
setup(nameSpace, userName, password);
PEG_TRACE((TRC_WMIPROVIDER,
Tracer::LEVEL3,
"ModifyInstance() - nameSpace %s, userName %s",
nameSpace.getCString(),
userName.getCString()));
if (!m_bInitialized)
{
PEG_TRACE((TRC_WMIPROVIDER, Tracer::LEVEL1,
"WMIInstanceProvider::ModifyInstance - m_bInitilized= %x, "
"throw CIM_ERR_FAILED exception",
m_bInitialized));
throw CIMException(CIM_ERR_FAILED);
}
// Check if the instance's class is valid.
String className = modifiedInstance.getClassName().getString();
if (!(_collector->getObject(&pClass, className)))
{
if (pClass)
pClass.Release();
throw CIMException(CIM_ERR_INVALID_CLASS);
}
else if (_collector->isInstance(pClass))
{
if (pClass)
pClass.Release();
throw CIMException(CIM_ERR_INVALID_PARAMETER);
}
if (pClass)
pClass.Release();
// Get the instance path
CIMObjectPath objPath = modifiedInstance.getPath();
// Get the name of the instance
String instanceName = getObjectName(objPath);
// Check if the instance exists
if (!(_collector->getObject(&pInstance, instanceName)))
{
if (pInstance)
pInstance.Release();
throw CIMException(CIM_ERR_NOT_FOUND);
}
else if (!(_collector->isInstance(pInstance)))
{
if (pInstance)
pInstance.Release();
throw CIMException(CIM_ERR_INVALID_PARAMETER);
}
// Set the properties that are into propertylist
Array<CIMName> listNames;
listNames = propertylist.getPropertyNameArray();
bool foundInArray;
bool bPropertySet = false;
for(Uint32 i = 0; i < modifiedInstance.getPropertyCount(); i++)
{
CComVariant v;
CIMProperty property = modifiedInstance.getProperty(i).clone();
String sPropName = property.getName().getString();
// change only the properties defined into the array
// if the array is null, change all properties
if (propertylist.isNull())
{
foundInArray = true;
}
else
{
foundInArray = false;
for (Uint32 j = 0; (j < listNames.size()) && !foundInArray; j++)
//if (listNames[j].getString() == str)
if (String::equalNoCase(listNames[j].getString(), sPropName))
foundInArray = true;
}
if (foundInArray)
{
WMIValue propertyValue = property.getValue();
try
{
propertyValue.getAsVariant(&v,nameSpace, userName, password);
}
catch (CIMException&)
{
if (pInstance)
pInstance.Release();
v.Clear();
throw;
}
CComBSTR bs = sPropName.getCString();
hr = pInstance->Put(bs, 0, &v, 0);
v.Clear();
// If we fail to set one property, we must assure
// that the others will be processed
if(SUCCEEDED(hr))
{
// Mark that at least one property was set
bPropertySet = true;
}
}
}
// Check if at least one property was set
// otherwise throw invalid parameter error
if(!bPropertySet)
{
PEG_TRACE((TRC_WMIPROVIDER,
Tracer::LEVEL1,
"modifyInstance() - Put Failed hr=0x%x.",
hr));
throw CIMException(CIM_ERR_FAILED);
}
// Connect to the server
CComPtr<IWbemServices> pServices;
bool bConnected = _collector->Connect(&pServices);
if (!bConnected)
{
throw CIMException(CIM_ERR_ACCESS_DENIED);
}
// Write the instance to WMI.
hr = pServices->PutInstance(pInstance,
WBEM_FLAG_UPDATE_ONLY,
NULL,
NULL);
if (pInstance)
pInstance.Release();
if (pServices)
pServices.Release();
if(FAILED(hr))
{
switch(hr)
{
case E_ACCESSDENIED:
throw CIMException(CIM_ERR_ACCESS_DENIED);
break;
case WBEM_E_ACCESS_DENIED:
throw CIMException(CIM_ERR_ACCESS_DENIED);
break;
case WBEM_E_NOT_FOUND:
throw CIMException(CIM_ERR_NOT_FOUND);
break;
case WBEM_E_INVALID_CLASS:
throw CIMException(CIM_ERR_INVALID_CLASS);
break;
case WBEM_E_INVALID_OBJECT:
throw CIMException(CIM_ERR_INVALID_PARAMETER);
break;
default:
throw CIMException(CIM_ERR_FAILED);
}
}
PEG_METHOD_EXIT();
return;
}
