/**
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
}
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;
}
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;
}
Boolean UNIX_BGPServiceAttributes::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(), "GroupComponent"))
{
CIMInstance groupComponentValue;
property.getValue().get(groupComponentValue);
setGroupComponent(groupComponentValue);
}
else if (String::equal(property.getName().getString(), "PartComponent"))
{
CIMInstance partComponentValue;
property.getValue().get(partComponentValue);
setPartComponent(partComponentValue);
}
}
return true;
}
Boolean UNIX_AssociatedTargetMaskingGroup::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(), "Antecedent"))
{
CIMInstance antecedentValue;
property.getValue().get(antecedentValue);
setAntecedent(antecedentValue);
}
else if (String::equal(property.getName().getString(), "Dependent"))
{
CIMInstance dependentValue;
property.getValue().get(dependentValue);
setDependent(dependentValue);
}
}
return true;
}
Boolean UNIX_BGPServiceStatistics::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(), "Stats"))
{
CIMInstance statsValue;
property.getValue().get(statsValue);
setStats(statsValue);
}
else if (String::equal(property.getName().getString(), "Element"))
{
CIMInstance elementValue;
property.getValue().get(elementValue);
setElement(elementValue);
}
}
return true;
}
/**
***************************************************************************
_filterAssociationInstancesByRole is used to filter the list of association
instances against the specified role filter. It returns a list of
association instances that pass the filter test.
@param associationInstance - The target association instances
@param targetObjectPath - The target ObjectPath
@param role - The role filter. If there is no role, this
is String::EMPTY
@return the set of association instances that pass the filter test.
***************************************************************************
*/
Array<CIMInstance> ANHProvider::_filterAssociationInstancesByRole(
const Array<CIMInstance>& associationInstances,
const CIMObjectPath& targetObjectPath,
const String& role)
{
Array<CIMInstance> returnInstances;
// Filter the instances from the list of association instances against
// the specified role filter
//
for (Uint32 i = 0, n = associationInstances.size(); i < n; i++)
{
CIMInstance instance = associationInstances[i];
// Search the association instance for all reference properties
for (Uint32 j = 0, m = instance.getPropertyCount(); j < m; j++)
{
const CIMProperty p = instance.getProperty(j);
if (p.getType() == CIMTYPE_REFERENCE)
{
CIMValue v = p.getValue();
CIMObjectPath path;
v.get(path);
if ((role == String::EMPTY) ||
(p.getName() == CIMName(role)))
{
if (targetObjectPath.identical(path))
{
returnInstances.append(instance);
}
}
}
}
}
return returnInstances;
}
////////////////////////////////////////////////////////////////////////////////
// Gather Properities for IP Route Info
////////////////////////////////////////////////////////////////////////////////
void IPRouteInfo::_gatherProperties(CIMInstance &inst)
{
_ipSCCN = String::EMPTY;
_ipSN = String::EMPTY;
_ipServiceCCN = String::EMPTY;
_ipServiceN = String::EMPTY;
_ipCCN = String::EMPTY;
_ipIPDestAddr = String::EMPTY;
_ipIPDestMask = String::EMPTY;
_ipAddrType = 0; // Unknown
_ipCaption = String::EMPTY;
_ipDescription = String::EMPTY;
_ipName = String::EMPTY;
_ipNextHop = String::EMPTY;
for (Uint32 j=0; j < inst.getPropertyCount(); j++)
{
CIMName propertyName = inst.getProperty(j).getName();
// Properties that are also keys
if (propertyName.equal("SystemCreationClassName"))
{
inst.getProperty(j).getValue().get(_ipSCCN);
}
else if (propertyName.equal("SystemName"))
{
inst.getProperty(j).getValue().get(_ipSN);
}
else if (propertyName.equal("ServiceCreationClassName"))
{
inst.getProperty(j).getValue().get(_ipServiceCCN);
}
else if (propertyName.equal("ServiceName"))
{
inst.getProperty(j).getValue().get(_ipServiceN);
}
else if (propertyName.equal("CreationClassName"))
{
inst.getProperty(j).getValue().get(_ipCCN);
}
else if (propertyName.equal("IPDestinationAddress"))
{
inst.getProperty(j).getValue().get(_ipIPDestAddr);
}
else if (propertyName.equal("IPDestinationMask"))
{
inst.getProperty(j).getValue().get(_ipIPDestMask);
}
else if (propertyName.equal("AddressType"))
{
inst.getProperty(j).getValue().get(_ipAddrType);
}
// Other properties
else if (propertyName.equal("Caption"))
{
inst.getProperty(j).getValue().get(_ipCaption);
}
else if (propertyName.equal("Description"))
{
inst.getProperty(j).getValue().get(_ipDescription);
}
else if (propertyName.equal("Name"))
{
inst.getProperty(j).getValue().get(_ipName);
}
else if (propertyName.equal("NextHop"))
{
inst.getProperty(j).getValue().get(_ipNextHop);
}
} // end for loop through properties
}
Boolean UNIX_BinarySensor::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(), "InstallDate"))
{
CIMDateTime installDateValue;
property.getValue().get(installDateValue);
setInstallDate(installDateValue);
}
else if (String::equal(property.getName().getString(), "Name"))
{
String nameValue;
property.getValue().get(nameValue);
setName(nameValue);
}
else if (String::equal(property.getName().getString(), "OperationalStatus"))
{
Array<Uint16> operationalStatusValue;
property.getValue().get(operationalStatusValue);
setOperationalStatus(operationalStatusValue);
}
else if (String::equal(property.getName().getString(), "StatusDescriptions"))
{
Array<String> statusDescriptionsValue;
property.getValue().get(statusDescriptionsValue);
setStatusDescriptions(statusDescriptionsValue);
}
else if (String::equal(property.getName().getString(), "Status"))
{
String statusValue;
property.getValue().get(statusValue);
setStatus(statusValue);
}
else if (String::equal(property.getName().getString(), "HealthState"))
{
Uint16 healthStateValue;
property.getValue().get(healthStateValue);
setHealthState(healthStateValue);
}
else if (String::equal(property.getName().getString(), "CommunicationStatus"))
{
Uint16 communicationStatusValue;
property.getValue().get(communicationStatusValue);
setCommunicationStatus(communicationStatusValue);
}
else if (String::equal(property.getName().getString(), "DetailedStatus"))
{
Uint16 detailedStatusValue;
property.getValue().get(detailedStatusValue);
setDetailedStatus(detailedStatusValue);
}
else if (String::equal(property.getName().getString(), "OperatingStatus"))
{
Uint16 operatingStatusValue;
property.getValue().get(operatingStatusValue);
setOperatingStatus(operatingStatusValue);
}
else if (String::equal(property.getName().getString(), "PrimaryStatus"))
{
Uint16 primaryStatusValue;
property.getValue().get(primaryStatusValue);
setPrimaryStatus(primaryStatusValue);
}
else if (String::equal(property.getName().getString(), "EnabledState"))
{
Uint16 enabledStateValue;
property.getValue().get(enabledStateValue);
setEnabledState(enabledStateValue);
}
else if (String::equal(property.getName().getString(), "OtherEnabledState"))
{
String otherEnabledStateValue;
property.getValue().get(otherEnabledStateValue);
setOtherEnabledState(otherEnabledStateValue);
}
else if (String::equal(property.getName().getString(), "RequestedState"))
{
Uint16 requestedStateValue;
property.getValue().get(requestedStateValue);
setRequestedState(requestedStateValue);
}
else if (String::equal(property.getName().getString(), "EnabledDefault"))
{
Uint16 enabledDefaultValue;
property.getValue().get(enabledDefaultValue);
setEnabledDefault(enabledDefaultValue);
}
else if (String::equal(property.getName().getString(), "TimeOfLastStateChange"))
{
CIMDateTime timeOfLastStateChangeValue;
property.getValue().get(timeOfLastStateChangeValue);
setTimeOfLastStateChange(timeOfLastStateChangeValue);
}
else if (String::equal(property.getName().getString(), "AvailableRequestedStates"))
{
Array<Uint16> availableRequestedStatesValue;
property.getValue().get(availableRequestedStatesValue);
setAvailableRequestedStates(availableRequestedStatesValue);
}
else if (String::equal(property.getName().getString(), "TransitioningToState"))
{
Uint16 transitioningToStateValue;
property.getValue().get(transitioningToStateValue);
setTransitioningToState(transitioningToStateValue);
}
else if (String::equal(property.getName().getString(), "AllocationState"))
{
String allocationStateValue;
property.getValue().get(allocationStateValue);
setAllocationState(allocationStateValue);
}
else if (String::equal(property.getName().getString(), "SystemCreationClassName"))
{
String systemCreationClassNameValue;
property.getValue().get(systemCreationClassNameValue);
setSystemCreationClassName(systemCreationClassNameValue);
}
else if (String::equal(property.getName().getString(), "SystemName"))
{
String systemNameValue;
property.getValue().get(systemNameValue);
setSystemName(systemNameValue);
}
else if (String::equal(property.getName().getString(), "CreationClassName"))
{
String creationClassNameValue;
property.getValue().get(creationClassNameValue);
setCreationClassName(creationClassNameValue);
}
else if (String::equal(property.getName().getString(), "DeviceID"))
{
String deviceIDValue;
property.getValue().get(deviceIDValue);
setDeviceID(deviceIDValue);
}
else if (String::equal(property.getName().getString(), "PowerManagementSupported"))
{
Boolean powerManagementSupportedValue;
property.getValue().get(powerManagementSupportedValue);
setPowerManagementSupported(powerManagementSupportedValue);
}
else if (String::equal(property.getName().getString(), "PowerManagementCapabilities"))
{
Array<Uint16> powerManagementCapabilitiesValue;
property.getValue().get(powerManagementCapabilitiesValue);
setPowerManagementCapabilities(powerManagementCapabilitiesValue);
}
else if (String::equal(property.getName().getString(), "Availability"))
{
Uint16 availabilityValue;
property.getValue().get(availabilityValue);
setAvailability(availabilityValue);
}
else if (String::equal(property.getName().getString(), "StatusInfo"))
{
Uint16 statusInfoValue;
property.getValue().get(statusInfoValue);
setStatusInfo(statusInfoValue);
}
else if (String::equal(property.getName().getString(), "LastErrorCode"))
{
Uint32 lastErrorCodeValue;
property.getValue().get(lastErrorCodeValue);
setLastErrorCode(lastErrorCodeValue);
}
else if (String::equal(property.getName().getString(), "ErrorDescription"))
{
String errorDescriptionValue;
property.getValue().get(errorDescriptionValue);
setErrorDescription(errorDescriptionValue);
}
else if (String::equal(property.getName().getString(), "ErrorCleared"))
{
Boolean errorClearedValue;
property.getValue().get(errorClearedValue);
setErrorCleared(errorClearedValue);
}
else if (String::equal(property.getName().getString(), "OtherIdentifyingInfo"))
{
Array<String> otherIdentifyingInfoValue;
property.getValue().get(otherIdentifyingInfoValue);
setOtherIdentifyingInfo(otherIdentifyingInfoValue);
}
else if (String::equal(property.getName().getString(), "PowerOnHours"))
{
Uint64 powerOnHoursValue;
property.getValue().get(powerOnHoursValue);
setPowerOnHours(powerOnHoursValue);
}
else if (String::equal(property.getName().getString(), "TotalPowerOnHours"))
{
Uint64 totalPowerOnHoursValue;
property.getValue().get(totalPowerOnHoursValue);
setTotalPowerOnHours(totalPowerOnHoursValue);
}
else if (String::equal(property.getName().getString(), "IdentifyingDescriptions"))
{
Array<String> identifyingDescriptionsValue;
property.getValue().get(identifyingDescriptionsValue);
setIdentifyingDescriptions(identifyingDescriptionsValue);
}
else if (String::equal(property.getName().getString(), "AdditionalAvailability"))
{
Array<Uint16> additionalAvailabilityValue;
property.getValue().get(additionalAvailabilityValue);
setAdditionalAvailability(additionalAvailabilityValue);
}
else if (String::equal(property.getName().getString(), "MaxQuiesceTime"))
{
Uint64 maxQuiesceTimeValue;
property.getValue().get(maxQuiesceTimeValue);
setMaxQuiesceTime(maxQuiesceTimeValue);
}
else if (String::equal(property.getName().getString(), "LocationIndicator"))
{
Uint16 locationIndicatorValue;
property.getValue().get(locationIndicatorValue);
setLocationIndicator(locationIndicatorValue);
}
else if (String::equal(property.getName().getString(), "SensorType"))
{
Uint16 sensorTypeValue;
property.getValue().get(sensorTypeValue);
setSensorType(sensorTypeValue);
}
else if (String::equal(property.getName().getString(), "OtherSensorTypeDescription"))
{
String otherSensorTypeDescriptionValue;
property.getValue().get(otherSensorTypeDescriptionValue);
setOtherSensorTypeDescription(otherSensorTypeDescriptionValue);
}
else if (String::equal(property.getName().getString(), "PossibleStates"))
{
Array<String> possibleStatesValue;
property.getValue().get(possibleStatesValue);
setPossibleStates(possibleStatesValue);
}
else if (String::equal(property.getName().getString(), "CurrentState"))
{
String currentStateValue;
property.getValue().get(currentStateValue);
setCurrentState(currentStateValue);
}
else if (String::equal(property.getName().getString(), "PollingInterval"))
{
Uint64 pollingIntervalValue;
property.getValue().get(pollingIntervalValue);
setPollingInterval(pollingIntervalValue);
}
else if (String::equal(property.getName().getString(), "SensorContext"))
{
String sensorContextValue;
property.getValue().get(sensorContextValue);
setSensorContext(sensorContextValue);
}
else if (String::equal(property.getName().getString(), "CurrentReading"))
{
Boolean currentReadingValue;
property.getValue().get(currentReadingValue);
setCurrentReading(currentReadingValue);
}
else if (String::equal(property.getName().getString(), "ExpectedReading"))
{
Boolean expectedReadingValue;
property.getValue().get(expectedReadingValue);
setExpectedReading(expectedReadingValue);
}
else if (String::equal(property.getName().getString(), "InterpretationOfTrue"))
{
String interpretationOfTrueValue;
property.getValue().get(interpretationOfTrueValue);
setInterpretationOfTrue(interpretationOfTrueValue);
}
else if (String::equal(property.getName().getString(), "InterpretationOfFalse"))
{
String interpretationOfFalseValue;
property.getValue().get(interpretationOfFalseValue);
setInterpretationOfFalse(interpretationOfFalseValue);
}
}
return true;
}
Boolean UNIX_BatchSAP::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(), "InstallDate"))
{
CIMDateTime installDateValue;
property.getValue().get(installDateValue);
setInstallDate(installDateValue);
}
else if (String::equal(property.getName().getString(), "Name"))
{
String nameValue;
property.getValue().get(nameValue);
setName(nameValue);
}
else if (String::equal(property.getName().getString(), "OperationalStatus"))
{
Array<Uint16> operationalStatusValue;
property.getValue().get(operationalStatusValue);
setOperationalStatus(operationalStatusValue);
}
else if (String::equal(property.getName().getString(), "StatusDescriptions"))
{
Array<String> statusDescriptionsValue;
property.getValue().get(statusDescriptionsValue);
setStatusDescriptions(statusDescriptionsValue);
}
else if (String::equal(property.getName().getString(), "Status"))
{
String statusValue;
property.getValue().get(statusValue);
setStatus(statusValue);
}
else if (String::equal(property.getName().getString(), "HealthState"))
{
Uint16 healthStateValue;
property.getValue().get(healthStateValue);
setHealthState(healthStateValue);
}
else if (String::equal(property.getName().getString(), "CommunicationStatus"))
{
Uint16 communicationStatusValue;
property.getValue().get(communicationStatusValue);
setCommunicationStatus(communicationStatusValue);
}
else if (String::equal(property.getName().getString(), "DetailedStatus"))
{
Uint16 detailedStatusValue;
property.getValue().get(detailedStatusValue);
setDetailedStatus(detailedStatusValue);
}
else if (String::equal(property.getName().getString(), "OperatingStatus"))
{
Uint16 operatingStatusValue;
property.getValue().get(operatingStatusValue);
setOperatingStatus(operatingStatusValue);
}
else if (String::equal(property.getName().getString(), "PrimaryStatus"))
{
Uint16 primaryStatusValue;
property.getValue().get(primaryStatusValue);
setPrimaryStatus(primaryStatusValue);
}
else if (String::equal(property.getName().getString(), "EnabledState"))
{
Uint16 enabledStateValue;
property.getValue().get(enabledStateValue);
setEnabledState(enabledStateValue);
}
else if (String::equal(property.getName().getString(), "OtherEnabledState"))
{
String otherEnabledStateValue;
property.getValue().get(otherEnabledStateValue);
setOtherEnabledState(otherEnabledStateValue);
}
else if (String::equal(property.getName().getString(), "RequestedState"))
{
Uint16 requestedStateValue;
property.getValue().get(requestedStateValue);
setRequestedState(requestedStateValue);
}
else if (String::equal(property.getName().getString(), "EnabledDefault"))
{
Uint16 enabledDefaultValue;
property.getValue().get(enabledDefaultValue);
setEnabledDefault(enabledDefaultValue);
}
else if (String::equal(property.getName().getString(), "TimeOfLastStateChange"))
{
CIMDateTime timeOfLastStateChangeValue;
property.getValue().get(timeOfLastStateChangeValue);
setTimeOfLastStateChange(timeOfLastStateChangeValue);
}
else if (String::equal(property.getName().getString(), "AvailableRequestedStates"))
{
Array<Uint16> availableRequestedStatesValue;
property.getValue().get(availableRequestedStatesValue);
setAvailableRequestedStates(availableRequestedStatesValue);
}
else if (String::equal(property.getName().getString(), "TransitioningToState"))
{
Uint16 transitioningToStateValue;
property.getValue().get(transitioningToStateValue);
setTransitioningToState(transitioningToStateValue);
}
else if (String::equal(property.getName().getString(), "SystemCreationClassName"))
{
String systemCreationClassNameValue;
property.getValue().get(systemCreationClassNameValue);
setSystemCreationClassName(systemCreationClassNameValue);
}
else if (String::equal(property.getName().getString(), "SystemName"))
{
String systemNameValue;
property.getValue().get(systemNameValue);
setSystemName(systemNameValue);
}
else if (String::equal(property.getName().getString(), "CreationClassName"))
{
String creationClassNameValue;
property.getValue().get(creationClassNameValue);
setCreationClassName(creationClassNameValue);
}
else if (String::equal(property.getName().getString(), "BatchProtocol"))
{
Array<Uint16> batchProtocolValue;
property.getValue().get(batchProtocolValue);
setBatchProtocol(batchProtocolValue);
}
else if (String::equal(property.getName().getString(), "BatchProtocolInfo"))
{
Array<String> batchProtocolInfoValue;
property.getValue().get(batchProtocolInfoValue);
setBatchProtocolInfo(batchProtocolInfoValue);
}
}
return true;
}
/**
_validateProperties method of the NIS provider Test Client
*/
void NISTestClient::_validateProperties(
CIMInstance &inst,
Boolean verboseTest)
{
if (verboseTest)
cout << "Checking " << inst.getPropertyCount() << " properties" << endl;
// loop through the properties
for (Uint32 j=0; j < inst.getPropertyCount(); j++)
{
CIMName propertyName = inst.getProperty(j).getName();
if (verboseTest)
cout << "Property name: " << propertyName.getString() << endl;
if (propertyName.equal("CreationClassName"))
{
String propertyValue;
inst.getProperty(j).getValue().get(propertyValue);
if (goodCreationClassName(propertyValue, verboseTest) == false)
{
errorExit ("CreationClassName not PG_NISServerService");
}
} // end if CreationClassName
else if (propertyName.equal("Name"))
{
String propertyValue;
inst.getProperty(j).getValue().get(propertyValue);
if (goodName(propertyValue, verboseTest) == false)
{
errorExit ("Name not correct");
}
} // end if Name
else if (propertyName.equal("Caption"))
{
String propertyValue;
inst.getProperty(j).getValue().get(propertyValue);
if (goodCaption(propertyValue, verboseTest) == false)
{
errorExit ("Caption not correct");
}
} // end if Caption
else if (propertyName.equal("Description"))
{
String propertyValue;
inst.getProperty(j).getValue().get(propertyValue);
if (goodDescription(propertyValue, verboseTest) == false)
{
errorExit ("Description not correct");
}
} // end if Description
else if (propertyName.equal("ServerWaitFlag"))
{
Uint16 propertyValue;
inst.getProperty(j).getValue().get(propertyValue);
if (goodServerWaitFlag(propertyValue, verboseTest) == false)
{
errorExit ("ServerWaitFlag not correct");
}
} // end if Server Wait Flag
else if (propertyName.equal("ServerType"))
{
Uint16 propertyValue;
inst.getProperty(j).getValue().get(propertyValue);
if (goodServerType(propertyValue, verboseTest) == false)
{
errorExit ("ServerType not correct");
}
} // end if Server Wait Flag
else if (propertyName.equal("SystemName"))
{
String propertyValue;
inst.getProperty(j).getValue().get(propertyValue);
if (goodSystemName(propertyValue, verboseTest) == false)
{
errorExit ("SystemName not correct");
}
} // end if SystemName
else if (propertyName.equal("SystemCreationClassName"))
{
String propertyValue;
inst.getProperty(j).getValue().get(propertyValue);
if (goodSystemCreationClassName(propertyValue, verboseTest) ==
false)
{
errorExit ("SystemCreationClassName not correct");
}
} // end if SystemCreationClassName
}
}
Boolean UNIX_BlockStatisticsManifest::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(), "ElementType"))
{
Uint16 elementTypeValue;
property.getValue().get(elementTypeValue);
setElementType(elementTypeValue);
}
else if (String::equal(property.getName().getString(), "IncludeStartStatisticTime"))
{
Boolean includeStartStatisticTimeValue;
property.getValue().get(includeStartStatisticTimeValue);
setIncludeStartStatisticTime(includeStartStatisticTimeValue);
}
else if (String::equal(property.getName().getString(), "IncludeStatisticTime"))
{
Boolean includeStatisticTimeValue;
property.getValue().get(includeStatisticTimeValue);
setIncludeStatisticTime(includeStatisticTimeValue);
}
else if (String::equal(property.getName().getString(), "IncludeTotalIOs"))
{
Boolean includeTotalIOsValue;
property.getValue().get(includeTotalIOsValue);
setIncludeTotalIOs(includeTotalIOsValue);
}
else if (String::equal(property.getName().getString(), "IncludeKBytesTransferred"))
{
Boolean includeKBytesTransferredValue;
property.getValue().get(includeKBytesTransferredValue);
setIncludeKBytesTransferred(includeKBytesTransferredValue);
}
else if (String::equal(property.getName().getString(), "IncludeIOTimeCounter"))
{
Boolean includeIOTimeCounterValue;
property.getValue().get(includeIOTimeCounterValue);
setIncludeIOTimeCounter(includeIOTimeCounterValue);
}
else if (String::equal(property.getName().getString(), "IncludeReadIOs"))
{
Boolean includeReadIOsValue;
property.getValue().get(includeReadIOsValue);
setIncludeReadIOs(includeReadIOsValue);
}
else if (String::equal(property.getName().getString(), "IncludeReadHitIOs"))
{
Boolean includeReadHitIOsValue;
property.getValue().get(includeReadHitIOsValue);
setIncludeReadHitIOs(includeReadHitIOsValue);
}
else if (String::equal(property.getName().getString(), "IncludeReadIOTimeCounter"))
{
Boolean includeReadIOTimeCounterValue;
property.getValue().get(includeReadIOTimeCounterValue);
setIncludeReadIOTimeCounter(includeReadIOTimeCounterValue);
}
else if (String::equal(property.getName().getString(), "IncludeReadHitIOTimeCounter"))
{
Boolean includeReadHitIOTimeCounterValue;
property.getValue().get(includeReadHitIOTimeCounterValue);
setIncludeReadHitIOTimeCounter(includeReadHitIOTimeCounterValue);
}
else if (String::equal(property.getName().getString(), "IncludeKBytesRead"))
{
Boolean includeKBytesReadValue;
property.getValue().get(includeKBytesReadValue);
setIncludeKBytesRead(includeKBytesReadValue);
}
else if (String::equal(property.getName().getString(), "IncludeWriteIOs"))
{
Boolean includeWriteIOsValue;
property.getValue().get(includeWriteIOsValue);
setIncludeWriteIOs(includeWriteIOsValue);
}
else if (String::equal(property.getName().getString(), "IncludeWriteHitIOs"))
{
Boolean includeWriteHitIOsValue;
property.getValue().get(includeWriteHitIOsValue);
setIncludeWriteHitIOs(includeWriteHitIOsValue);
}
else if (String::equal(property.getName().getString(), "IncludeWriteIOTimeCounter"))
{
Boolean includeWriteIOTimeCounterValue;
property.getValue().get(includeWriteIOTimeCounterValue);
setIncludeWriteIOTimeCounter(includeWriteIOTimeCounterValue);
}
else if (String::equal(property.getName().getString(), "IncludeWriteHitIOTimeCounter"))
{
Boolean includeWriteHitIOTimeCounterValue;
property.getValue().get(includeWriteHitIOTimeCounterValue);
setIncludeWriteHitIOTimeCounter(includeWriteHitIOTimeCounterValue);
}
else if (String::equal(property.getName().getString(), "IncludeKBytesWritten"))
{
Boolean includeKBytesWrittenValue;
property.getValue().get(includeKBytesWrittenValue);
setIncludeKBytesWritten(includeKBytesWrittenValue);
}
else if (String::equal(property.getName().getString(), "IncludeIdleTimeCounter"))
{
Boolean includeIdleTimeCounterValue;
property.getValue().get(includeIdleTimeCounterValue);
setIncludeIdleTimeCounter(includeIdleTimeCounterValue);
}
else if (String::equal(property.getName().getString(), "IncludeMaintOp"))
{
Boolean includeMaintOpValue;
property.getValue().get(includeMaintOpValue);
setIncludeMaintOp(includeMaintOpValue);
}
else if (String::equal(property.getName().getString(), "IncludeMaintTimeCounter"))
{
Boolean includeMaintTimeCounterValue;
property.getValue().get(includeMaintTimeCounterValue);
setIncludeMaintTimeCounter(includeMaintTimeCounterValue);
}
else if (String::equal(property.getName().getString(), "CSVSequence"))
{
Array<String> cSVSequenceValue;
property.getValue().get(cSVSequenceValue);
setCSVSequence(cSVSequenceValue);
}
else if (String::equal(property.getName().getString(), "CSVRateSequence"))
{
Array<String> cSVRateSequenceValue;
property.getValue().get(cSVRateSequenceValue);
setCSVRateSequence(cSVRateSequenceValue);
}
else if (String::equal(property.getName().getString(), "IncludeKBytesReadRate"))
{
Boolean includeKBytesReadRateValue;
property.getValue().get(includeKBytesReadRateValue);
setIncludeKBytesReadRate(includeKBytesReadRateValue);
}
else if (String::equal(property.getName().getString(), "IncludeKBytesTransferredRate"))
{
Boolean includeKBytesTransferredRateValue;
property.getValue().get(includeKBytesTransferredRateValue);
setIncludeKBytesTransferredRate(includeKBytesTransferredRateValue);
}
else if (String::equal(property.getName().getString(), "IncludeKBytesWrittenRate"))
{
Boolean includeKBytesWrittenRateValue;
property.getValue().get(includeKBytesWrittenRateValue);
setIncludeKBytesWrittenRate(includeKBytesWrittenRateValue);
}
else if (String::equal(property.getName().getString(), "IncludeMaintOpRate"))
{
Boolean includeMaintOpRateValue;
property.getValue().get(includeMaintOpRateValue);
setIncludeMaintOpRate(includeMaintOpRateValue);
}
else if (String::equal(property.getName().getString(), "IncludeRateIntervalEndTime"))
{
Boolean includeRateIntervalEndTimeValue;
property.getValue().get(includeRateIntervalEndTimeValue);
setIncludeRateIntervalEndTime(includeRateIntervalEndTimeValue);
}
else if (String::equal(property.getName().getString(), "IncludeRateIntervalStartTime"))
{
Boolean includeRateIntervalStartTimeValue;
property.getValue().get(includeRateIntervalStartTimeValue);
setIncludeRateIntervalStartTime(includeRateIntervalStartTimeValue);
}
else if (String::equal(property.getName().getString(), "IncludeReadHitIOsRate"))
{
Boolean includeReadHitIOsRateValue;
property.getValue().get(includeReadHitIOsRateValue);
setIncludeReadHitIOsRate(includeReadHitIOsRateValue);
}
else if (String::equal(property.getName().getString(), "IncludeReadIOsRate"))
{
Boolean includeReadIOsRateValue;
property.getValue().get(includeReadIOsRateValue);
setIncludeReadIOsRate(includeReadIOsRateValue);
}
else if (String::equal(property.getName().getString(), "IncludeTotalIOsRate"))
{
Boolean includeTotalIOsRateValue;
property.getValue().get(includeTotalIOsRateValue);
setIncludeTotalIOsRate(includeTotalIOsRateValue);
}
else if (String::equal(property.getName().getString(), "IncludeWriteHitIOsRate"))
{
Boolean includeWriteHitIOsRateValue;
property.getValue().get(includeWriteHitIOsRateValue);
setIncludeWriteHitIOsRate(includeWriteHitIOsRateValue);
}
else if (String::equal(property.getName().getString(), "IncludeWriteIOsRate"))
{
Boolean includeWriteIOsRateValue;
property.getValue().get(includeWriteIOsRateValue);
setIncludeWriteIOsRate(includeWriteIOsRateValue);
}
else if (String::equal(property.getName().getString(), "RateElementType"))
{
Uint16 rateElementTypeValue;
property.getValue().get(rateElementTypeValue);
setRateElementType(rateElementTypeValue);
}
}
return true;
}
Boolean UNIX_CPUDiagnosticSettingData::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(), "ConfigurationName"))
{
String configurationNameValue;
property.getValue().get(configurationNameValue);
setConfigurationName(configurationNameValue);
}
else if (String::equal(property.getName().getString(), "ChangeableType"))
{
Uint16 changeableTypeValue;
property.getValue().get(changeableTypeValue);
setChangeableType(changeableTypeValue);
}
else if (String::equal(property.getName().getString(), "ComponentSetting"))
{
Array<String> componentSettingValue;
property.getValue().get(componentSettingValue);
setComponentSetting(componentSettingValue);
}
else if (String::equal(property.getName().getString(), "SoID"))
{
String soIDValue;
property.getValue().get(soIDValue);
setSoID(soIDValue);
}
else if (String::equal(property.getName().getString(), "SoOrgID"))
{
String soOrgIDValue;
property.getValue().get(soOrgIDValue);
setSoOrgID(soOrgIDValue);
}
else if (String::equal(property.getName().getString(), "HaltOnError"))
{
Boolean haltOnErrorValue;
property.getValue().get(haltOnErrorValue);
setHaltOnError(haltOnErrorValue);
}
else if (String::equal(property.getName().getString(), "QuickMode"))
{
Boolean quickModeValue;
property.getValue().get(quickModeValue);
setQuickMode(quickModeValue);
}
else if (String::equal(property.getName().getString(), "PercentOfTestCoverage"))
{
Uint8 percentOfTestCoverageValue;
property.getValue().get(percentOfTestCoverageValue);
setPercentOfTestCoverage(percentOfTestCoverageValue);
}
else if (String::equal(property.getName().getString(), "LoopControlParameter"))
{
Array<String> loopControlParameterValue;
property.getValue().get(loopControlParameterValue);
setLoopControlParameter(loopControlParameterValue);
}
else if (String::equal(property.getName().getString(), "LoopControl"))
{
Array<Uint16> loopControlValue;
property.getValue().get(loopControlValue);
setLoopControl(loopControlValue);
}
else if (String::equal(property.getName().getString(), "OtherLoopControlDescriptions"))
{
Array<String> otherLoopControlDescriptionsValue;
property.getValue().get(otherLoopControlDescriptionsValue);
setOtherLoopControlDescriptions(otherLoopControlDescriptionsValue);
}
else if (String::equal(property.getName().getString(), "ResultPersistence"))
{
Uint32 resultPersistenceValue;
property.getValue().get(resultPersistenceValue);
setResultPersistence(resultPersistenceValue);
}
else if (String::equal(property.getName().getString(), "LogOptions"))
{
Array<Uint16> logOptionsValue;
property.getValue().get(logOptionsValue);
setLogOptions(logOptionsValue);
}
else if (String::equal(property.getName().getString(), "OtherLogOptionsDescriptions"))
{
Array<String> otherLogOptionsDescriptionsValue;
property.getValue().get(otherLogOptionsDescriptionsValue);
setOtherLogOptionsDescriptions(otherLogOptionsDescriptionsValue);
}
else if (String::equal(property.getName().getString(), "LogStorage"))
{
Array<Uint16> logStorageValue;
property.getValue().get(logStorageValue);
setLogStorage(logStorageValue);
}
else if (String::equal(property.getName().getString(), "OtherLogStorageDescriptions"))
{
Array<String> otherLogStorageDescriptionsValue;
property.getValue().get(otherLogStorageDescriptionsValue);
setOtherLogStorageDescriptions(otherLogStorageDescriptionsValue);
}
else if (String::equal(property.getName().getString(), "VerbosityLevel"))
{
Array<Uint16> verbosityLevelValue;
property.getValue().get(verbosityLevelValue);
setVerbosityLevel(verbosityLevelValue);
}
else if (String::equal(property.getName().getString(), "QueryTimeout"))
{
Uint32 queryTimeoutValue;
property.getValue().get(queryTimeoutValue);
setQueryTimeout(queryTimeoutValue);
}
else if (String::equal(property.getName().getString(), "NonDestructive"))
{
Boolean nonDestructiveValue;
property.getValue().get(nonDestructiveValue);
setNonDestructive(nonDestructiveValue);
}
else if (String::equal(property.getName().getString(), "CoreVoltages"))
{
Array<Real32> coreVoltagesValue;
property.getValue().get(coreVoltagesValue);
setCoreVoltages(coreVoltagesValue);
}
else if (String::equal(property.getName().getString(), "CPUSpeeds"))
{
Array<Real32> cPUSpeedsValue;
property.getValue().get(cPUSpeedsValue);
setCPUSpeeds(cPUSpeedsValue);
}
else if (String::equal(property.getName().getString(), "Seed"))
{
Uint32 seedValue;
property.getValue().get(seedValue);
setSeed(seedValue);
}
}
return true;
}
// Tests PROPERTY.ARRAY as an embedded object with array type.
static void testGetInstanceElement2(const char* testDataFile)
{
CIMInstance cimInstance;
Buffer text;
FileSystem::loadFileToMemory(text, testDataFile);
XmlParser parser((char*)text.getData());
XmlReader::getInstanceElement(parser, cimInstance);
PEGASUS_TEST_ASSERT(cimInstance.getClassName() ==
CIMName("CIM_InstCreation"));
Uint32 idx;
CIMProperty cimProperty;
CIMValue cimValue;
CIMType cimType;
PEGASUS_TEST_ASSERT(cimInstance.getPropertyCount() == 3);
idx = cimInstance.findProperty(CIMName("IndicationIdentifier"));
PEGASUS_TEST_ASSERT(idx != PEG_NOT_FOUND);
cimProperty = cimInstance.getProperty(idx);
cimValue = cimProperty.getValue();
cimType = cimProperty.getType();
PEGASUS_TEST_ASSERT(strcmp(cimTypeToString(cimType), "string") == 0);
String myString;
cimValue.get(myString);
PEGASUS_TEST_ASSERT(strcmp(myString.getCString(), "0") == 0);
idx = cimInstance.findProperty(CIMName("IndicationTime"));
PEGASUS_TEST_ASSERT(idx != PEG_NOT_FOUND);
cimProperty = cimInstance.getProperty(idx);
cimValue = cimProperty.getValue();
cimType = cimProperty.getType();
PEGASUS_TEST_ASSERT(strcmp(cimTypeToString(cimType), "datetime") == 0);
CIMDateTime myDateTime;
cimValue.get(myDateTime);
PEGASUS_TEST_ASSERT(myDateTime.equal(
CIMDateTime("20050227225624.524000-300")));
idx = cimInstance.findProperty(CIMName("SourceInstance"));
PEGASUS_TEST_ASSERT(idx != PEG_NOT_FOUND);
cimProperty = cimInstance.getProperty(idx);
cimValue = cimProperty.getValue();
cimType = cimProperty.getType();
PEGASUS_TEST_ASSERT(strcmp(cimTypeToString(cimType), "object") == 0);
Array<CIMObject> cimObject;
cimValue.get(cimObject);
PEGASUS_TEST_ASSERT(cimObject.size() == 2);
for (idx = 0; idx < cimObject.size(); idx++)
{
CIMInstance cimInstanceElement(cimObject[idx]);
PEGASUS_TEST_ASSERT(cimInstanceElement.getPropertyCount() == 2);
Uint32 propIdx = cimInstanceElement.findProperty(CIMName("uniqueId"));
if (propIdx != PEG_NOT_FOUND)
{
CIMProperty nestedProperty =
cimInstanceElement.getProperty(propIdx);
cimValue = nestedProperty.getValue();
Uint32 uniqueId;
cimValue.get(uniqueId);
propIdx = cimInstanceElement.findProperty(CIMName("lastOp"));
nestedProperty = cimInstanceElement.getProperty(propIdx);
cimValue = nestedProperty.getValue();
String checkStringValue;
cimValue.get(checkStringValue);
if (uniqueId == 1)
{
PEGASUS_TEST_ASSERT(strcmp(
checkStringValue.getCString(), "createInstance") == 0);
}
else if (uniqueId == 2)
{
PEGASUS_TEST_ASSERT(strcmp(
checkStringValue.getCString(), "deleteInstance") == 0);
}
else
{
PEGASUS_TEST_ASSERT(false);
}
}
}
}
// l10n - note: ignoring indication language
void snmpIndicationHandler::handleIndication(
const OperationContext& context,
const String nameSpace,
CIMInstance& indication,
CIMInstance& handler,
CIMInstance& subscription,
ContentLanguages & contentLanguages)
{
Array<String> propOIDs;
Array<String> propTYPEs;
Array<String> propVALUEs;
CIMProperty prop;
CIMQualifier trapQualifier;
Uint32 qualifierPos;
String propValue;
String mapstr1;
String mapstr2;
PEG_METHOD_ENTER (TRC_IND_HANDLER,
"snmpIndicationHandler::handleIndication");
try
{
CIMClass indicationClass = _repository->getClass(
nameSpace, indication.getClassName(), false, true,
false, CIMPropertyList());
Uint32 propertyCount = indication.getPropertyCount();
for (Uint32 i=0; i < propertyCount; i++)
{
prop = indication.getProperty(i);
if (!prop.isUninitialized())
{
CIMName propName = prop.getName();
Uint32 propPos = indicationClass.findProperty(propName);
if (propPos != PEG_NOT_FOUND)
{
CIMProperty trapProp = indicationClass.getProperty(propPos);
qualifierPos = trapProp.findQualifier(CIMName ("MappingStrings"));
if (qualifierPos != PEG_NOT_FOUND)
{
trapQualifier = trapProp.getQualifier(qualifierPos);
mapstr1.clear();
mapstr1 = trapQualifier.getValue().toString();
if ((mapstr1.find("OID.IETF") != PEG_NOT_FOUND) &&
(mapstr1.find("DataType.IETF") != PEG_NOT_FOUND))
{
if (mapstr1.subString(0, 8) == "OID.IETF")
{
mapstr1 = mapstr1.subString(mapstr1.find("SNMP.")+5);
if (mapstr1.find("|") != PEG_NOT_FOUND)
{
mapstr2.clear();
mapstr2 = mapstr1.subString(0,
mapstr1.find("DataType.IETF")-1);
propOIDs.append(mapstr2);
propValue.clear();
propValue = prop.getValue().toString();
propVALUEs.append(propValue);
mapstr2 = mapstr1.subString(mapstr1.find("|")+2);
mapstr2 = mapstr2.subString(0, mapstr2.size()-1);
propTYPEs.append(mapstr2);
}
}
}
}
}
}
}
// Collected complete data in arrays and ready to send the trap.
// trap destination and SNMP type are defined in handlerInstance
// and passing this instance as it is to deliverTrap() call
#ifdef HPUX_EMANATE
static snmpDeliverTrap_emanate emanateTrap;
#else
static snmpDeliverTrap_stub emanateTrap;
#endif
Uint32 targetHostPos = handler.findProperty(CIMName ("TargetHost"));
Uint32 targetHostFormatPos = handler.findProperty(CIMName ("TargetHostFormat"));
Uint32 otherTargetHostFormatPos = handler.findProperty(CIMName (
"OtherTargetHostFormat"));
Uint32 portNumberPos = handler.findProperty(CIMName ("PortNumber"));
Uint32 snmpVersionPos = handler.findProperty(CIMName ("SNMPVersion"));
Uint32 securityNamePos = handler.findProperty(CIMName ("SNMPSecurityName"));
Uint32 engineIDPos = handler.findProperty(CIMName ("SNMPEngineID"));
if ((targetHostPos != PEG_NOT_FOUND) &&
(targetHostFormatPos != PEG_NOT_FOUND) &&
(snmpVersionPos != PEG_NOT_FOUND) &&
(indicationClass.findQualifier(CIMName ("MappingStrings")) !=
PEG_NOT_FOUND))
{
// properties from the handler instance
String targetHost;
String otherTargetHostFormat = String();
String securityName = String();
String engineID = String();
Uint16 targetHostFormat = 0;
Uint16 snmpVersion = 0;
Uint32 portNumber;
String trapOid;
//
// Get snmpTrapOid from context
//
try
{
SnmpTrapOidContainer trapContainer = context.get
(SnmpTrapOidContainer::NAME);
trapOid = trapContainer.getSnmpTrapOid();
}
catch (Exception& e)
{
// get trapOid from indication Class
Uint32 pos = indicationClass.findQualifier(CIMName ("MappingStrings"));
if (pos != PEG_NOT_FOUND)
{
trapOid = indicationClass.getQualifier(pos).getValue().toString();
trapOid = trapOid.subString(11, PEG_NOT_FOUND);
if ((String::compare(trapOid, "SNMP.", 5)) == 0)
{
trapOid = trapOid.subString(5, (trapOid.size()-6));
}
else
{
PEG_TRACE_STRING(TRC_IND_HANDLER, Tracer::LEVEL4,
"Invalid MappingStrings Value " + trapOid);
PEG_METHOD_EXIT();
// l10n
// throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, "Invalid MappingStrings Value");
throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,
MessageLoaderParms("Handler.snmpIndicationHandler.snmpIndicationHandler.INVALID_MS_VALUE",
"Invalid MappingStrings Value"));
}
}
else
{
PEG_TRACE_STRING(TRC_IND_HANDLER, Tracer::LEVEL4,
"Qualifier MappingStrings can not be found.");
PEG_METHOD_EXIT();
//L10N_ TODO DONE
//throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, "Qualifier MappingStrings can not be found");
MessageLoaderParms parms("Handler.snmpIndicationHandler.snmpIndicationHandler.QUALIFIER_MAPPINGS_NOT_FOUND",
"Qualifier MappingStrings can not be found");
throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED, parms);
}
}
handler.getProperty(targetHostPos).getValue().get(targetHost);
handler.getProperty(targetHostFormatPos).getValue().get(targetHostFormat);
if (otherTargetHostFormatPos != PEG_NOT_FOUND)
{
handler.getProperty(otherTargetHostFormatPos).getValue().get
(otherTargetHostFormat);
}
if (portNumberPos != PEG_NOT_FOUND)
{
handler.getProperty(portNumberPos).getValue().get(portNumber);
}
else
{
// default port
portNumber = SNMP_TRAP_DEFAULT_PORT;
}
handler.getProperty(snmpVersionPos).getValue().get(snmpVersion);
if (securityNamePos != PEG_NOT_FOUND)
{
handler.getProperty(securityNamePos).getValue().get(securityName);
}
if (engineIDPos != PEG_NOT_FOUND)
{
handler.getProperty(engineIDPos).getValue().get(engineID);
}
emanateTrap.deliverTrap(
trapOid,
securityName,
targetHost,
targetHostFormat,
otherTargetHostFormat,
portNumber,
snmpVersion,
engineID,
propOIDs,
propTYPEs,
propVALUEs);
}
else
{
PEG_TRACE_STRING(TRC_IND_HANDLER, Tracer::LEVEL4,
"Invalid IndicationHandlerSNMPMapper instance.");
PEG_METHOD_EXIT();
// l10n
// throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,
// "Invalid IndicationHandlerSNMPMapper instance");
throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,
MessageLoaderParms("Handler.snmpIndicationHandler.snmpIndicationHandler.INVALID_SNMP_INSTANCE",
"Invalid IndicationHandlerSNMPMapper instance"));
}
}
catch (CIMException & c)
{
PEG_TRACE_STRING(TRC_IND_HANDLER, Tracer::LEVEL4, c.getMessage());
PEG_METHOD_EXIT();
throw PEGASUS_CIM_EXCEPTION (CIM_ERR_FAILED, c.getMessage());
}
catch (Exception& e)
{
PEG_TRACE_STRING(TRC_IND_HANDLER, Tracer::LEVEL4, e.getMessage());
PEG_METHOD_EXIT();
throw PEGASUS_CIM_EXCEPTION (CIM_ERR_FAILED, e.getMessage());
}
catch (...)
{
PEG_TRACE_STRING(TRC_IND_HANDLER, Tracer::LEVEL4,
"Failed to deliver trap.");
PEG_METHOD_EXIT();
throw PEGASUS_CIM_EXCEPTION_L (CIM_ERR_FAILED,
MessageLoaderParms("Handler.snmpIndicationHandler.snmpIndicationHandler.FAILED_TO_DELIVER_TRAP",
"Failed to deliver trap."));
}
}
Boolean UNIX_CPUDiagnosticTest::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(), "InstallDate"))
{
CIMDateTime installDateValue;
property.getValue().get(installDateValue);
setInstallDate(installDateValue);
}
else if (String::equal(property.getName().getString(), "Name"))
{
String nameValue;
property.getValue().get(nameValue);
setName(nameValue);
}
else if (String::equal(property.getName().getString(), "OperationalStatus"))
{
Array<Uint16> operationalStatusValue;
property.getValue().get(operationalStatusValue);
setOperationalStatus(operationalStatusValue);
}
else if (String::equal(property.getName().getString(), "StatusDescriptions"))
{
Array<String> statusDescriptionsValue;
property.getValue().get(statusDescriptionsValue);
setStatusDescriptions(statusDescriptionsValue);
}
else if (String::equal(property.getName().getString(), "Status"))
{
String statusValue;
property.getValue().get(statusValue);
setStatus(statusValue);
}
else if (String::equal(property.getName().getString(), "HealthState"))
{
Uint16 healthStateValue;
property.getValue().get(healthStateValue);
setHealthState(healthStateValue);
}
else if (String::equal(property.getName().getString(), "CommunicationStatus"))
{
Uint16 communicationStatusValue;
property.getValue().get(communicationStatusValue);
setCommunicationStatus(communicationStatusValue);
}
else if (String::equal(property.getName().getString(), "DetailedStatus"))
{
Uint16 detailedStatusValue;
property.getValue().get(detailedStatusValue);
setDetailedStatus(detailedStatusValue);
}
else if (String::equal(property.getName().getString(), "OperatingStatus"))
{
Uint16 operatingStatusValue;
property.getValue().get(operatingStatusValue);
setOperatingStatus(operatingStatusValue);
}
else if (String::equal(property.getName().getString(), "PrimaryStatus"))
{
Uint16 primaryStatusValue;
property.getValue().get(primaryStatusValue);
setPrimaryStatus(primaryStatusValue);
}
else if (String::equal(property.getName().getString(), "EnabledState"))
{
Uint16 enabledStateValue;
property.getValue().get(enabledStateValue);
setEnabledState(enabledStateValue);
}
else if (String::equal(property.getName().getString(), "OtherEnabledState"))
{
String otherEnabledStateValue;
property.getValue().get(otherEnabledStateValue);
setOtherEnabledState(otherEnabledStateValue);
}
else if (String::equal(property.getName().getString(), "RequestedState"))
{
Uint16 requestedStateValue;
property.getValue().get(requestedStateValue);
setRequestedState(requestedStateValue);
}
else if (String::equal(property.getName().getString(), "EnabledDefault"))
{
Uint16 enabledDefaultValue;
property.getValue().get(enabledDefaultValue);
setEnabledDefault(enabledDefaultValue);
}
else if (String::equal(property.getName().getString(), "TimeOfLastStateChange"))
{
CIMDateTime timeOfLastStateChangeValue;
property.getValue().get(timeOfLastStateChangeValue);
setTimeOfLastStateChange(timeOfLastStateChangeValue);
}
else if (String::equal(property.getName().getString(), "AvailableRequestedStates"))
{
Array<Uint16> availableRequestedStatesValue;
property.getValue().get(availableRequestedStatesValue);
setAvailableRequestedStates(availableRequestedStatesValue);
}
else if (String::equal(property.getName().getString(), "TransitioningToState"))
{
Uint16 transitioningToStateValue;
property.getValue().get(transitioningToStateValue);
setTransitioningToState(transitioningToStateValue);
}
else if (String::equal(property.getName().getString(), "SystemCreationClassName"))
{
String systemCreationClassNameValue;
property.getValue().get(systemCreationClassNameValue);
setSystemCreationClassName(systemCreationClassNameValue);
}
else if (String::equal(property.getName().getString(), "SystemName"))
{
String systemNameValue;
property.getValue().get(systemNameValue);
setSystemName(systemNameValue);
}
else if (String::equal(property.getName().getString(), "CreationClassName"))
{
String creationClassNameValue;
property.getValue().get(creationClassNameValue);
setCreationClassName(creationClassNameValue);
}
else if (String::equal(property.getName().getString(), "PrimaryOwnerName"))
{
String primaryOwnerNameValue;
property.getValue().get(primaryOwnerNameValue);
setPrimaryOwnerName(primaryOwnerNameValue);
}
else if (String::equal(property.getName().getString(), "PrimaryOwnerContact"))
{
String primaryOwnerContactValue;
property.getValue().get(primaryOwnerContactValue);
setPrimaryOwnerContact(primaryOwnerContactValue);
}
else if (String::equal(property.getName().getString(), "StartMode"))
{
String startModeValue;
property.getValue().get(startModeValue);
setStartMode(startModeValue);
}
else if (String::equal(property.getName().getString(), "Started"))
{
Boolean startedValue;
property.getValue().get(startedValue);
setStarted(startedValue);
}
else if (String::equal(property.getName().getString(), "LoSID"))
{
String loSIDValue;
property.getValue().get(loSIDValue);
setLoSID(loSIDValue);
}
else if (String::equal(property.getName().getString(), "LoSOrgID"))
{
String loSOrgIDValue;
property.getValue().get(loSOrgIDValue);
setLoSOrgID(loSOrgIDValue);
}
else if (String::equal(property.getName().getString(), "Characteristics"))
{
Array<Uint16> characteristicsValue;
property.getValue().get(characteristicsValue);
setCharacteristics(characteristicsValue);
}
else if (String::equal(property.getName().getString(), "OtherCharacteristicDescription"))
{
String otherCharacteristicDescriptionValue;
property.getValue().get(otherCharacteristicDescriptionValue);
setOtherCharacteristicDescription(otherCharacteristicDescriptionValue);
}
else if (String::equal(property.getName().getString(), "OtherCharacteristicsDescriptions"))
{
Array<String> otherCharacteristicsDescriptionsValue;
property.getValue().get(otherCharacteristicsDescriptionsValue);
setOtherCharacteristicsDescriptions(otherCharacteristicsDescriptionsValue);
}
else if (String::equal(property.getName().getString(), "IsInUse"))
{
Boolean isInUseValue;
property.getValue().get(isInUseValue);
setIsInUse(isInUseValue);
}
else if (String::equal(property.getName().getString(), "ResourcesUsed"))
{
Array<Uint16> resourcesUsedValue;
property.getValue().get(resourcesUsedValue);
setResourcesUsed(resourcesUsedValue);
}
else if (String::equal(property.getName().getString(), "TestTypes"))
{
Array<Uint16> testTypesValue;
property.getValue().get(testTypesValue);
setTestTypes(testTypesValue);
}
else if (String::equal(property.getName().getString(), "OtherTestTypesDescriptions"))
{
Array<String> otherTestTypesDescriptionsValue;
property.getValue().get(otherTestTypesDescriptionsValue);
setOtherTestTypesDescriptions(otherTestTypesDescriptionsValue);
}
else if (String::equal(property.getName().getString(), "CPUTestType"))
{
Uint16 cPUTestTypeValue;
property.getValue().get(cPUTestTypeValue);
setCPUTestType(cPUTestTypeValue);
}
else if (String::equal(property.getName().getString(), "OtherCPUTestTypeDescription"))
{
String otherCPUTestTypeDescriptionValue;
property.getValue().get(otherCPUTestTypeDescriptionValue);
setOtherCPUTestTypeDescription(otherCPUTestTypeDescriptionValue);
}
}
return true;
}
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);
}
String IndicationFormatter::_getIndPropertyValue(
const String & specifiedPropertyName,
const String & arrayIndexStr,
const CIMInstance & indication,
const ContentLanguages & contentLangs)
{
PEG_METHOD_ENTER (TRC_IND_FORMATTER,
"IndicationFormatter::_getIndPropertyValue");
CIMInstance indicationInstance = indication.clone();
String propertyName;
Boolean canLocalize = false;
#if defined(PEGASUS_HAS_ICU) && defined(PEGASUS_INDFORMATTER_USE_ICU)
Locale locale;
canLocalize = _canLocalize(contentLangs, locale);
#endif
for (Uint32 i=0; i < indicationInstance.getPropertyCount(); i++)
{
CIMProperty property = indicationInstance.getProperty(i);
propertyName = property.getName().getString();
// get specified property value
if (String::equalNoCase(propertyName, specifiedPropertyName))
{
CIMValue propertyValue = property.getValue();
Boolean valueIsNull = propertyValue.isNull();
CIMType type = propertyValue.getType();
if (!valueIsNull)
{
Boolean isArray = propertyValue.isArray();
if (isArray)
{
PEG_METHOD_EXIT();
return (_getArrayValues(propertyValue, arrayIndexStr,
contentLangs));
}
else // value is not an array
{
#if defined(PEGASUS_HAS_ICU) && defined(PEGASUS_INDFORMATTER_USE_ICU)
if (canLocalize)
{
if (type == CIMTYPE_DATETIME)
{
CIMDateTime dateTimeValue;
propertyValue.get(dateTimeValue);
PEG_METHOD_EXIT();
return(_localizeDateTime(dateTimeValue, locale));
}
else if (type == CIMTYPE_BOOLEAN)
{
Boolean booleanValue;
propertyValue.get(booleanValue);
PEG_METHOD_EXIT();
return(_localizeBooleanStr(booleanValue, locale));
}
else
{
PEG_METHOD_EXIT();
return (propertyValue.toString());
}
}
else
{
if (type == CIMTYPE_BOOLEAN)
{
PEG_METHOD_EXIT();
return (_getBooleanStr(propertyValue));
}
else
{
PEG_METHOD_EXIT();
return (propertyValue.toString());
}
}
#else
if (type == CIMTYPE_BOOLEAN)
{
PEG_METHOD_EXIT();
return (_getBooleanStr(propertyValue));
}
else
{
PEG_METHOD_EXIT();
return (propertyValue.toString());
}
#endif
}
}
else // value is NULL
{
PEG_METHOD_EXIT();
return ("NULL");
}
}
propertyName.clear();
}
PEG_METHOD_EXIT();
return ("UNKNOWN");
}
String IndicationFormatter::_formatDefaultIndicationText(
const CIMInstance & indication,
const ContentLanguages & contentLangs)
{
PEG_METHOD_ENTER (TRC_IND_FORMATTER,
"IndicationFormatter::_formatDefaultIndicationText");
CIMInstance indicationInstance = indication.clone();
String propertyName;
String indicationStr;
Uint32 propertyCount = indicationInstance.getPropertyCount();
indicationStr.append("Indication (default format):");
Boolean canLocalize = false;
#if defined(PEGASUS_HAS_ICU) && defined(PEGASUS_INDFORMATTER_USE_ICU)
Locale locale;
canLocalize = _canLocalize(contentLangs, locale);
#endif
for (Uint32 i=0; i < propertyCount; i++)
{
CIMProperty property = indicationInstance.getProperty(i);
propertyName = property.getName().getString();
CIMValue propertyValue = property.getValue();
Boolean valueIsNull = propertyValue.isNull();
Boolean isArray = propertyValue.isArray();
indicationStr.append(propertyName);
indicationStr.append(" = ");
CIMType type = propertyValue.getType();
if (!valueIsNull)
{
if (isArray)
{
indicationStr.append(_getArrayValues(propertyValue, "",
contentLangs));
}
else // value is not an array
{
#if defined(PEGASUS_HAS_ICU) && defined(PEGASUS_INDFORMATTER_USE_ICU)
if (canLocalize)
{
if (type == CIMTYPE_DATETIME)
{
CIMDateTime dateTimeValue;
propertyValue.get(dateTimeValue);
indicationStr.append(_localizeDateTime(dateTimeValue,
locale));
}
else if (type == CIMTYPE_BOOLEAN)
{
Boolean booleanValue;
propertyValue.get(booleanValue);
indicationStr.append(_localizeBooleanStr(booleanValue,
locale));
}
else
{
indicationStr.append(propertyValue.toString());
}
}
else
{
if (type == CIMTYPE_BOOLEAN)
{
indicationStr.append(_getBooleanStr(propertyValue));
}
else
{
indicationStr.append(propertyValue.toString());
}
}
#else
if (type == CIMTYPE_BOOLEAN)
{
indicationStr.append(_getBooleanStr(propertyValue));
}
else
{
indicationStr.append(propertyValue.toString());
}
#endif
}
}
else
{
indicationStr.append("NULL");
}
if (i < propertyCount -1)
{
indicationStr.append(", ");
}
propertyName.clear();
}
PEG_METHOD_EXIT();
return (indicationStr);
}
Boolean UNIX_BIOSElement::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(), "InstallDate"))
{
CIMDateTime installDateValue;
property.getValue().get(installDateValue);
setInstallDate(installDateValue);
}
else if (String::equal(property.getName().getString(), "Name"))
{
String nameValue;
property.getValue().get(nameValue);
setName(nameValue);
}
else if (String::equal(property.getName().getString(), "OperationalStatus"))
{
Array<Uint16> operationalStatusValue;
property.getValue().get(operationalStatusValue);
setOperationalStatus(operationalStatusValue);
}
else if (String::equal(property.getName().getString(), "StatusDescriptions"))
{
Array<String> statusDescriptionsValue;
property.getValue().get(statusDescriptionsValue);
setStatusDescriptions(statusDescriptionsValue);
}
else if (String::equal(property.getName().getString(), "Status"))
{
String statusValue;
property.getValue().get(statusValue);
setStatus(statusValue);
}
else if (String::equal(property.getName().getString(), "HealthState"))
{
Uint16 healthStateValue;
property.getValue().get(healthStateValue);
setHealthState(healthStateValue);
}
else if (String::equal(property.getName().getString(), "CommunicationStatus"))
{
Uint16 communicationStatusValue;
property.getValue().get(communicationStatusValue);
setCommunicationStatus(communicationStatusValue);
}
else if (String::equal(property.getName().getString(), "DetailedStatus"))
{
Uint16 detailedStatusValue;
property.getValue().get(detailedStatusValue);
setDetailedStatus(detailedStatusValue);
}
else if (String::equal(property.getName().getString(), "OperatingStatus"))
{
Uint16 operatingStatusValue;
property.getValue().get(operatingStatusValue);
setOperatingStatus(operatingStatusValue);
}
else if (String::equal(property.getName().getString(), "PrimaryStatus"))
{
Uint16 primaryStatusValue;
property.getValue().get(primaryStatusValue);
setPrimaryStatus(primaryStatusValue);
}
else if (String::equal(property.getName().getString(), "Version"))
{
String versionValue;
property.getValue().get(versionValue);
setVersion(versionValue);
}
else if (String::equal(property.getName().getString(), "SoftwareElementState"))
{
Uint16 softwareElementStateValue;
property.getValue().get(softwareElementStateValue);
setSoftwareElementState(softwareElementStateValue);
}
else if (String::equal(property.getName().getString(), "SoftwareElementID"))
{
String softwareElementIDValue;
property.getValue().get(softwareElementIDValue);
setSoftwareElementID(softwareElementIDValue);
}
else if (String::equal(property.getName().getString(), "TargetOperatingSystem"))
{
Uint16 targetOperatingSystemValue;
property.getValue().get(targetOperatingSystemValue);
setTargetOperatingSystem(targetOperatingSystemValue);
}
else if (String::equal(property.getName().getString(), "OtherTargetOS"))
{
String otherTargetOSValue;
property.getValue().get(otherTargetOSValue);
setOtherTargetOS(otherTargetOSValue);
}
else if (String::equal(property.getName().getString(), "Manufacturer"))
{
String manufacturerValue;
property.getValue().get(manufacturerValue);
setManufacturer(manufacturerValue);
}
else if (String::equal(property.getName().getString(), "BuildNumber"))
{
String buildNumberValue;
property.getValue().get(buildNumberValue);
setBuildNumber(buildNumberValue);
}
else if (String::equal(property.getName().getString(), "SerialNumber"))
{
String serialNumberValue;
property.getValue().get(serialNumberValue);
setSerialNumber(serialNumberValue);
}
else if (String::equal(property.getName().getString(), "CodeSet"))
{
String codeSetValue;
property.getValue().get(codeSetValue);
setCodeSet(codeSetValue);
}
else if (String::equal(property.getName().getString(), "IdentificationCode"))
{
String identificationCodeValue;
property.getValue().get(identificationCodeValue);
setIdentificationCode(identificationCodeValue);
}
else if (String::equal(property.getName().getString(), "LanguageEdition"))
{
String languageEditionValue;
property.getValue().get(languageEditionValue);
setLanguageEdition(languageEditionValue);
}
else if (String::equal(property.getName().getString(), "PrimaryBIOS"))
{
Boolean primaryBIOSValue;
property.getValue().get(primaryBIOSValue);
setPrimaryBIOS(primaryBIOSValue);
}
else if (String::equal(property.getName().getString(), "ListOfLanguages"))
{
Array<String> listOfLanguagesValue;
property.getValue().get(listOfLanguagesValue);
setListOfLanguages(listOfLanguagesValue);
}
else if (String::equal(property.getName().getString(), "CurrentLanguage"))
{
String currentLanguageValue;
property.getValue().get(currentLanguageValue);
setCurrentLanguage(currentLanguageValue);
}
else if (String::equal(property.getName().getString(), "LoadedStartingAddress"))
{
Uint64 loadedStartingAddressValue;
property.getValue().get(loadedStartingAddressValue);
setLoadedStartingAddress(loadedStartingAddressValue);
}
else if (String::equal(property.getName().getString(), "LoadedEndingAddress"))
{
Uint64 loadedEndingAddressValue;
property.getValue().get(loadedEndingAddressValue);
setLoadedEndingAddress(loadedEndingAddressValue);
}
else if (String::equal(property.getName().getString(), "LoadUtilityInformation"))
{
String loadUtilityInformationValue;
property.getValue().get(loadUtilityInformationValue);
setLoadUtilityInformation(loadUtilityInformationValue);
}
else if (String::equal(property.getName().getString(), "ReleaseDate"))
{
CIMDateTime releaseDateValue;
property.getValue().get(releaseDateValue);
setReleaseDate(releaseDateValue);
}
else if (String::equal(property.getName().getString(), "SystemBIOSMajorRelease"))
{
Uint8 systemBIOSMajorReleaseValue;
property.getValue().get(systemBIOSMajorReleaseValue);
setSystemBIOSMajorRelease(systemBIOSMajorReleaseValue);
}
else if (String::equal(property.getName().getString(), "SystemBIOSMinorRelease"))
{
Uint8 systemBIOSMinorReleaseValue;
property.getValue().get(systemBIOSMinorReleaseValue);
setSystemBIOSMinorRelease(systemBIOSMinorReleaseValue);
}
else if (String::equal(property.getName().getString(), "EmbeddedControllerFirmwareMajorRelease"))
{
Uint8 embeddedControllerFirmwareMajorReleaseValue;
property.getValue().get(embeddedControllerFirmwareMajorReleaseValue);
setEmbeddedControllerFirmwareMajorRelease(embeddedControllerFirmwareMajorReleaseValue);
}
else if (String::equal(property.getName().getString(), "EmbeddedControllerFirmwareMinorRelease"))
{
Uint8 embeddedControllerFirmwareMinorReleaseValue;
property.getValue().get(embeddedControllerFirmwareMinorReleaseValue);
setEmbeddedControllerFirmwareMinorRelease(embeddedControllerFirmwareMinorReleaseValue);
}
else if (String::equal(property.getName().getString(), "RegistryURIs"))
{
Array<String> registryURIsValue;
property.getValue().get(registryURIsValue);
setRegistryURIs(registryURIsValue);
}
}
return true;
}
// private method: _testPropertyTypesValue
void PG_TestPropertyTypes::_testPropertyTypesValue(
const CIMInstance& instanceObject)
{
Uint32 PropertyCount = instanceObject.getPropertyCount();
Uint32 j;
for (j = 0; j < PropertyCount; j++)
{
const CIMConstProperty& property = instanceObject.getProperty(j);
const CIMValue& propertyValue = property.getValue();
CIMType type = propertyValue.getType();
switch (type)
{
case CIMTYPE_UINT8:
Uint8 propertyValueUint8;
propertyValue.get(propertyValueUint8);
if (propertyValueUint8 >= 255)
{
throw CIMException(CIM_ERR_INVALID_PARAMETER);
}
break;
case CIMTYPE_UINT16:
Uint16 propertyValueUint16;
propertyValue.get(propertyValueUint16);
if (propertyValueUint16 >= 10000)
{
throw CIMException(CIM_ERR_INVALID_PARAMETER);
}
break;
case CIMTYPE_UINT32:
Uint32 propertyValueUint32;
propertyValue.get(propertyValueUint32);
if (propertyValueUint32 >= 10000000)
{
throw CIMException(CIM_ERR_INVALID_PARAMETER);
}
break;
case CIMTYPE_UINT64:
Uint64 propertyValueUint64;
propertyValue.get(propertyValueUint64);
if (propertyValueUint64 >= 1000000000)
{
throw CIMException(CIM_ERR_INVALID_PARAMETER);
}
break;
case CIMTYPE_SINT8:
Sint8 propertyValueSint8;
propertyValue.get(propertyValueSint8);
if (propertyValueSint8 <= (Sint8)-120)
{
throw CIMException(CIM_ERR_INVALID_PARAMETER);
}
break;
case CIMTYPE_SINT16:
Sint16 propertyValueSint16;
propertyValue.get(propertyValueSint16);
if (propertyValueSint16 < -10000)
{
throw CIMException(CIM_ERR_INVALID_PARAMETER);
}
break;
case CIMTYPE_SINT32:
Sint32 propertyValueSint32;
propertyValue.get(propertyValueSint32);
if (propertyValueSint32 <= -10000000)
{
throw CIMException(CIM_ERR_INVALID_PARAMETER);
}
break;
case CIMTYPE_SINT64:
Sint64 propertyValueSint64;
propertyValue.get(propertyValueSint64);
if (propertyValueSint64 <= -1000000000)
{
throw CIMException(CIM_ERR_INVALID_PARAMETER);
}
break;
case CIMTYPE_REAL32:
Real32 propertyValueReal32;
propertyValue.get(propertyValueReal32);
if (propertyValueReal32 >= 10000000.32)
{
throw CIMException(CIM_ERR_INVALID_PARAMETER);
}
break;
case CIMTYPE_REAL64:
Real64 propertyValueReal64;
propertyValue.get(propertyValueReal64);
if (propertyValueReal64 >= 1000000000.64)
{
throw CIMException(CIM_ERR_INVALID_PARAMETER);
}
break;
default:
;
}
} // end for loop
}
// Tests PROPERTY as an embedded object.
static void testGetInstanceElement(const char* testDataFile)
{
//--------------------------------------------------------------------------
// Read in instance
//--------------------------------------------------------------------------
CIMInstance cimInstance;
Buffer text;
FileSystem::loadFileToMemory(text, testDataFile);
XmlParser parser((char*)text.getData());
XmlReader::getInstanceElement(parser, cimInstance);
PEGASUS_TEST_ASSERT(
cimInstance.getClassName() == CIMName("CIM_InstCreation"));
Uint32 idx;
CIMProperty cimProperty;
CIMValue cimValue;
CIMType cimType;
PEGASUS_TEST_ASSERT(cimInstance.getPropertyCount() == 3);
idx = cimInstance.findProperty(CIMName("IndicationIdentifier"));
PEGASUS_TEST_ASSERT(idx != PEG_NOT_FOUND);
cimProperty = cimInstance.getProperty(idx);
cimValue = cimProperty.getValue();
cimType = cimProperty.getType();
PEGASUS_TEST_ASSERT(strcmp(cimTypeToString(cimType), "string") == 0);
String myString;
cimValue.get(myString);
PEGASUS_TEST_ASSERT(strcmp(myString.getCString(), "0") == 0);
idx = cimInstance.findProperty(CIMName("IndicationTime"));
PEGASUS_TEST_ASSERT(idx != PEG_NOT_FOUND);
cimProperty = cimInstance.getProperty(idx);
cimValue = cimProperty.getValue();
cimType = cimProperty.getType();
PEGASUS_TEST_ASSERT(strcmp(cimTypeToString(cimType), "datetime") == 0);
CIMDateTime myDateTime;
cimValue.get(myDateTime);
PEGASUS_TEST_ASSERT(myDateTime.equal(
CIMDateTime("20050227225624.524000-300")));
idx = cimInstance.findProperty(CIMName("SourceInstance"));
PEGASUS_TEST_ASSERT(idx != PEG_NOT_FOUND);
cimProperty = cimInstance.getProperty(idx);
cimValue = cimProperty.getValue();
cimType = cimProperty.getType();
PEGASUS_TEST_ASSERT(strcmp(cimTypeToString(cimType), "object") == 0);
CIMObject cimObject;
cimValue.get(cimObject);
PEGASUS_TEST_ASSERT(
cimObject.getClassName() ==
CIMName("Sample_LifecycleIndicationProviderClass"));
PEGASUS_TEST_ASSERT(cimObject.getPropertyCount() == 2);
idx = cimObject.findProperty(CIMName("uniqueId"));
PEGASUS_TEST_ASSERT(idx != PEG_NOT_FOUND);
cimProperty = cimObject.getProperty(idx);
cimValue = cimProperty.getValue();
cimType = cimProperty.getType();
PEGASUS_TEST_ASSERT(strcmp(cimTypeToString(cimType), "uint32") == 0);
Uint32 myUint32;
cimValue.get(myUint32);
PEGASUS_TEST_ASSERT(myUint32 == 1);
idx = cimObject.findProperty(CIMName("lastOp"));
PEGASUS_TEST_ASSERT(idx != PEG_NOT_FOUND);
cimProperty = cimObject.getProperty(idx);
cimValue = cimProperty.getValue();
cimType = cimProperty.getType();
PEGASUS_TEST_ASSERT(strcmp(cimTypeToString(cimType), "string") == 0);
cimValue.get(myString);
PEGASUS_TEST_ASSERT(strcmp(myString.getCString(), "createInstance") == 0);
}
//
// Test of the Instance creation and instance filtering
//
void test04()
{
if (verbose)
{
cout << "Test04 - Create instance from Class. " << endl;
}
const CIMNamespaceName NAMESPACE = CIMNamespaceName("/zzz");
// Create and populate a declaration context:
SimpleDeclContext* context = new SimpleDeclContext;
context->addQualifierDecl(
NAMESPACE, CIMQualifierDecl(CIMName("counter"), false,
CIMScope::PROPERTY));
context->addQualifierDecl(
NAMESPACE, CIMQualifierDecl(CIMName("classcounter"), false,
CIMScope::CLASS));
context->addQualifierDecl(
NAMESPACE, CIMQualifierDecl(CIMName("min"), String(),
CIMScope::PROPERTY));
context->addQualifierDecl(
NAMESPACE, CIMQualifierDecl(CIMName("max"), String(),
CIMScope::PROPERTY));
context->addQualifierDecl(NAMESPACE,
CIMQualifierDecl(CIMName("Description"), String(),
CIMScope::PROPERTY));
CIMClass class1(CIMName("MyClass"));
class1
.addProperty(CIMProperty(CIMName("count"), Uint32(55))
.addQualifier(CIMQualifier(CIMName("counter"), true))
.addQualifier(CIMQualifier(CIMName("min"), String("0")))
.addQualifier(CIMQualifier(CIMName("max"), String("1"))))
.addProperty(CIMProperty(CIMName("message"), String("Hello"))
.addQualifier(CIMQualifier(CIMName("description"),
String("My Message"))))
.addProperty(CIMProperty(CIMName("ratio"), Real32(1.5)));
Resolver::resolveClass(class1, context, NAMESPACE);
context->addClass(NAMESPACE, class1);
if (verbose)
{
XmlWriter::printClassElement(class1);
}
//
// Create instance with qualifiers, classorigin, and Null propertyList
//
{
CIMInstance newInstance;
newInstance = class1.buildInstance(true, true, CIMPropertyList());
if (verbose)
{
XmlWriter::printInstanceElement(newInstance);
}
assert(newInstance.getPropertyCount() == class1.getPropertyCount());
assert(newInstance.getQualifierCount() == class1.getQualifierCount());
assert(newInstance.findProperty("ratio") != PEG_NOT_FOUND);
assert(newInstance.findProperty("message") != PEG_NOT_FOUND);
}
//
// Test with include qualifiers false. Should be no qualifiers in result
//
{
CIMInstance newInstance =
class1.buildInstance(false, true, CIMPropertyList());
assert(newInstance.getQualifierCount() == 0);
assert(newInstance.getPropertyCount() == class1.getPropertyCount());
assert(newInstance.findProperty("ratio") != PEG_NOT_FOUND);
assert(newInstance.findProperty("message") != PEG_NOT_FOUND);
}
//
// Test with empty property list. Should have no properties.
//
{
Array<CIMName> pl1Array;
CIMPropertyList pl1(pl1Array);
CIMInstance newInstance = class1.buildInstance(false, true, pl1);
assert(newInstance.getQualifierCount() == 0);
assert(newInstance.getPropertyCount() == 0);
}
//
// Test with a property that exists in property list.
//
{
Array<CIMName> pl1Array;
pl1Array.append("ratio");
CIMPropertyList pl1(pl1Array);
CIMInstance newInstance = class1.buildInstance(false, true, pl1);
if (verbose)
{
cout << "Test with one property in new instance" << endl;
XmlWriter::printInstanceElement(newInstance);
}
assert(newInstance.getPropertyCount() == 1);
assert(newInstance.findProperty("ratio") != PEG_NOT_FOUND);
assert(newInstance.findProperty("message") == PEG_NOT_FOUND);
assert(newInstance.getQualifierCount() == 0);
}
//
// Test with a property that does/does not exist in property list
//
{
Array<CIMName> pl1Array;
CIMPropertyList pl1(pl1Array);
pl1.clear();
pl1Array.append("blob");
pl1Array.append("ratio");
pl1.set(pl1Array);
CIMInstance newInstance = class1.buildInstance(false, true, pl1);
assert(newInstance.getPropertyCount() == 1);
assert(newInstance.findProperty("ratio") != PEG_NOT_FOUND);
assert(newInstance.findProperty("blob") == PEG_NOT_FOUND);
assert(newInstance.findProperty("message") == PEG_NOT_FOUND);
assert(newInstance.getQualifierCount() == 0);
}
///////////////////////////////////////////////////////////////////////
//
// Instance Filtering function tests
//
///////////////////////////////////////////////////////////////////////
// build instance as starting point for tests.
CIMInstance tstInstance =
class1.buildInstance(true, true, CIMPropertyList());
//
// Test complete copy, no change
//
{
if (verbose)
{
cout << "Test1" << endl;
}
CIMInstance filterInstance = tstInstance.clone();
filterInstance.filter(true, true, CIMPropertyList());
assert(tstInstance.identical(filterInstance));
assert(filterInstance.getPropertyCount() == 3);
assert(filterInstance.getQualifierCount() ==
tstInstance.getQualifierCount());
}
//
// Filter to one property, ratio
//
{
if (verbose)
{
cout << "Test2" << endl;
}
Array<CIMName> pl1Array;
pl1Array.append("ratio");
CIMPropertyList pl1(pl1Array);
CIMInstance filterInstance = tstInstance.clone();
filterInstance.filter(true, true, pl1);
if (verbose)
{
XmlWriter::printInstanceElement(filterInstance);
}
assert(filterInstance.getPropertyCount() == 1);
assert(filterInstance.findProperty("ratio") != PEG_NOT_FOUND);
assert(_propertyIdentical("ratio", filterInstance, tstInstance));
assert(filterInstance.getQualifierCount() ==
tstInstance.getQualifierCount());
}
//
// Filter to one property, message
//
{
if (verbose)
{
cout << "Test3" << endl;
}
Array<CIMName> pl1Array;
pl1Array.append("message");
CIMPropertyList pl1(pl1Array);
CIMInstance filterInstance = tstInstance.clone();
filterInstance.filter(true, true, pl1);
if (verbose)
{
XmlWriter::printInstanceElement(filterInstance);
}
assert(filterInstance.getPropertyCount() == 1);
assert(filterInstance.findProperty("message") != PEG_NOT_FOUND);
assert(_propertyIdentical("message", filterInstance, tstInstance));
assert(filterInstance.getQualifierCount() ==
tstInstance.getQualifierCount());
}
//
// Filter to one property, count
//
{
if (verbose)
{
cout << "Test4" << endl;
}
Array<CIMName> pl1Array;
pl1Array.append("count");
CIMPropertyList pl1(pl1Array);
CIMInstance filterInstance = tstInstance.clone();
filterInstance.filter(true, true, pl1);
if (verbose)
{
XmlWriter::printInstanceElement(filterInstance);
}
assert(filterInstance.getPropertyCount() == 1);
assert(filterInstance.findProperty("count") != PEG_NOT_FOUND);
assert(filterInstance.getQualifierCount() ==
tstInstance.getQualifierCount());
}
//
// Filter to no properties
//
{
if (verbose)
{
cout << "Test5a" << endl;
}
Array<CIMName> pl1Array;
CIMPropertyList pl1(pl1Array);
CIMInstance filterInstance = tstInstance.clone();
filterInstance.filter(true, true, pl1);
assert(filterInstance.getPropertyCount() == 0);
assert(filterInstance.findProperty("ratio") == PEG_NOT_FOUND);
assert(filterInstance.getQualifierCount() ==
tstInstance.getQualifierCount());
}
//
// Filter to two properties
//
{
if (verbose)
{
cout << "Test5b" << endl;
}
Array<CIMName> pl1Array;
pl1Array.append("count");
pl1Array.append("message");
CIMPropertyList pl1(pl1Array);
CIMInstance filterInstance = tstInstance.clone();
filterInstance.filter(true, true, pl1);
assert(filterInstance.getPropertyCount() == 2);
assert(filterInstance.findProperty("ratio") == PEG_NOT_FOUND);
assert(filterInstance.findProperty("message") != PEG_NOT_FOUND);
assert(_propertyIdentical("message", filterInstance, tstInstance));
assert(filterInstance.findProperty("count") != PEG_NOT_FOUND);
assert(_propertyIdentical("count", filterInstance, tstInstance));
assert(filterInstance.getQualifierCount() ==
tstInstance.getQualifierCount());
}
//
// Filter to no qualifiers and all properties.
//
{
if (verbose)
{
cout << "Test6" << endl;
}
CIMInstance filterInstance = tstInstance.clone();
filterInstance.filter(false, true, CIMPropertyList());
assert(filterInstance.getPropertyCount() == 3);
assert(filterInstance.findProperty("ratio") != PEG_NOT_FOUND);
assert(filterInstance.getQualifierCount() == 0);
for (Uint32 i = 0; i < filterInstance.getPropertyCount() ; i++)
{
CIMConstProperty p = filterInstance.getProperty(i);
assert(p.getQualifierCount() == 0);
}
}
//
// Filter to no qualifiers and no properties.
//
{
if (verbose)
{
cout << "Test6a" << endl;
}
Array<CIMName> pl1Array;
CIMPropertyList pl1(pl1Array);
CIMInstance filterInstance = tstInstance.clone();
filterInstance.filter(false, true, pl1);
assert(filterInstance.getPropertyCount() == 0);
assert(filterInstance.findProperty("ratio") == PEG_NOT_FOUND);
assert(filterInstance.getQualifierCount() == 0);
}
//
// Test Class Origin Filter
//
{
if (verbose)
{
cout << "Test7 Class Origin" << endl;
}
// Create a subclass to do classOrigin testing
CIMClass mySubClass(CIMName("subclass"));
mySubClass.setSuperClassName(CIMName("MyClass"));
Resolver::resolveClass(mySubClass, context, NAMESPACE);
context->addClass(NAMESPACE, mySubClass);
// build instance
CIMInstance filterInstance =
mySubClass.buildInstance(true, true, CIMPropertyList());
filterInstance.filter(false, true, CIMPropertyList());
assert(filterInstance.getPropertyCount() == 3);
assert(filterInstance.findProperty("ratio") != PEG_NOT_FOUND);
assert(filterInstance.getQualifierCount() == 0);
for (Uint32 i = 0 ; i < filterInstance.getPropertyCount() ; i++)
{
CIMProperty p = filterInstance.getProperty(i);
assert(!(p.getClassOrigin() == CIMName()));
}
filterInstance.filter(false, false, CIMPropertyList());
for (Uint32 i = 0 ; i < filterInstance.getPropertyCount() ; i++)
{
CIMProperty p = filterInstance.getProperty(i);
assert(p.getClassOrigin() == CIMName());
}
CIMInstance filterInstance2 =
mySubClass.buildInstance(true, false, CIMPropertyList());
for (Uint32 i = 0 ; i < filterInstance2.getPropertyCount() ; i++)
{
CIMProperty p = filterInstance2.getProperty(i);
assert(p.getClassOrigin() == CIMName());
}
}
delete context;
}
// l10n - note: ignoring indication language
void snmpIndicationHandler::handleIndication(
const OperationContext& context,
const String nameSpace,
CIMInstance& indication,
CIMInstance& handler,
CIMInstance& subscription,
ContentLanguageList & contentLanguages)
{
Array<String> propOIDs;
Array<String> propTYPEs;
Array<String> propVALUEs;
Array<String> mapStr;
PEG_METHOD_ENTER(TRC_IND_HANDLER,
"snmpIndicationHandler::handleIndication");
try
{
PEG_TRACE ((TRC_INDICATION_GENERATION, Tracer::LEVEL4,
"snmpIndicationHandler %s:%s.%s processing %s Indication",
(const char*)(nameSpace.getCString()),
(const char*)(handler.getClassName().getString().getCString()),
(const char*)(handler.getProperty(
handler.findProperty(PEGASUS_PROPERTYNAME_NAME)).
getValue().toString().getCString()),
(const char*)(indication.getClassName().getString().
getCString())));
CIMClass indicationClass = _repository->getClass(
nameSpace, indication.getClassName(), false, true,
false, CIMPropertyList());
Uint32 propertyCount = indication.getPropertyCount();
for (Uint32 i=0; i < propertyCount; i++)
{
CIMProperty prop = indication.getProperty(i);
Uint32 propDeclPos = indicationClass.findProperty(prop.getName());
if (propDeclPos != PEG_NOT_FOUND)
{
CIMProperty propDecl = indicationClass.getProperty(propDeclPos);
Uint32 qualifierPos =
propDecl.findQualifier(CIMName("MappingStrings"));
if (qualifierPos != PEG_NOT_FOUND)
{
//
// We are looking for following fields:
// MappingStrings {"OID.IETF | SNMP." oidStr,
// "DataType.IETF |" dataType}
// oidStr is the object identifier (e.g. "1.3.6.1.2.1.5..."
// dataType is either Integer, or OctetString,
// or OID
// Following is one example:
// MappingStrings {"OID.IETF | SNMP.1.3.6.6.3.1.1.5.2",
// "DataType.IETF | Integer"}
//
propDecl.getQualifier(qualifierPos).getValue().get(
mapStr);
String oidStr, dataType;
String mapStr1, mapStr2;
Boolean isValidAuthority = false;
Boolean isValidDataType = false;
for (Uint32 j=0; j < mapStr.size(); j++)
{
Uint32 barPos = mapStr[j].find("|");
if (barPos != PEG_NOT_FOUND)
{
mapStr1 = mapStr[j].subString(0, barPos);
mapStr2 = mapStr[j].subString(barPos + 1);
_trimWhitespace(mapStr1);
_trimWhitespace(mapStr2);
if ((mapStr1 == "OID.IETF") &&
(String::compare(mapStr2,
String("SNMP."), 5) == 0))
{
isValidAuthority = true;
oidStr = mapStr2.subString(5);
}
else if (mapStr1 == "DataType.IETF")
{
isValidDataType = true;
dataType = mapStr2;
}
if (isValidAuthority && isValidDataType)
{
propOIDs.append(oidStr);
propTYPEs.append(dataType);
propVALUEs.append(prop.getValue().toString());
break;
}
}
}
}
}
}
// Collected complete data in arrays and ready to send the trap.
// trap destination and SNMP type are defined in handlerInstance
// and passing this instance as it is to deliverTrap() call
Uint32 targetHostPos = handler.findProperty(CIMName("TargetHost"));
Uint32 targetHostFormatPos =
handler.findProperty(CIMName("TargetHostFormat"));
Uint32 otherTargetHostFormatPos =
handler.findProperty(CIMName("OtherTargetHostFormat"));
Uint32 portNumberPos = handler.findProperty(CIMName("PortNumber"));
Uint32 snmpVersionPos = handler.findProperty(CIMName("SNMPVersion"));
Uint32 securityNamePos =
handler.findProperty(CIMName("SNMPSecurityName"));
Uint32 engineIDPos = handler.findProperty(CIMName("SNMPEngineID"));
Uint32 snmpSecLevelPos =
handler.findProperty(CIMName("SNMPSecurityLevel"));
Uint32 snmpSecAuthProtoPos =
handler.findProperty(CIMName("SNMPSecurityAuthProtocol"));
Uint32 snmpSecAuthKeyPos =
handler.findProperty(CIMName("SNMPSecurityAuthKey"));
Uint32 snmpSecPrivProtoPos =
handler.findProperty(CIMName("SNMPSecurityPrivProtocol"));
Uint32 snmpSecPrivKeyPos =
handler.findProperty(CIMName("SNMPSecurityPrivKey"));
if (targetHostPos == PEG_NOT_FOUND)
{
PEG_TRACE((TRC_DISCARDED_DATA, Tracer::LEVEL1,
"Target host is not set for IndicationHandlerSNMPMapper %s"
" Indication.",
(const char*)(indication.getClassName().getString().
getCString())));
PEG_METHOD_EXIT();
throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED, MessageLoaderParms(
"Handler.snmpIndicationHandler.snmpIndicationHandler."
"INVALID_SNMP_INSTANCE",
"Invalid IndicationHandlerSNMPMapper instance"));
}
if (targetHostFormatPos == PEG_NOT_FOUND)
{
PEG_TRACE((TRC_DISCARDED_DATA, Tracer::LEVEL1,
"Target host format is not set for IndicationHandlerSNMPMapper"
" %s Indication.",
(const char*)(indication.getClassName().getString().
getCString())));
PEG_METHOD_EXIT();
throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED, MessageLoaderParms(
"Handler.snmpIndicationHandler.snmpIndicationHandler."
"INVALID_SNMP_INSTANCE",
"Invalid IndicationHandlerSNMPMapper instance"));
}
if (snmpVersionPos == PEG_NOT_FOUND)
{
PEG_TRACE((TRC_DISCARDED_DATA, Tracer::LEVEL1,
"SNMP Version is not set for IndicationHandlerSNMPMapper %s"
" Indication.",
(const char*)(indication.getClassName().getString().
getCString())));
PEG_METHOD_EXIT();
throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED, MessageLoaderParms(
"Handler.snmpIndicationHandler.snmpIndicationHandler."
"INVALID_SNMP_INSTANCE",
"Invalid IndicationHandlerSNMPMapper instance"));
}
else
{
// properties from the handler instance
String targetHost;
String otherTargetHostFormat = String();
String securityName = String();
String engineID = String();
Uint16 targetHostFormat = 0;
Uint16 snmpVersion = 0;
Uint32 portNumber;
Uint8 snmpSecLevel = 1; // noAuthnoPriv
Uint8 snmpSecAuthProto = 0;
Array<Uint8> snmpSecAuthKey;// no key
Uint8 snmpSecPrivProto = 0;
Array<Uint8> snmpSecPrivKey ;// no key
String trapOid;
Boolean trapOidAvailable = false;
//
// Get snmpTrapOid from context
//
if (context.contains(SnmpTrapOidContainer::NAME))
{
SnmpTrapOidContainer trapContainer =
context.get(SnmpTrapOidContainer::NAME);
trapOid = trapContainer.getSnmpTrapOid();
trapOidAvailable = true;
}
else
{
// get trapOid from indication Class
Uint32 pos =
indicationClass.findQualifier(CIMName("MappingStrings"));
if (pos != PEG_NOT_FOUND)
{
Array<String> classMapStr;
indicationClass.getQualifier(pos).getValue().
get(classMapStr);
for (Uint32 i=0; i < classMapStr.size(); i++)
{
Uint32 barPos = classMapStr[i].find("|");
if (barPos != PEG_NOT_FOUND)
{
String authorityName =
classMapStr[i].subString(0, barPos);
String oidStr = classMapStr[i].subString(
barPos+1, PEG_NOT_FOUND);
_trimWhitespace(authorityName);
_trimWhitespace(oidStr);
if ((authorityName == "OID.IETF") &&
(String::compare(oidStr,
String("SNMP."), 5) == 0))
{
trapOid = oidStr.subString(5);
trapOidAvailable = true;
break;
}
}
}
if (!trapOidAvailable)
{
PEG_TRACE((
TRC_IND_HANDLER,
Tracer::LEVEL1,
"No MappingStrings for snmp trap is specified "
"for class: %s",
(const char*)
indication.getClassName().getString().getCString()
));
PEG_METHOD_EXIT();
throw PEGASUS_CIM_EXCEPTION_L(
CIM_ERR_FAILED,
MessageLoaderParms(
"Handler.snmpIndicationHandler."
"snmpIndicationHandler.NO_MS_FOR_SNMP_TRAP",
"No MappingStrings for snmp trap is specified "
"for class: $0",
indication.getClassName().getString()));
}
}
else
{
PEG_TRACE_CSTRING(TRC_IND_HANDLER, Tracer::LEVEL1,
"Qualifier MappingStrings can not be found.");
PEG_METHOD_EXIT();
MessageLoaderParms parms(
"Handler.snmpIndicationHandler.snmpIndicationHandler."
"QUALIFIER_MAPPINGS_NOT_FOUND",
"Qualifier MappingStrings can not be found");
throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED, parms);
}
}
handler.getProperty(targetHostPos).getValue().get(targetHost);
handler.getProperty(targetHostFormatPos).getValue().get(
targetHostFormat);
if (otherTargetHostFormatPos != PEG_NOT_FOUND)
{
handler.getProperty(otherTargetHostFormatPos).getValue().get(
otherTargetHostFormat);
}
if (portNumberPos != PEG_NOT_FOUND)
{
handler.getProperty(portNumberPos).getValue().get(portNumber);
}
else
{
// default port
portNumber = SNMP_TRAP_DEFAULT_PORT;
}
handler.getProperty(snmpVersionPos).getValue().get(snmpVersion);
if (securityNamePos != PEG_NOT_FOUND)
{
handler.getProperty(securityNamePos).getValue().get(
securityName);
}
if (engineIDPos != PEG_NOT_FOUND)
{
handler.getProperty(engineIDPos).getValue().get(engineID);
}
if(snmpVersion == 5) // SNMPv3 Trap
{
//fetch the security data
if(snmpSecLevelPos != PEG_NOT_FOUND)
{
handler.getProperty(snmpSecLevelPos).getValue(). \
get(snmpSecLevel);
}
if(snmpSecAuthProtoPos != PEG_NOT_FOUND)
{
handler.getProperty(snmpSecAuthProtoPos).getValue(). \
get(snmpSecAuthProto);
}
if(snmpSecAuthKeyPos != PEG_NOT_FOUND)
{
handler.getProperty(snmpSecAuthKeyPos).getValue(). \
get(snmpSecAuthKey);
}
if(snmpSecPrivProtoPos != PEG_NOT_FOUND)
{
handler.getProperty(snmpSecPrivProtoPos).getValue(). \
get(snmpSecPrivProto);
}
if(snmpSecPrivKeyPos!= PEG_NOT_FOUND)
{
handler.getProperty(snmpSecPrivKeyPos).getValue(). \
get(snmpSecPrivKey);
}
}
PEG_TRACE ((TRC_INDICATION_GENERATION, Tracer::LEVEL4,
"snmpIndicationHandler sending %s Indication trap %s to target"
" host %s target port %d",
(const char*)(indication.getClassName().getString().
getCString()),
(const char*)(trapOid.getCString()),
(const char*)(targetHost.getCString()),portNumber));
_snmpTrapSender->deliverTrap(
trapOid,
securityName,
targetHost,
targetHostFormat,
otherTargetHostFormat,
portNumber,
snmpVersion,
engineID,
snmpSecLevel,
snmpSecAuthProto,
snmpSecAuthKey,
snmpSecPrivProto,
snmpSecPrivKey,
propOIDs,
propTYPEs,
propVALUEs);
PEG_TRACE ((TRC_INDICATION_GENERATION, Tracer::LEVEL4,
"%s Indication trap %s sent to target host %s target port %d "
"successfully",
(const char*)(indication.getClassName().getString().getCString()),
(const char*)(trapOid.getCString()),
(const char*)(targetHost.getCString()),portNumber));
}
}
catch (CIMException& c)
{
PEG_TRACE((TRC_IND_HANDLER, Tracer::LEVEL1, "CIMException %s",
(const char*)c.getMessage().getCString()));
PEG_METHOD_EXIT();
throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, c.getMessage());
}
catch (Exception& e)
{
PEG_TRACE((TRC_IND_HANDLER, Tracer::LEVEL1, "Exception %s",
(const char*)e.getMessage().getCString()));
PEG_METHOD_EXIT();
throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED, e.getMessage());
}
catch (...)
{
PEG_TRACE_CSTRING(TRC_IND_HANDLER, Tracer::LEVEL1,
"Failed to deliver trap.");
PEG_METHOD_EXIT();
throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED, MessageLoaderParms(
"Handler.snmpIndicationHandler.snmpIndicationHandler."
"FAILED_TO_DELIVER_TRAP",
"Failed to deliver trap."));
}
PEG_METHOD_EXIT();
}
void OSInfoCommand::gatherProperties(CIMInstance &inst, Boolean cimFormat)
{
// 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 ("CSName")))
{
inst.getProperty(j).getValue().get(osCSName);
} // end if CSName
else if (propertyName.equal (CIMName ("Name")))
{
inst.getProperty(j).getValue().get(osName);
} // end if Name
else if (propertyName.equal (CIMName ("NumberOfProcesses")))
{
Uint32 propertyValue;
inst.getProperty(j).getValue().get(propertyValue);
char tmpString[80];
sprintf(tmpString, "%d processes", propertyValue);
osNumberOfProcesses.assign(tmpString);
} // end if NumberOfProcesses
else if (propertyName.equal (CIMName ("NumberOfUsers")))
{
Uint32 propertyValue;
inst.getProperty(j).getValue().get(propertyValue);
char tmpString[80];
sprintf(tmpString, "%d users", propertyValue);
osNumberOfUsers.assign(tmpString);
} // end if NumberOfUsers
if (propertyName.equal (CIMName ("Version")))
{
inst.getProperty(j).getValue().get(osVersion);
} // end if Version
else if (propertyName.equal (CIMName ("OperatingSystemCapability")))
{
inst.getProperty(j).getValue().get(osCapability);
} // end if OSCapability
else if (propertyName.equal (CIMName ("OtherTypeDescription")))
{
inst.getProperty(j).getValue().get(osOtherInfo);
} // end if OtherTypeDescription
else if (propertyName.equal (CIMName ("NumberOfLicensedUsers")))
{
Uint32 propertyValue;
inst.getProperty(j).getValue().get(propertyValue);
// special consideration for HP-UX
if (propertyValue == 0)
{
if (String::equalNoCase(osVersion,"HP-UX"))
{
osLicensedUsers.assign("128, 256, or unlimited users");
}
else
{
osLicensedUsers.assign("Unlimited user license");
}
} // end if 0 as number of licensed users
else // standard number of users
{
char users[80];
sprintf(users, "%d users", propertyValue);
osLicensedUsers.assign(users);
}
} // end if NumberOfLicensedUsers
else if (propertyName.equal (CIMName ("LastBootUpTime")))
{
CIMDateTime bdate;
char bdateString[80];
inst.getProperty(j).getValue().get(bdate);
CString dtStr = bdate.toString().getCString();
if (!cimFormat)
{ // else leave in raw CIM
formatCIMDateTime(dtStr, bdateString);
}
else
{
sprintf(bdateString,"%s",(const char*)dtStr);
}
osBootUpTime.assign(bdateString);
} // end if LastBootUpTime
else if (propertyName.equal (CIMName ("LocalDateTime")))
{
CIMDateTime ldate;
char ldateString[80];
inst.getProperty(j).getValue().get(ldate);
CString dtStr = ldate.toString().getCString();
if (!cimFormat)
{ // else leave in raw CIM
formatCIMDateTime(dtStr, ldateString);
}
else
{
sprintf(ldateString,"%s",(const char*)dtStr);
}
osLocalDateTime.assign(ldateString);
} // end if LocalDateTime
else if (propertyName.equal (CIMName ("SystemUpTime")))
{
Uint64 total;
char uptime[80];
inst.getProperty(j).getValue().get(total);
if (!cimFormat)
{ // else leave in raw CIM
// let's make things a bit easier for our user to read
Uint64 days = 0;
Uint32 hours = 0;
Uint32 minutes = 0;
Uint32 seconds = 0;
Uint64 totalSeconds = total;
seconds = Uint32(total%60);
total = total/60;
minutes = Uint32(total%60);
total = total/60;
hours = Uint32(total%24);
total = total/24;
days = total;
// now deal with the proper singular/plural
char dayString[20];
char hourString[20];
char minuteString[20];
char secondString[20];
sprintf(dayString,
(days == 0 ? "" : (days == 1 ? "1 day," :
"%" PEGASUS_64BIT_CONVERSION_WIDTH "u days,")), days);
// for other values, want to display the 0s
sprintf(hourString, (hours == 1 ? "1 hr," : "%u hrs,"), hours);
sprintf(minuteString,
(minutes == 1 ? "1 min," : "%u mins,"), minutes);
sprintf(secondString,
(seconds == 1 ? "1 sec" : "%u secs"), seconds);
sprintf(uptime,
"%" PEGASUS_64BIT_CONVERSION_WIDTH "u seconds = %s %s %s %s",
totalSeconds,
dayString,
hourString,
minuteString,
secondString);
osSystemUpTime.assign(uptime);
} // end of if wanted nicely formatted vs. raw CIM
else
{
sprintf(uptime, "%" PEGASUS_64BIT_CONVERSION_WIDTH "u", total);
}
osSystemUpTime.assign(uptime);
} // end if SystemUpTime
} // end of for looping through properties
}
Boolean UNIX_BIOSString::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(), "AttributeName"))
{
String attributeNameValue;
property.getValue().get(attributeNameValue);
setAttributeName(attributeNameValue);
}
else if (String::equal(property.getName().getString(), "CurrentValue"))
{
Array<String> currentValueValue;
property.getValue().get(currentValueValue);
setCurrentValue(currentValueValue);
}
else if (String::equal(property.getName().getString(), "DefaultValue"))
{
Array<String> defaultValueValue;
property.getValue().get(defaultValueValue);
setDefaultValue(defaultValueValue);
}
else if (String::equal(property.getName().getString(), "PendingValue"))
{
Array<String> pendingValueValue;
property.getValue().get(pendingValueValue);
setPendingValue(pendingValueValue);
}
else if (String::equal(property.getName().getString(), "IsOrderedList"))
{
Boolean isOrderedListValue;
property.getValue().get(isOrderedListValue);
setIsOrderedList(isOrderedListValue);
}
else if (String::equal(property.getName().getString(), "IsReadOnly"))
{
Boolean isReadOnlyValue;
property.getValue().get(isReadOnlyValue);
setIsReadOnly(isReadOnlyValue);
}
else if (String::equal(property.getName().getString(), "StringType"))
{
Uint32 stringTypeValue;
property.getValue().get(stringTypeValue);
setStringType(stringTypeValue);
}
else if (String::equal(property.getName().getString(), "MinLength"))
{
Uint64 minLengthValue;
property.getValue().get(minLengthValue);
setMinLength(minLengthValue);
}
else if (String::equal(property.getName().getString(), "MaxLength"))
{
Uint64 maxLengthValue;
property.getValue().get(maxLengthValue);
setMaxLength(maxLengthValue);
}
else if (String::equal(property.getName().getString(), "ValueExpression"))
{
String valueExpressionValue;
property.getValue().get(valueExpressionValue);
setValueExpression(valueExpressionValue);
}
}
return true;
}
Boolean _applyProjection(QueryExpression& qe,
Array<CIMInstance>& _instances,
String testOption,
String lang)
{
if(testOption == String::EMPTY || testOption == "2")
{
cout << endl << lang << " ========Apply Projection Results========" << endl;
cout << qe.getQuery() << endl;
for(Uint32 j = 0; j < _instances.size(); j++)
{
cout << "Instance of class " << _instances[j].getClassName().getString() << endl;
try
{
CIMInstance projInst = _instances[j].clone();
Boolean gotPropExc = false;
try
{
qe.applyProjection(projInst, false);
}
catch (QueryRuntimePropertyException & qrpe)
{
// Got a missing property exception.
cout << "-----" << qrpe.getMessage() << endl;
gotPropExc = true;
}
if (gotPropExc)
{
// Got a missing property exception.
// Try again, allowing missing properties.
// Need to use a cloned instance because the original instance
// was partially projected.
cout << "Instance of class " << _instances[j].getClassName().getString()
<< ". Allow missing properties." << endl;
projInst = _instances[j].clone();
qe.applyProjection(projInst, true);
}
Uint32 cnt = projInst.getPropertyCount();
if (cnt == 0)
{
cout << "-----No properties left after projection" << endl;
}
if (cnt > 10)
{
// If more than 10 props, just print the count to keep
// the output file short
cout << "Instance has " << cnt << " properties" << endl;
}
else
{
for (Uint32 n = 0; n < cnt; n++)
{
CIMProperty prop = projInst.getProperty(n);
CIMValue val = prop.getValue();
cout << "-----Prop #" << n << " Name = " << prop.getName().getString();
if (val.isNull())
{
cout << " Value = NULL" << endl;
}
else
{
cout << " Value = " << val.toString() << endl;
}
}
}
}
catch(Exception& e) {
cout << "-----" << e.getMessage() << endl;
}
catch(...) {
cout << "Unknown Exception" << endl;
}
}
}
return true;
}
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 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);
}
}
