void UNIX_BGPEndpointStatisticsProvider::invokeMethod(
const OperationContext& context,
const CIMObjectPath& objectReference,
const CIMName& methodName,
const Array<CIMParamValue>& inParameters,
MethodResultResponseHandler& handler)
{
if (!objectReference.getClassName().equal("UNIX_BGPEndpointStatistics") && !objectReference.getClassName().equal("CIM_BGPEndpointStatistics")) {
String classMessage;
classMessage.append("UNIX_BGPEndpointStatistics Provider");
classMessage.append (" does not support class ");
classMessage.append (objectReference.getClassName().getString());
throw CIMNotSupportedException(classMessage);
}
handler.processing();
// Make cimom handle invokeMethod request with input parameters.
CIMObjectPath localReference = CIMObjectPath(
String(""),
CIMNamespaceName("root/cimv2"),
objectReference.getClassName(),
objectReference.getKeyBindings());
if (methodName.equal("ResetSelectedStats")) {
if (inParameters.size() != 1)
{
throw new CIMOperationFailedException("Incorrect in parameters");
}
//Invoking ResetSelectedStats method.
Uint32 invokeResetSelectedStatsReturnValue;
Array<String> inSelectedStatistics;
for(Uint32 pi = 0; pi < inParameters.size(); pi++) {
CIMParamValue p = inParameters[pi];
if (String::equalNoCase(p.getParameterName(), "SelectedStatistics"))
{
p.getValue().get(inSelectedStatistics);
}
}
_p.initialize();
_p.find(localReference.getKeyBindings());
invokeResetSelectedStatsReturnValue = _p.invokeResetSelectedStats(
inSelectedStatistics
);
_p.finalize();
handler.deliver(invokeResetSelectedStatsReturnValue);
}
else {
String message;
message.append("UNIX_BGPEndpointStatistics");
message.append (" does not support invokeMethod");
throw CIMNotSupportedException(message);
}
}
void TimingProvider::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(),
String(),
instanceReference.getClassName(),
instanceReference.getKeyBindings());
cout <<"TimingProvider::modifyInstance" << endl;
// begin processing the request
handler.processing();
// instance index corresponds to reference index
for(Uint32 i = 0, n = _instances.size(); i < n; i++)
{
if(localReference == _instanceNames[i])
{
// overwrite existing instance
_instances[i] = instanceObject;
break;
}
}
// complete processing the request
handler.complete();
}
void IBM_CIMOMStatDataProvider::getInstance(
const OperationContext & context,
const CIMObjectPath & instanceReference,
const Boolean includeQualifiers,
const Boolean includeClassOrigin,
const CIMPropertyList & propertyList,
InstanceResponseHandler & handler)
{
CIMObjectPath localReference = CIMObjectPath(
String::EMPTY,
CIMNamespaceName(),
instanceReference.getClassName(),
instanceReference.getKeyBindings());
// begin processing the request
handler.processing();
// instance index corresponds to reference index
for(Uint32 i = 0; i < StatisticalData::NUMBER_OF_TYPES; i++)
{ // cout << "loop" << endl;
if(localReference == _references[i])
{
// deliver requested instance
handler.deliver(getInstance(i));
break;
}
}
// complete processing the request
handler.complete();
}
static void _BubbleSort(Array<CIMKeyBinding>& x)
{
Uint32 n = x.size();
//
// If the key is a reference, the keys in the reference must also be
// sorted
//
for (Uint32 k = 0; k < n ; k++)
if (x[k].getType () == CIMKeyBinding::REFERENCE)
{
CIMObjectPath tmp (x[k].getValue ());
Array <CIMKeyBinding> keyBindings = tmp.getKeyBindings ();
_BubbleSort (keyBindings);
tmp.setKeyBindings (keyBindings);
x[k].setValue (tmp.toString ());
}
if (n < 2)
return;
for (Uint32 i = 0; i < n - 1; i++)
{
for (Uint32 j = 0; j < n - 1; j++)
{
if (String::compareNoCase(x[j].getName().getString(),
x[j+1].getName().getString()) > 0)
{
CIMKeyBinding t = x[j];
x[j] = x[j+1];
x[j+1] = t;
}
}
}
}
void _getKeyValue (
const CIMObjectPath& instanceName,
CIMNamespaceName& childNamespaceName,
Boolean& isRelativeName)
{
Array<CIMKeyBinding> kbArray = instanceName.getKeyBindings();
if ((kbArray.size() == 1) &&
(kbArray[0].getName() == NAMESPACE_PROPERTYNAME))
{
String childNamespaceString = kbArray[0].getValue();
if (childNamespaceString != String::EMPTY)
{
childNamespaceName = childNamespaceString;
}
isRelativeName = !(childNamespaceName.isNull());
}
else
{
//l10n
//throw CIMInvalidParameterException("Invalid key property: ");
throw CIMInvalidParameterException(MessageLoaderParms(
"ControlProviders.NamespaceProvider.NamespaceProvider.INVALID_KEY_PROPERTY",
"Invalid key property: "));
}
}
void InstanceProvider::deleteInstance(
const OperationContext & context,
const CIMObjectPath & instanceReference,
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())
{
// remove instance from the array
_instances.remove(i);
break;
}
}
// complete processing the request
handler.complete();
}
void LargeDataProvider::getInstance(
const OperationContext & context,
const CIMObjectPath & instanceReference,
const Boolean includeQualifiers,
const Boolean includeClassOrigin,
const CIMPropertyList & propertyList,
InstanceResponseHandler & handler)
{
cout << "------------------------------" << endl;
cout << "LargeDataProvider::getInstance" << endl;
cout << "------------------------------" << endl;
// convert a potential fully qualified reference into a local reference
// (class name and keys only).
CIMObjectPath localReference = CIMObjectPath(
String(),
String(),
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 == _instanceNames[i])
{
// deliver requested instance
handler.deliver(_instances[i]);
break;
}
}
// complete processing the request
handler.complete();
}
void ComputerSystemProvider::getInstance(
const OperationContext& context,
const CIMObjectPath& ref,
const Boolean includeQualifiers,
const Boolean includeClassOrigin,
const CIMPropertyList& propertyList,
InstanceResponseHandler &handler)
{
CIMName className = ref.getClassName();
_checkClass(className);
Array<CIMKeyBinding> keys = ref.getKeyBindings();
//-- make sure we're the right instance
unsigned int keyCount = NUMKEYS_COMPUTER_SYSTEM;
CIMName keyName;
String keyValue;
if (keys.size() != keyCount)
{
throw CIMInvalidParameterException("Wrong number of keys");
}
for (unsigned int ii = 0; ii < keys.size(); ii++)
{
keyName = keys[ii].getName();
keyValue = keys[ii].getValue();
//Put CLASS_EXTENDED_COMPUTER_SYSTEM in front CLASS_CIM_COMPUTER_SYSTEM
//to prefer CLASS_EXTENDED_COMPUTER_SYSTEM as class being served first
//followed by CLASS_CIM_UNITARY_COMPUTER_SYSTEM
if (keyName.equal(PROPERTY_CREATION_CLASS_NAME) &&
(String::equalNoCase(keyValue,CLASS_EXTENDED_COMPUTER_SYSTEM) ||
String::equalNoCase(keyValue,CLASS_CIM_UNITARY_COMPUTER_SYSTEM) ||
String::equalNoCase(keyValue,CLASS_CIM_COMPUTER_SYSTEM) ||
String::equalNoCase(keyValue,String::EMPTY)))
{
keyCount--;
}
else if (keyName.equal("Name") &&
String::equalNoCase(keyValue,_cs.getHostName()))
{
keyCount--;
}
}
if (keyCount)
{
throw CIMInvalidParameterException(String::EMPTY);
}
// return instance of specified class
CIMInstance instance = _cs.buildInstance(ref.getClassName());
handler.processing();
handler.deliver(instance);
handler.complete();
return;
}
void AuditLogger::logUpdateInstanceOperation(
const char* cimMethodName,
AuditEvent eventType,
const String& userName,
const String& ipAddr,
const CIMNamespaceName& nameSpace,
const CIMObjectPath& instanceName,
const String& moduleName,
const String& providerName,
CIMStatusCode statusCode)
{
// check if SMF is gathering this type of records.
if (_smf.isRecording(CIM_OPERATION) ||
(! _isInternalWriterUsed) )
{
String cimInstanceName =
CIMObjectPath("", CIMNamespaceName(), instanceName.getClassName(),
instanceName.getKeyBindings()).toString();
_writeCIMOperationRecord(
INSTANCE_OPERATION, userName, statusCode,
ipAddr, cimMethodName, cimInstanceName,
nameSpace.getString(), providerName, moduleName );
}
}
void ANHProvider::references(
const OperationContext& context,
const CIMObjectPath& objectName,
const CIMName& resultClass,
const String& role,
const Boolean includeQualifiers,
const Boolean includeClassOrigin,
const CIMPropertyList& propertyList,
ObjectResponseHandler& handler)
{
// validate namespace
const CIMNamespaceName& nameSpace = objectName.getNameSpace();
if (!nameSpace.equal(NAMESPACE))
{
throw CIMNotSupportedException(
nameSpace.getString() + " not supported.");
}
// Build a host and namespace independent object path
CIMObjectPath localObjectPath = CIMObjectPath(
String(),
CIMNamespaceName(),
objectName.getClassName(),
objectName.getKeyBindings());
// begin processing the request
handler.processing();
// Filter the instances from the list of association instances against
// the specified role filter
//
Array<CIMInstance> resultInstances;
if (resultClass == CLASS_PG_ASSOCIATED_NEXT_HOP)
{
resultInstances =
_filterAssociationInstancesByRole(
_AssociationInstances,
localObjectPath,
role);
}
else
{
throw CIMNotSupportedException(
resultClass.getString() + " is not supported");
}
// return the instances
for (Uint32 i = 0, n = resultInstances.size(); i < n; i++)
{
handler.deliver(resultInstances[i]);
}
// complete processing the request
handler.complete();
}
void DefaultInstanceProvider::deleteInstance(
const OperationContext & context,
const CIMObjectPath & instanceReference,
ResponseHandler & handler)
{
CIMNamespaceName nameSpace = instanceReference.getNameSpace();
// get the class name
CIMName className = instanceReference.getClassName();
// create the namespace if necessary
if (!_nameSpaceExists(nameSpace))
{
_copyNameSpace(nameSpace.getString(), className.getString());
}
// check to see if class already exists
// if not, copy the class
//
try
{
CIMClass cimClass = _repository->getClass(nameSpace, className);
}
catch (Exception&)
{
// Class does not exist. Copy the class.
//
_copyClass(nameSpace.getString(), className.getString());
}
// convert a potential fully qualified reference into a local reference
// (class name and keys only).
CIMObjectPath localReference = CIMObjectPath(
String(),
String(),
instanceReference.getClassName(),
instanceReference.getKeyBindings());
// begin processing the request
handler.processing();
try
{
_repository->deleteInstance(nameSpace, localReference);
}
catch (Exception & ex)
{
const String msg = "delete Instance failed. " + ex.getMessage();
throw CIMOperationFailedException( msg );
}
// complete processing the request
handler.complete();
}
void ANHProvider::associators(
const OperationContext& context,
const CIMObjectPath& objectName,
const CIMName& associationClass,
const CIMName& resultClass,
const String& role,
const String& resultRole,
const Boolean includeQualifiers,
const Boolean includeClassOrigin,
const CIMPropertyList& propertyList,
ObjectResponseHandler& handler)
{
// validate namespace
const CIMNamespaceName& nameSpace = objectName.getNameSpace();
if (!nameSpace.equal(NAMESPACE))
{
throw CIMNotSupportedException(
nameSpace.getString() + " not supported.");
}
// Build a host and namespace independent object path
CIMObjectPath localObjectPath = CIMObjectPath(
String(),
CIMNamespaceName(),
objectName.getClassName(),
objectName.getKeyBindings());
// begin processing the request
handler.processing();
if (associationClass == CLASS_PG_ASSOCIATED_NEXT_HOP)
{
_associators(
_AssociationInstances,
localObjectPath,
role,
resultClass,
resultRole,
handler);
}
else
{
throw CIMNotSupportedException(
associationClass.getString() + " is not supported");
}
// complete processing the request
handler.complete();
}
Boolean isValid(const CIMObjectPath & cimObjectPath)
{
if(!String::equalNoCase(cimObjectPath.getClassName().getString(), CLASSNAME))
{
return(false);
}
if(cimObjectPath.getKeyBindings().size() == 0) // singleton?
{
return(false);
}
return(true);
}
void MethodProvider::invokeMethod(
const OperationContext & context,
const CIMObjectPath & objectReference,
const CIMName & methodName,
const Array<CIMParamValue> & inParameters,
MethodResultResponseHandler & handler)
{
// convert a fully qualified reference into a local reference
// (class name and keys only).
CIMObjectPath localReference = CIMObjectPath(
String(),
CIMNamespaceName(),
objectReference.getClassName(),
objectReference.getKeyBindings());
handler.processing();
if (objectReference.getClassName().equal("Sample_MethodProviderClass"))
{
if (methodName.equal("SayHello"))
{
String outString = "Hello";
if (inParameters.size() > 0)
{
CIMValue paramVal = inParameters[0].getValue();
if (!paramVal.isNull())
{
String replyName;
paramVal.get(replyName);
if (replyName != String::EMPTY)
{
outString.append(", " + replyName + "!");
}
}
handler.deliverParamValue(
CIMParamValue("Place",
CIMValue(String("From Neverland"))));
handler.deliver(CIMValue(outString));
}
else
{
handler.deliver(CIMValue(outString));
}
}
}
handler.complete();
}
void
LinuxNetworkAdapterProvider::getInstance(const OperationContext& context,
const CIMObjectPath& ref,
const Boolean includeQualifiers,
const Boolean includeClassOrigin,
const CIMPropertyList& propertyList,
InstanceResponseHandler& handler)
{
Array<CIMKeyBinding> keys = ref.getKeyBindings();
Uint32 i;
NetworkAdapterData* located_interface;
String unique_name;
CIMName className;
enum network_provider_types classType;
className = ref.getClassName();
if (className.equal("Linux_EthernetAdapter"))
{
classType = NETWORK_ADAPTER_PROVIDER_ETHERNET;
}
else if (className.equal("Linux_NetworkAdapter"))
{
classType = NETWORK_ADAPTER_PROVIDER_OTHER;
}
else
{
throw CIMNotSupportedException(className.getString() + "::getInstance");
}
for (i = 0; i < keys.size(); i++)
if (keys[i].getName() == CIMName("Name"))
unique_name = keys[i].getValue();
handler.processing();
located_interface = LocateInterface(unique_name);
if (located_interface != NULL && interface_is_my_type(classType,located_interface))
{
CIMInstance instance = build_instance(className, classType, located_interface);
handler.deliver(instance);
}
delete located_interface;
handler.complete();
return;
}
void ParserTestProvider::getInstance(
const OperationContext & context,
const CIMObjectPath & instanceReference,
const Boolean includeQualifiers,
const Boolean includeClassOrigin,
const CIMPropertyList & propertyList,
InstanceResponseHandler & handler)
{
String Value;
char csname[256];
int cnum;
char badstrname[256];
cout << "ParserTestProvider::getInstance" << endl;
CIMName className = instanceReference.getClassName();
CIMNamespaceName nameSpace = instanceReference.getNameSpace();
Array<CIMKeyBinding> keys = instanceReference.getKeyBindings();
for (int i = 0; i < (int)keys.size(); i++)
{
CIMName cimName = keys[i].getName();
Value = keys[i].getValue();
if (cimName.equal("BadStringName")) {
strncpy(badstrname, Value.getCString(), 256);
}
}
CIMInstance instance(CLASS_NAME);
instance.setPath(CIMObjectPath(String::EMPTY, // hostname
nameSpace,
CLASS_NAME,
keys));
instance.addProperty(CIMProperty("CName",
String(CLASS_NAME)));
instance.addProperty(CIMProperty("BadStringName",
String(badstrname)));
//begin processing the request
handler.processing();
handler.deliver(instance);
// complete processing the request
handler.complete();
}
void RUEpProvider::associatorNames(
const OperationContext& context,
const CIMObjectPath& objectName,
const CIMName& associationClass,
const CIMName& resultClass,
const String& role,
const String& resultRole,
ObjectPathResponseHandler& handler)
{
// validate namespace
const CIMNamespaceName& nameSpace = objectName.getNameSpace();
if (!nameSpace.equal(NAMESPACE))
{
throw CIMNotSupportedException(
nameSpace.getString() + " not supported.");
}
// Build a host and namespace independent object path
CIMObjectPath localObjectPath = CIMObjectPath(
String(),
CIMNamespaceName(),
objectName.getClassName(),
objectName.getKeyBindings());
// begin processing the request
handler.processing();
if (associationClass == CLASS_PG_ROUTE_USES_ENDPOINT)
{
_associatorNames(
_AssociationInstances,
localObjectPath,
role,
resultClass,
resultRole,
handler);
}
else
{
throw CIMNotSupportedException(
associationClass.getString() + " is not supported");
}
// complete processing the request
handler.complete();
}
void _checkFilterOrHandlerPath
(const CIMObjectPath & path, const CIMName & className, const String & name)
{
PEGASUS_ASSERT (path.getClassName () == className);
Array < CIMKeyBinding > keyBindings = path.getKeyBindings ();
Boolean SCCNfound = false;
Boolean SNfound = false;
Boolean CCNfound = false;
Boolean Nfound = false;
for (Uint32 i = 0; i < keyBindings.size (); i++)
{
if (keyBindings[i].getName ().equal ("SystemCreationClassName"))
{
SCCNfound = true;
PEGASUS_ASSERT (keyBindings[i].getValue () ==
System::getSystemCreationClassName ());
}
else if (keyBindings[i].getName ().equal ("SystemName"))
{
SNfound = true;
PEGASUS_ASSERT (keyBindings[i].getValue () ==
System::getFullyQualifiedHostName ());
}
else if (keyBindings[i].getName ().equal ("CreationClassName"))
{
CCNfound = true;
PEGASUS_ASSERT (keyBindings[i].getValue () ==
className.getString ());
}
else if (keyBindings[i].getName ().equal ("Name"))
{
Nfound = true;
PEGASUS_ASSERT (keyBindings[i].getValue () == name);
}
else
{
PEGASUS_ASSERT (false);
}
}
PEGASUS_ASSERT (SCCNfound);
PEGASUS_ASSERT (SNfound);
PEGASUS_ASSERT (CCNfound);
PEGASUS_ASSERT (Nfound);
}
CIMInstance ProviderIndicationCountTable::getProviderIndicationDataInstance(
const CIMObjectPath& instanceName)
{
PEG_METHOD_ENTER(TRC_INDICATION_SERVICE,
"ProviderIndicationCountTable::getProviderIndicationDataInstance");
//
// Gets provider module name and provider name from the provider indication
// data instance object path
//
String providerModuleName;
String providerName;
Array<CIMKeyBinding> keys = instanceName.getKeyBindings();
for (Uint32 i = 0; i < keys.size(); i++)
{
if (keys[i].getName() == _PROPERTY_PROVIDERNAME)
{
providerName = keys[i].getValue();
}
else if (keys[i].getName() == _PROPERTY_PROVIDERMODULENAME)
{
providerModuleName = keys[i].getValue();
}
}
String providerKey = _generateKey(providerModuleName, providerName);
_ProviderIndicationCountTableEntry entry;
WriteLock lock(_tableLock);
if (_table.lookup(providerKey, entry))
{
CIMInstance providerIndDataInstance =
_buildProviderIndDataInstance(entry);
PEG_METHOD_EXIT();
return providerIndDataInstance;
}
PEG_METHOD_EXIT();
throw CIMObjectNotFoundException(instanceName.toString());
}
/**
_validateKeys method of the OS provider Test Client
*/
void OSTestClient::_validateKeys(CIMObjectPath &cimRef,
Boolean verboseTest)
{
// don't have a try here - want it to be caught by caller
Array<CIMKeyBinding> keyBindings = cimRef.getKeyBindings();
if (verboseTest)
cout << "Retrieved " << keyBindings.size() << " keys" <<endl;
for (Uint32 j = 0; j < keyBindings.size(); j++)
{
CIMName keyName = keyBindings[j].getName();
if (verboseTest)
cout << "checking key " << keyName << endl;
if (((keyName.equal ("CSCreationClassName")) &&
(goodCSCreationClassName(
keyBindings[j].getValue(),
verboseTest) == false)))
{
errorExit ("CSCreationClassName not CIM_UnitaryComputerSystem");
}
else if ((keyName.equal ("CSName")) &&
(goodCSName(keyBindings[j].getValue(),
verboseTest) == false))
{
errorExit ("CSName not correct");
}
else if ((keyName.equal ("CreationClassName")) &&
(goodCreationClassName(
keyBindings[j].getValue(),
verboseTest) == false))
{
errorExit ("CreationClassName not correct");
}
else if ((keyName.equal ("Name")) &&
(goodName(
keyBindings[j].getValue(),
verboseTest) == false))
{
errorExit ("Name not correct");
}
} // end for j looping through properties
}
void ExceptionsTest::getInstance(
const OperationContext & context,
const CIMObjectPath & instanceReference,
const Boolean includeQualifiers,
const Boolean includeClassOrigin,
const CIMPropertyList & propertyList,
InstanceResponseHandler & handler)
{
// convert a potential fully qualified reference into a local reference
// (class name and keys only).
CIMObjectPath localReference = CIMObjectPath(
String(),
String(),
instanceReference.getClassName(),
instanceReference.getKeyBindings());
CIMName className = instanceReference.getClassName();
// begin processing the request
handler.processing();
cout <<"Calling Exception ExceptionsTest::getInstance 1" << endl;
CheckExceptionType(EXCEPTION_TYPE);
if (className == CIMName("FirstClass"))
{
// instance index corresponds to reference index
for(Uint32 i = 0, n = _instances.size(); i < n; i++)
{
if(localReference == _instanceNames[i])
{
// deliver requested instance
handler.deliver(_instances[i]);
break;
}
}
}
// complete processing the request
handler.complete();
cout <<"Calling Exception ExceptionsTest::getInstance 2" << endl;
CheckExceptionType(EXCEPTION_TYPE);
}
void LargeDataProvider::createInstance(
const OperationContext & context,
const CIMObjectPath & instanceReference,
const CIMInstance & instanceObject,
ObjectPathResponseHandler & handler)
{
cout << "---------------------------------" << endl;
cout << "LargeDataProvider::createInstance" << endl;
cout << "---------------------------------" << endl;
// convert a potential fully qualified reference into a local reference
// (class name and keys only).
CIMObjectPath localReference = CIMObjectPath(
String(),
String(),
instanceReference.getClassName(),
instanceReference.getKeyBindings());
// instance index corresponds to reference index
for(Uint32 i = 0, n = _instanceNames.size(); i < n; i++)
{
if(localReference == _instanceNames[i])
{
throw CIMObjectAlreadyExistsException(
localReference.toString());
}
}
// begin processing the request
handler.processing();
// add the new instance to the array
_instances.append(instanceObject);
_instanceNames.append(instanceReference);
// deliver the new instance
handler.deliver(_instanceNames[_instanceNames.size() - 1]);
// complete processing the request
handler.complete();
}
/**
_validateKeys method of the NIS provider Test Client
*/
void NISTestClient::_validateKeys(
CIMObjectPath &cimRef,
Boolean verboseTest)
{
// don't have a try here - want it to be caught by caller
String keyVal;
CIMName keyName;
Array<CIMKeyBinding> keyBindings = cimRef.getKeyBindings();
if (verboseTest)
cout << "Retrieved " << keyBindings.size() << " keys" <<endl;
for (Uint32 j = 0; j < keyBindings.size(); j++)
{
keyName = keyBindings[j].getName();
keyVal = keyBindings[j].getValue();
if (verboseTest)
cout << "checking key " << keyName.getString() << endl;
if (keyName.equal("CreationClassName") &&
!goodCreationClassName(keyVal, verboseTest))
{
errorExit ("CreationClassName not PG_NISServerService");
}
else if (keyName.equal("Name") &&
!goodName(keyVal, verboseTest))
{
errorExit ("Name not correct");
}
else if (keyName.equal("SystemCreationClassName") &&
!goodSystemCreationClassName(keyVal, verboseTest))
{
errorExit ("SystemCreationClassName not correct");
}
else if (keyName.equal("SystemName") &&
!goodSystemName(keyVal, verboseTest))
{
errorExit ("SystemName not correct");
}
}
}
/* SystemName key property should be set to fully qualified hostname
which is set on cimserver at startup to "hugo.bert" before this test case
is executed
*/
void testFilterSystemName(
CIMClient & client)
{
CIMInstance filter("CIM_IndicationFilter");
String query("SELECT * FROM CIM_ProcessIndication");
filter.addProperty(
CIMProperty(CIMName("Name"),String("Filter01")));
filter.addProperty(
CIMProperty(CIMName("SourceNamespace"),String("root/SampleProvider")));
filter.addProperty(
CIMProperty(CIMName("Query"), query));
filter.addProperty(
CIMProperty(CIMName("QueryLanguage"),String("WQL")));
CIMObjectPath path =
client.createInstance(PEGASUS_NAMESPACENAME_INTEROP, filter);
client.deleteInstance(PEGASUS_NAMESPACENAME_INTEROP, path);
// SystemName is fourth (=last) keybinding
Array<CIMKeyBinding> keys = path.getKeyBindings();
CIMKeyBinding sysName=keys[3];
if (verbose)
{
cout << "SystemName returned is: " << sysName.getValue() << endl;
}
Boolean result = String("hugo.bert") == sysName.getValue();
if(!result)
{
cout << "Test failed, Make sure that cimserver is started " \
"with \"hostname=hugo fullyQualifiedHostName=hugo.bert\"" \
<< endl;
}
PEGASUS_TEST_ASSERT(result);
}
void benchmarkProvider::getInstance(
const OperationContext & context,
const CIMObjectPath & instanceReference,
const Boolean includeQualifiers,
const Boolean includeClassOrigin,
const CIMPropertyList & propertyList,
InstanceResponseHandler & handler)
{
CIMInstance _instance;
Uint32 numberOfProperties;
Uint32 sizeOfPropertyValue;
Uint32 numberOfInstances;
CIMName className = instanceReference.getClassName();
test.getConfiguration(className, numberOfProperties,
sizeOfPropertyValue, numberOfInstances);
Array<CIMKeyBinding> keyBindings = instanceReference.getKeyBindings();
if (keyBindings.size() != 1)
{
throw CIMException(CIM_ERR_NOT_SUPPORTED);
}
// begin processing the request
handler.processing();
Uint32 ID;
if (sscanf (keyBindings[0].getValue().getCString(), "%u", &ID) != 1)
{
throw CIMException (CIM_ERR_INVALID_PARAMETER);
}
_instance = _buildInstance(className, numberOfProperties,
sizeOfPropertyValue , CIMValue(ID));
handler.deliver(_instance);
// complete processing the request
handler.complete();
}
void ExceptionsTest::deleteInstance(
const OperationContext & context,
const CIMObjectPath & instanceReference,
ResponseHandler & handler)
{
// convert a potential fully qualified reference into a local reference
// (class name and keys only).
CIMObjectPath localReference = CIMObjectPath(
String(),
String(),
instanceReference.getClassName(),
instanceReference.getKeyBindings());
// begin processing the request
handler.processing();
cout <<"Calling Exception ExceptionsTest::deleteInstance 1" << endl;
CheckExceptionType(EXCEPTION_TYPE);
// instance index corresponds to reference index
for(Uint32 i = 0, n = _instances.size(); i < n; i++)
{
if(localReference == _instanceNames[i])
{
// save the instance locally
CIMInstance cimInstance(_instances[i]);
// remove instance from the array
_instances.remove(i);
_instanceNames.remove(i);
// exit loop
break;
}
}
cout <<"Calling Exception ExceptionsTest::deleteInstance 2" << endl;
CheckExceptionType(EXCEPTION_TYPE);
// complete processing the request
handler.complete();
}
void testEnumInstances(CIMClient& client, const char* ns)
{
Array<CIMInstance> instances;
instances = client.enumerateInstances(ns,CIM_QUERYCAPCLASS_NAME);
if(instances.size() != 1) throw Exception("instances.size() incorrect");
Array<Uint16> providerReturnedVal;
//Array<Uint16> actualVal(NUM_QUERY_CAPABILITIES);
Uint32 prop = 0;
CIMObjectPath path;
path = instances[0].getPath();
Array<CIMKeyBinding> keys = path.getKeyBindings();
//-- make sure we're the right instance
CIMName keyName;
String keyValue;
if (keys.size() != NUM_KEY_PROPERTIES)
throw Exception("Wrong number of keys");
keyName = keys[0].getName();
keyValue = keys[0].getValue();
if(keyName.getString() != String(PROPERTY_NAME_INSTANCEID) )
throw Exception("Incorrect Key");
if(keyValue != String(INSTANCEID_VALUE))
throw Exception(keyValue);
prop = instances[0].findProperty(CIMName(PROPERTY_NAME_CQLFEATURES));
instances[0].getProperty(prop).getValue().get(providerReturnedVal);
_checkIfReturnedValueIsCorrect(providerReturnedVal);
}
void LinuxDiskDriveProvider::getInstance(const OperationContext& context,
const CIMObjectPath& ref,
const Boolean includeQualifiers,
const Boolean includeClassOrigin,
const CIMPropertyList& propertyList,
InstanceResponseHandler& handler)
{
DiskDriveData diskdriveData;
MediaAccessDeviceInformation *curDiskDrive;
Array<CIMKeyBinding> keys = ref.getKeyBindings();
Uint32 i;
String nameString;
handler.processing();
/* Get the diskdrive that was requested */
i = 0;
while (i < keys.size())
{
if (keys[i].getName() == CIMName("Name"))
nameString = keys[i].getValue();
i++;
}
if (nameString != String::EMPTY)
{
curDiskDrive = diskdriveData.GetDiskDrive(nameString);
if (curDiskDrive!=NULL)
{
CIMInstance instance =
build_instance(DISKDRIVECLASSNAME, curDiskDrive);
handler.deliver(instance);
delete curDiskDrive;
}
}
handler.complete();
return;
}
void AuditLogger::logInvokeMethodOperation(
const String& userName,
const String& ipAddr,
const CIMNamespaceName& nameSpace,
const CIMObjectPath& objectName,
const CIMName& methodName,
const String& moduleName,
const String& providerName,
CIMStatusCode statusCode)
{
// check if SMF is gathering this type of records.
if (_smf.isRecording(CIM_OPERATION) ||
(! _isInternalWriterUsed) )
{
String cimObjectName =
CIMObjectPath("", CIMNamespaceName(), objectName.getClassName(),
objectName.getKeyBindings()).toString();
_writeCIMOperationRecord(
INVOKE_METHOD, userName, statusCode,
ipAddr, methodName.getString(), cimObjectName,
nameSpace.getString(), providerName,moduleName );
}
}
void _checkSubscriptionPath
(const CIMObjectPath & path,
const String & filterName,
const CIMName & handlerClass, const String & handlerName)
{
PEGASUS_ASSERT (path.getClassName () == PEGASUS_CLASSNAME_INDSUBSCRIPTION);
Array < CIMKeyBinding > keyBindings = path.getKeyBindings ();
Boolean filterFound = false;
Boolean handlerFound = false;
for (Uint32 i = 0; i < keyBindings.size (); i++)
{
if (keyBindings[i].getName ().equal ("Filter"))
{
filterFound = true;
CIMObjectPath filterPath = _buildFilterOrHandlerPath
(PEGASUS_CLASSNAME_INDFILTER, filterName);
PEGASUS_ASSERT (keyBindings[i].getValue () ==
filterPath.toString ());
}
else if (keyBindings[i].getName ().equal ("Handler"))
{
handlerFound = true;
CIMObjectPath handlerPath = _buildFilterOrHandlerPath
(handlerClass, handlerName);
PEGASUS_ASSERT (keyBindings[i].getValue () ==
handlerPath.toString ());
}
else
{
PEGASUS_ASSERT (false);
}
}
PEGASUS_ASSERT (filterFound);
PEGASUS_ASSERT (handlerFound);
}
