// automatically generated. Do not modify
static void testHostMetricss(xen_session *session) {
printf("\nGet all the HostMetrics Records\n");
xen_host_metrics_set *host_metrics_set;
bool d = xen_host_metrics_get_all(session, &host_metrics_set);
if (d) {
size_t i = 0;
for (; i < host_metrics_set->size; ++i) {
xen_host_metrics_record *host_metrics_record;
xen_host_metrics_get_record(session, &host_metrics_record,
host_metrics_set->contents[i]);
char *handle = (char*) host_metrics_record->handle;
char *opaque = (char*) host_metrics_set->contents[i];
if (strcmp(handle, opaque) == 0)
printf("identical: %s\n", opaque);
else
printf("record->handle[%s] v.s. set->contents[%d][%s]\n",
opaque, i, handle);
xen_host_metrics_record_free(host_metrics_record);
}
} else {
print_error(session);
}
xen_host_metrics_set_free(host_metrics_set);
printf("\n==============================================\n\n");
}
static CMPIrc memorypool_set_properties(
provider_resource *resource,
CMPIInstance *inst
)
{
local_host_resource *ctx = resource->ctx;
char buf[MAX_INSTANCEID_LEN];
int prop_val_32;
xen_host_metrics_record *host_metrics_rec = NULL;
if (ctx->host_rec->metrics->is_record)
host_metrics_rec = ctx->host_rec->metrics->u.record;
else
xen_host_metrics_get_record(resource->session->xen, &host_metrics_rec, ctx->host_rec->metrics->u.handle);
_CMPICreateNewDeviceInstanceID(buf, MAX_INSTANCEID_LEN, ctx->host_rec->uuid, "MemoryPool");
CMSetProperty(inst, "InstanceID", (CMPIValue *)buf, CMPI_chars);
CMSetProperty(inst, "PoolID", (CMPIValue *)ctx->host_rec->uuid, CMPI_chars);
int type = DMTF_ResourceType_Memory;
CMSetProperty(inst, "ResourceType", (CMPIValue *)&type, CMPI_uint16);
CMSetProperty(inst, "ResourceSubType", (CMPIValue *) "Xen Memory", CMPI_chars);
CMSetProperty(inst, "AllocationUnits", (CMPIValue *)"Bytes", CMPI_chars);
CMSetProperty(inst, "Capacity",(CMPIValue *)&(host_metrics_rec->memory_total), CMPI_uint64);
CMSetProperty(inst, "Caption", (CMPIValue *)"Xen Virtual Memory Pool", CMPI_chars);
CMSetProperty(inst, "Description", (CMPIValue *)"Xen Virtual Memory Pool", CMPI_chars);
CMSetProperty(inst, "ElementName", (CMPIValue *)ctx->host_rec->name_label, CMPI_chars);
prop_val_32 = DMTF_HealthState_OK;
CMSetProperty(inst, "HealthState", (CMPIValue *)&prop_val_32, CMPI_uint16);
//CMSetProperty(inst, "InstallDate", (CMPIValue *)installDate, CMPI_dateTime);
CMSetProperty(inst, "Name", (CMPIValue *)"Xen Virtual Memory Pool", CMPI_chars);
prop_val_32 = DMTF_OperationalStatus_OK;
CMPIArray *arr = CMNewArray(resource->broker, 1, CMPI_uint16, NULL);
CMSetArrayElementAt(arr, 0, (CMPIValue *)&prop_val_32, CMPI_uint16);
CMSetProperty(inst, "OperationalStatus", (CMPIValue *) &arr, CMPI_uint16A);
//CMSetProperty(inst, "OtherResourceType", (CMPIValue *)other_resource_type, CMPI_String);
prop_val_32 = 1;
CMSetProperty(inst, "Primordial" , (CMPIValue *)&prop_val_32, CMPI_boolean);
//CMSetProperty(inst, "Status", (CMPIValue *)status, CMPI_chars);
// CMSetProperty(inst, "StatusDescriptions", (CMPIValue *)status_descs, CMPI_chars);
int64_t reserved = host_metrics_rec->memory_total - host_metrics_rec->memory_free;
CMSetProperty(inst, "Reserved", (CMPIValue *)&reserved, CMPI_uint64);
// CMSetProperty(inst, "Unreservable", (CMPIValue *)unreservable, CMPI_uint16);
if (!ctx->host_rec->metrics->is_record)
xen_host_metrics_record_free(host_metrics_rec);
return CMPI_RC_OK;
}
static CMPIrc hostmemory_set_properties(
provider_resource *resource,
CMPIInstance *inst
)
{
char buf[MAX_INSTANCEID_LEN];
local_host_resource *ctx = resource->ctx;
_CMPICreateNewDeviceInstanceID(buf, sizeof(buf), ctx->host_rec->uuid, "Memory");
CMSetProperty(inst, "DeviceID",(CMPIValue *)buf, CMPI_chars);
CMSetProperty(inst, "CreationClassName",(CMPIValue *)"Xen_HostMemory", CMPI_chars);
CMSetProperty(inst, "SystemCreationClassName",(CMPIValue *)"Xen_HostComputerSystem", CMPI_chars);
CMSetProperty(inst, "SystemName",(CMPIValue *)ctx->host_rec->uuid, CMPI_chars);
xen_host_metrics_record *metrics_rec = NULL;
if (ctx->host_rec->metrics->is_record)
metrics_rec = ctx->host_rec->metrics->u.record;
else
xen_host_metrics_get_record(resource->session->xen, &metrics_rec, ctx->host_rec->metrics->u.handle);
/* Populate the instance's properties with the backend data */
//CMSetProperty(inst, "Access",(CMPIValue *)&<value>, CMPI_uint16);
//CMPIArray *arr = CMNewArray(_BROKER, 1, CMPI_uint16, NULL);
//CMSetArrayElementAt(arr, 0, (CMPIValue *)&<value>, CMPI_uint16);
//CMSetProperty(inst, "AdditionalAvailability",(CMPIValue *)&arr, CMPI_uint16A);
//CMPIArray *arr = CMNewArray(_BROKER, 1, CMPI_uint8, NULL);
//CMSetArrayElementAt(arr, 0, (CMPIValue *)&<value>, CMPI_uint8);
//CMSetProperty(inst, "AdditionalErrorData",(CMPIValue *)&arr, CMPI_uint8A);
//CMSetProperty(inst, "Availability",(CMPIValue *)&<value>, CMPI_uint16);
uint64_t blockSize = 1;
CMSetProperty(inst, "BlockSize",(CMPIValue *)&blockSize, CMPI_uint64);
CMSetProperty(inst, "Caption",(CMPIValue *)"Xen Host Memory", CMPI_chars);
CMSetProperty(inst, "ConsumableBlocks",(CMPIValue *)&metrics_rec->memory_free, CMPI_uint64);
//CMSetProperty(inst, "CorrectableError",(CMPIValue *)&<value>, CMPI_boolean);
//CMSetProperty(inst, "DataOrganization",(CMPIValue *)&<value>, CMPI_uint16);
//CMSetProperty(inst, "DataRedundancy",(CMPIValue *)&<value>, CMPI_uint16);
//CMSetProperty(inst, "DeltaReservation",(CMPIValue *)&<value>, CMPI_uint8);
CMSetProperty(inst, "Description",(CMPIValue *)ctx->host_rec->name_description, CMPI_chars);
CMSetProperty(inst, "ElementName",(CMPIValue *)ctx->host_rec->name_label, CMPI_chars);
//CMSetProperty(inst, "EnabledDefault",(CMPIValue *)&<value>, CMPI_uint16);
//CMSetProperty(inst, "EnabledState",(CMPIValue *)&<value>, CMPI_uint16);
CMSetProperty(inst, "EndingAddress",(CMPIValue *)&metrics_rec->memory_total, CMPI_uint64);
//CMSetProperty(inst, "ErrorAccess",(CMPIValue *)&<value>, CMPI_uint16);
//CMSetProperty(inst, "ErrorAddress",(CMPIValue *)&<value>, CMPI_uint64);
//CMSetProperty(inst, "ErrorCleared",(CMPIValue *)&<value>, CMPI_boolean);
//CMPIArray *arr = CMNewArray(_BROKER, 1, CMPI_uint8, NULL);
//CMSetArrayElementAt(arr, 0, (CMPIValue *)&<value>, CMPI_uint8);
//CMSetProperty(inst, "ErrorData",(CMPIValue *)&arr, CMPI_uint8A);
//CMSetProperty(inst, "ErrorDataOrder",(CMPIValue *)&<value>, CMPI_uint16);
//CMSetProperty(inst, "ErrorDescription",(CMPIValue *)<value>, CMPI_chars);
//CMSetProperty(inst, "ErrorInfo",(CMPIValue *)&<value>, CMPI_uint16);
//CMSetProperty(inst, "ErrorMethodology",(CMPIValue *)<value>, CMPI_chars);
//CMSetProperty(inst, "ErrorResolution",(CMPIValue *)&<value>, CMPI_uint64);
//CMPIDateTime *date_time = xen_utils_time_t_to_CMPIDateTime(_BROKER, <time_value>);
//CMSetProperty(inst, "ErrorTime",(CMPIValue *)&date_time, CMPI_dateTime);
//CMSetProperty(inst, "ErrorTransferSize",(CMPIValue *)&<value>, CMPI_uint32);
//CMPIArray *arr = CMNewArray(_BROKER, 1, CMPI_uint16, NULL);
//CMSetArrayElementAt(arr, 0, (CMPIValue *)&<value>, CMPI_uint16);
//CMSetProperty(inst, "ExtentStatus",(CMPIValue *)&arr, CMPI_uint16A);
//CMSetProperty(inst, "HealthState",(CMPIValue *)&<value>, CMPI_uint16);
//CMPIArray *arr = CMNewArray(_BROKER, 1, CMPI_chars, NULL);
//CMSetArrayElementAt(arr, 0, (CMPIValue *)<value>, CMPI_chars);
//CMSetProperty(inst, "IdentifyingDescriptions",(CMPIValue *)&arr, CMPI_charsA);
//CMPIDateTime *date_time = xen_utils_time_t_to_CMPIDateTime(_BROKER, <time_value>);
//CMSetProperty(inst, "InstallDate",(CMPIValue *)&date_time, CMPI_dateTime);
//CMSetProperty(inst, "IsBasedOnUnderlyingRedundancy",(CMPIValue *)&<value>, CMPI_boolean);
//CMSetProperty(inst, "LastErrorCode",(CMPIValue *)&<value>, CMPI_uint32);
//CMSetProperty(inst, "MaxQuiesceTime",(CMPIValue *)&<value>, CMPI_uint64);
//CMSetProperty(inst, "Name",(CMPIValue *)<value>, CMPI_chars);
//CMSetProperty(inst, "NameFormat",(CMPIValue *)&<value>, CMPI_uint16);
//CMSetProperty(inst, "NameNamespace",(CMPIValue *)&<value>, CMPI_uint16);
//CMSetProperty(inst, "NoSinglePointOfFailure",(CMPIValue *)&<value>, CMPI_boolean);
CMSetProperty(inst, "NumberOfBlocks",(CMPIValue *)&metrics_rec->memory_total, CMPI_uint64);
//CMPIArray *arr = CMNewArray(_BROKER, 1, CMPI_uint16, NULL);
//CMSetArrayElementAt(arr, 0, (CMPIValue *)&<value>, CMPI_uint16);
//CMSetProperty(inst, "OperationalStatus",(CMPIValue *)&arr, CMPI_uint16A);
//CMSetProperty(inst, "OtherEnabledState",(CMPIValue *)<value>, CMPI_chars);
//CMSetProperty(inst, "OtherErrorDescription",(CMPIValue *)<value>, CMPI_chars);
//CMPIArray *arr = CMNewArray(_BROKER, 1, CMPI_chars, NULL);
//CMSetArrayElementAt(arr, 0, (CMPIValue *)<value>, CMPI_chars);
//CMSetProperty(inst, "OtherIdentifyingInfo",(CMPIValue *)&arr, CMPI_charsA);
//CMSetProperty(inst, "OtherNameFormat",(CMPIValue *)<value>, CMPI_chars);
//CMSetProperty(inst, "OtherNameNamespace",(CMPIValue *)<value>, CMPI_chars);
//CMSetProperty(inst, "PackageRedundancy",(CMPIValue *)&<value>, CMPI_uint16);
//CMPIArray *arr = CMNewArray(_BROKER, 1, CMPI_uint16, NULL);
//CMSetArrayElementAt(arr, 0, (CMPIValue *)&<value>, CMPI_uint16);
//CMSetProperty(inst, "PowerManagementCapabilities",(CMPIValue *)&arr, CMPI_uint16A);
//CMSetProperty(inst, "PowerManagementSupported",(CMPIValue *)&<value>, CMPI_boolean);
//CMSetProperty(inst, "PowerOnHours",(CMPIValue *)&<value>, CMPI_uint64);
bool primordial = true;
CMSetProperty(inst, "Primordial",(CMPIValue *)&primordial, CMPI_boolean);
//CMSetProperty(inst, "Purpose",(CMPIValue *)<value>, CMPI_chars);
//CMSetProperty(inst, "RequestedState",(CMPIValue *)&<value>, CMPI_uint16);
//CMSetProperty(inst, "SequentialAccess",(CMPIValue *)&<value>, CMPI_boolean);
uint64_t startingAddress = 0;
CMSetProperty(inst, "StartingAddress",(CMPIValue *)&startingAddress, CMPI_uint64);
CMSetProperty(inst, "Status",(CMPIValue *)DMTF_Status_OK, CMPI_chars);
//CMPIArray *arr = CMNewArray(_BROKER, 1, CMPI_chars, NULL);
//CMSetArrayElementAt(arr, 0, (CMPIValue *)<value>, CMPI_chars);
//CMSetProperty(inst, "StatusDescriptions",(CMPIValue *)&arr, CMPI_charsA);
//CMSetProperty(inst, "StatusInfo",(CMPIValue *)&<value>, CMPI_uint16);
//CMSetProperty(inst, "SystemLevelAddress",(CMPIValue *)&<value>, CMPI_boolean);
//CMPIDateTime *date_time = xen_utils_time_t_to_CMPIDateTime(_BROKER, <time_value>);
//CMSetProperty(inst, "TimeOfLastStateChange",(CMPIValue *)&date_time, CMPI_dateTime);
//CMSetProperty(inst, "TotalPowerOnHours",(CMPIValue *)&<value>, CMPI_uint64);
//CMSetProperty(inst, "Volatile",(CMPIValue *)&<value>, CMPI_boolean);
if (!ctx->host_rec->metrics->is_record)
xen_host_metrics_record_free(metrics_rec);
return CMPI_RC_OK;
}
static CMPIrc host_set_properties(
provider_resource *resource,
CMPIInstance *inst
)
{
local_host_resource *ctx = (local_host_resource *)resource->ctx;
/* Key properties to be filled in */
CMSetProperty(inst, "Name",(CMPIValue *)ctx->host_rec->uuid, CMPI_chars);
CMSetProperty(inst, "CreationClassName",(CMPIValue *)"Xen_HostComputerSystem", CMPI_chars);
xen_host_metrics metrics = NULL;
xen_host_get_metrics(resource->session->xen, &metrics, ctx->host);
xen_host_metrics_record *metrics_rec = NULL;
if (metrics) {
xen_host_metrics_get_record(resource->session->xen, &metrics_rec, metrics);
xen_host_metrics_free(metrics);
}
/* Populate the instance's properties with the backend data */
_set_allowed_operations(resource->broker, ctx->host_rec, inst, "AvailableRequestedStates");
/* Check other-config (as a cache) */
char *CN = NULL;
CN = xen_utils_get_from_string_string_map(ctx->host_rec->other_config, "host_cn");
/* Did not find the CN in the cache, call out to plugin */
if (CN) {
_SBLIM_TRACE(_SBLIM_TRACE_LEVEL_DEBUG,("CN back from other_config = %s for host %s", CN, ctx->host));
CMSetProperty(inst, "CN", (CMPIValue *)CN, CMPI_chars);
} else {
/* Get CN name by calling a plugin on the Host */
//char *CN = NULL;
xen_string_string_map *args = xen_string_string_map_alloc(0);
xen_host_call_plugin(resource->session->xen, &CN, ctx->host, "xscim", "read_host_cn", args);
xen_string_string_map_free(args);
_SBLIM_TRACE(_SBLIM_TRACE_LEVEL_DEBUG,("CN name back from plugin = %s for host %s", CN, ctx->host));
/* Update the other_config cache */
xen_host_add_to_other_config(resource->session->xen, ctx->host, "host_cn", CN);
CMSetProperty(inst, "CN", (CMPIValue *)CN, CMPI_chars);
// Only need to free CN here because we have made the plugin call.
// If we've taken the value from the cache it will be free'd when
// ctx->host_rec is free'd.
if (CN)
free(CN);
}
CMSetProperty(inst, "Caption",(CMPIValue *)"XenServer Host", CMPI_chars);
DMTF_Dedicated dedicated = DMTF_Dedicated_Other;
CMPIArray *arr = CMNewArray(resource->broker, 1, CMPI_uint16, NULL);
CMSetArrayElementAt(arr, 0, (CMPIValue *)&dedicated, CMPI_uint16);
CMSetProperty(inst, "Dedicated",(CMPIValue *)&arr, CMPI_uint16A);
CMSetProperty(inst, "Description",(CMPIValue *)ctx->host_rec->name_description, CMPI_chars);
CMSetProperty(inst, "ElementName",(CMPIValue *)ctx->host_rec->name_label, CMPI_chars);
DMTF_EnabledDefault eDefault = DMTF_EnabledDefault_Enabled;
CMSetProperty(inst, "EnabledDefault",(CMPIValue *)&eDefault, CMPI_uint16);
DMTF_EnabledState eState = DMTF_EnabledState_Enabled;
if (!ctx->host_rec->enabled)
eState = DMTF_EnabledState_Enabled_but_Offline;
CMSetProperty(inst, "EnabledState",(CMPIValue *)&eState, CMPI_uint16);
DMTF_HealthState hState = DMTF_HealthState_OK;
CMSetProperty(inst, "HealthState",(CMPIValue *)&hState, CMPI_uint16);
//CMPIDateTime *date_time = xen_utils_time_t_to_CMPIDateTime(resource->broker, <time_value>);
//CMSetProperty(inst, "InstallDate",(CMPIValue *)&date_time, CMPI_dateTime);
CMSetProperty(inst, "NameFormat",(CMPIValue *)DMTF_NameFormat_Other, CMPI_chars);
DMTF_OperationalStatus opStatus = DMTF_OperationalStatus_OK;
if (!ctx->host_rec->enabled)
opStatus = DMTF_OperationalStatus_Stopped;
CMPIArray *opStatusArr = CMNewArray(resource->broker, 1, CMPI_uint16, NULL);
CMSetArrayElementAt(opStatusArr, 0, (CMPIValue *)&opStatus, CMPI_uint16);
CMSetProperty(inst, "OperationalStatus",(CMPIValue *)&opStatusArr, CMPI_uint16A);
//CMPIArray *arr = CMNewArray(resource->broker, 1, CMPI_chars, NULL);
//CMSetArrayElementAt(arr, 0, (CMPIValue *)<value>, CMPI_chars);
//CMSetProperty(inst, "OtherDedicatedDescriptions",(CMPIValue *)&arr, CMPI_charsA);
//CMSetProperty(inst, "OtherEnabledState",(CMPIValue *)<value>, CMPI_chars);
arr = xen_utils_convert_string_string_map_to_CMPIArray(resource->broker, ctx->host_rec->other_config);
if(arr)
CMSetProperty(inst, "OtherConfig",(CMPIValue *)&arr, CMPI_stringA);
CMPIArray *otheridinfo = CMNewArray(resource->broker, 4, CMPI_chars, NULL);
char* brand = xen_utils_get_from_string_string_map(ctx->host_rec->software_version, "product_brand");
char* version = xen_utils_get_from_string_string_map(ctx->host_rec->software_version, "product_version");
char* build = xen_utils_get_from_string_string_map(ctx->host_rec->software_version, "build_number");
CMSetArrayElementAt(otheridinfo, 0, (CMPIValue *)ctx->host_rec->address, CMPI_chars);
CMSetArrayElementAt(otheridinfo, 1, (CMPIValue *)brand, CMPI_chars);
CMSetArrayElementAt(otheridinfo, 2, (CMPIValue *)version, CMPI_chars);
CMSetArrayElementAt(otheridinfo, 3, (CMPIValue *)build, CMPI_chars);
CMSetProperty(inst, "OtherIdentifyingInfo",(CMPIValue *)&otheridinfo, CMPI_charsA);
CMPIArray *iddesc = CMNewArray(resource->broker, 4, CMPI_chars, NULL);
CMSetArrayElementAt(iddesc, 0, (CMPIValue *)"IPv4Address", CMPI_chars);
CMSetArrayElementAt(iddesc, 1, (CMPIValue *)"ProductBrand", CMPI_chars);
CMSetArrayElementAt(iddesc, 2, (CMPIValue *)"ProductVersion", CMPI_chars);
CMSetArrayElementAt(iddesc, 3, (CMPIValue *)"BuildNumber", CMPI_chars);
CMSetProperty(inst, "IdentifyingDescriptions",(CMPIValue *)&iddesc, CMPI_charsA);
//CMPIArray *arr = CMNewArray(resource->broker, 1, CMPI_uint16, NULL);
//CMSetArrayElementAt(arr, 0, (CMPIValue *)&<value>, CMPI_uint16);
//CMSetProperty(inst, "PowerManagementCapabilities",(CMPIValue *)&arr, CMPI_uint16A);
char *owner = xen_utils_get_from_string_string_map(ctx->host_rec->other_config, "owner");
char *ownercontact = xen_utils_get_from_string_string_map(ctx->host_rec->other_config, "ownercontact");
if (owner)
CMSetProperty(inst, "PrimaryOwnerName",(CMPIValue *)owner, CMPI_chars);
if (ownercontact)
CMSetProperty(inst, "PrimaryOwnerContact",(CMPIValue *)ownercontact, CMPI_chars);
DMTF_RequestedState rState = DMTF_RequestedState_Enabled;
CMSetProperty(inst, "RequestedState",(CMPIValue *)&rState, CMPI_uint16);
//CMSetProperty(inst, "ResetCapability",(CMPIValue *)&<value>, CMPI_uint16);
char *serverrole = xen_utils_get_from_string_string_map(ctx->host_rec->other_config, "role");
if (serverrole) {
CMPIArray *rolesarr = CMNewArray(resource->broker, 1, CMPI_chars, NULL);
CMSetArrayElementAt(rolesarr, 0, (CMPIValue *)serverrole, CMPI_chars);
CMSetProperty(inst, "Roles",(CMPIValue *)&rolesarr, CMPI_charsA);
}
if (ctx->host_rec->other_config) {
char *val = xen_utils_get_from_string_string_map(ctx->host_rec->other_config, "boot_time");
if (val) {
time_t time = atol(val);
CMPIDateTime *start_time = xen_utils_time_t_to_CMPIDateTime(resource->broker, time);
if (start_time) CMSetProperty(inst, "StartTime",(CMPIValue *)&start_time, CMPI_dateTime);
}
}
CMSetProperty(inst, "Status",(CMPIValue *)DMTF_Status_OK, CMPI_chars);
//CMPIArray *arr = CMNewArray(resource->broker, 1, CMPI_chars, NULL);
//CMSetArrayElementAt(arr, 0, (CMPIValue *)<value>, CMPI_chars);
//CMSetProperty(inst, "StatusDescriptions",(CMPIValue *)&arr, CMPI_charsA);
if (metrics_rec && (metrics_rec->last_updated != 0)) {
CMPIDateTime *install_time = xen_utils_time_t_to_CMPIDateTime(resource->broker, metrics_rec->last_updated);
CMSetProperty(inst, "TimeOfLastStateChange",(CMPIValue *)&install_time, CMPI_dateTime);
}
/* properties to indicate hosts's time zone. We compute local time zone on this
host and assume all hosts are in the same zone since xapi doest report the time zone at this time */
time_t now = time(NULL);
struct tm tmnow;
localtime_r(&now, &tmnow);
CMSetProperty(inst, "TimeOffset", (CMPIValue *)&tmnow.tm_gmtoff, CMPI_sint32);
if (metrics_rec)
xen_host_metrics_record_free(metrics_rec);
return CMPI_RC_OK;
}
