void
xen_host_record_free(xen_host_record *record)
{
if (record == NULL)
{
return;
}
free(record->handle);
free(record->uuid);
free(record->name_label);
free(record->name_description);
free(record->api_version_vendor);
xen_string_string_map_free(record->api_version_vendor_implementation);
xen_string_string_map_free(record->software_version);
xen_string_string_map_free(record->other_config);
xen_string_set_free(record->capabilities);
xen_string_string_map_free(record->cpu_configuration);
free(record->sched_policy);
xen_string_set_free(record->supported_bootloaders);
xen_vm_record_opt_set_free(record->resident_vms);
xen_string_string_map_free(record->logging);
xen_pif_record_opt_set_free(record->pifs);
xen_sr_record_opt_free(record->suspend_image_sr);
xen_sr_record_opt_free(record->crash_dump_sr);
xen_pbd_record_opt_set_free(record->pbds);
xen_host_cpu_record_opt_set_free(record->host_cpus);
xen_host_metrics_record_opt_free(record->metrics);
xen_cpu_pool_record_opt_set_free(record->resident_cpu_pools);
free(record);
}
void
xen_vif_record_free(xen_vif_record *record)
{
if (record == NULL)
{
return;
}
free(record->handle);
free(record->uuid);
xen_vif_operations_set_free(record->allowed_operations);
xen_string_vif_operations_map_free(record->current_operations);
free(record->device);
xen_network_record_opt_free(record->network);
xen_vm_record_opt_free(record->vm);
free(record->mac);
xen_string_string_map_free(record->other_config);
free(record->status_detail);
xen_string_string_map_free(record->runtime_properties);
free(record->qos_algorithm_type);
xen_string_string_map_free(record->qos_algorithm_params);
xen_string_set_free(record->qos_supported_algorithms);
xen_vif_metrics_record_opt_free(record->metrics);
xen_string_set_free(record->ipv4_allowed);
xen_string_set_free(record->ipv6_allowed);
free(record);
}
void
xen_pbd_record_free(xen_pbd_record *record)
{
if (record == NULL)
{
return;
}
free(record->handle);
free(record->uuid);
xen_host_record_opt_free(record->host);
xen_sr_record_opt_free(record->sr);
xen_string_string_map_free(record->device_config);
xen_string_string_map_free(record->other_config);
free(record);
}
void
xen_bond_record_free(xen_bond_record *record)
{
if (record == NULL)
{
return;
}
free(record->handle);
free(record->uuid);
xen_pif_record_opt_free(record->master);
xen_pif_record_opt_set_free(record->slaves);
xen_string_string_map_free(record->other_config);
xen_pif_record_opt_free(record->primary_slave);
xen_string_string_map_free(record->properties);
free(record);
}
void
xen_host_metrics_record_free(xen_host_metrics_record *record)
{
if (record == NULL)
{
return;
}
free(record->handle);
free(record->uuid);
xen_string_string_map_free(record->other_config);
free(record);
}
void
xen_secret_record_free(xen_secret_record *record)
{
if (record == NULL)
{
return;
}
free(record->handle);
free(record->uuid);
free(record->value);
xen_string_string_map_free(record->other_config);
free(record);
}
void
xen_subject_record_free(xen_subject_record *record)
{
if (record == NULL)
{
return;
}
free(record->handle);
free(record->uuid);
free(record->subject_identifier);
xen_string_string_map_free(record->other_config);
xen_role_record_opt_set_free(record->roles);
free(record);
}
void
xen_vgpu_record_free(xen_vgpu_record *record)
{
if (record == NULL)
{
return;
}
free(record->handle);
free(record->uuid);
xen_vm_record_opt_free(record->vm);
xen_gpu_group_record_opt_free(record->gpu_group);
free(record->device);
xen_string_string_map_free(record->other_config);
free(record);
}
void
xen_network_record_free(xen_network_record *record)
{
if (record == NULL)
{
return;
}
free(record->handle);
free(record->uuid);
free(record->name_label);
free(record->name_description);
xen_vif_record_opt_set_free(record->vifs);
xen_pif_record_opt_set_free(record->pifs);
xen_string_string_map_free(record->other_config);
free(record);
}
/* allocate a flexible array and fill values(key,val) */
int
allocStringMap(xen_string_string_map **strings, char *key, char *val)
{
int sz = ((*strings) == NULL) ? 0 : (*strings)->size;
sz++;
if (VIR_REALLOC_N(*strings, sizeof(xen_string_string_map) +
sizeof(xen_string_string_map_contents) * sz) < 0)
return -1;
(*strings)->size = sz;
if (VIR_STRDUP((*strings)->contents[sz-1].key, key) < 0 ||
VIR_STRDUP((*strings)->contents[sz-1].val, val) < 0)
goto error;
return 0;
error:
xen_string_string_map_free(*strings);
return -1;
}
void
xen_string_string_string_map_map_free(xen_string_string_string_map_map *map)
{
if (map == NULL)
{
return;
}
size_t n = map->size;
for (size_t i = 0; i < n; i++)
{
free(map->contents[i].key);
xen_string_string_map_free(map->contents[i].val);
}
free(map);
}
void
xen_vdi_record_free(xen_vdi_record *record)
{
if (record == NULL)
{
return;
}
free(record->handle);
free(record->uuid);
free(record->name_label);
free(record->name_description);
xen_sr_record_opt_free(record->sr);
xen_vbd_record_opt_set_free(record->vbds);
xen_crashdump_record_opt_set_free(record->crash_dumps);
xen_string_string_map_free(record->other_config);
free(record);
}
/* allocate a flexible array and fill values(key,val) */
int
allocStringMap (xen_string_string_map **strings, char *key, char *val)
{
int sz = ((*strings) == NULL) ? 0 : (*strings)->size;
sz++;
if (VIR_REALLOC_N(*strings, sizeof(xen_string_string_map) +
sizeof(xen_string_string_map_contents) * sz) < 0) {
virReportOOMError();
return -1;
}
(*strings)->size = sz;
if (!((*strings)->contents[sz-1].key = strdup(key))) goto error;
if (!((*strings)->contents[sz-1].val = strdup(val))) goto error;
return 0;
error:
xen_string_string_map_free(*strings);
virReportOOMError();
return -1;
}
void
xen_task_record_free(xen_task_record *record)
{
if (record == NULL)
{
return;
}
free(record->handle);
free(record->uuid);
free(record->name_label);
free(record->name_description);
xen_task_allowed_operations_set_free(record->allowed_operations);
xen_string_task_allowed_operations_map_free(record->current_operations);
xen_host_record_opt_free(record->resident_on);
free(record->type);
free(record->result);
xen_string_set_free(record->error_info);
xen_string_string_map_free(record->other_config);
xen_task_record_opt_free(record->subtask_of);
xen_task_record_opt_set_free(record->subtasks);
free(record);
}
void
xen_vm_guest_metrics_record_free(xen_vm_guest_metrics_record *record)
{
if (record == NULL)
{
return;
}
free(record->handle);
free(record->uuid);
xen_string_string_map_free(record->os_version);
xen_string_string_map_free(record->pv_drivers_version);
xen_string_string_map_free(record->memory);
xen_string_string_map_free(record->disks);
xen_string_string_map_free(record->networks);
xen_string_string_map_free(record->other);
free(record);
}
/**
* Creation of a new VM by cloning from an existing template (looked up by name)
*/
static xen_vm create_new_vm(xen_session *session, char* template_name, char* sr_name, bool PV)
{
/*
* Lookup template by name
*/
xen_vm_set *vms;
if (!xen_vm_get_by_name_label(session, &vms, template_name) ||
vms->size < 1)
{
fprintf(stderr, "VM lookup failed.\n");
print_error(session);
return NULL;
}
/*
* Create VM by cloning from template
*/
xen_vm vm;
char *name_before = "NewVM <&>"; //using xml sensitive characters
int name_length = 9;
xen_vm_clone(session, &vm, vms->contents[0], name_before);
char *name_after;
xen_vm_get_name_label(session, &name_after, vm);
int result = strncmp(name_before, name_after, name_length);
if (result != 0){
fprintf(stderr, "Error: The VM name failed to be encoded/decoded correctly\n");
fprintf(stderr, "Before:%s\nAfter:%s\n", name_before, name_after);
return NULL;
}
xen_vm_set_free(vms);
if (!session->ok) {
fprintf(stderr, "VM clone failed.\n");
print_error(session);
return NULL;
}
if (PV) {
xen_string_string_map *other_config;
if (!xen_vm_get_other_config(session, &other_config, vm)) {
fprintf(stderr, "VM get other_config failed.\n");
print_error(session);
return NULL;
}
char *disks = NULL;
for (size_t i=0; i < other_config->size; i++) {
printf("%s -> %s.\n", other_config->contents[i].key,
other_config->contents[i].val);
if (strcmp(other_config->contents[i].key, "disks") == 0) {
disks = other_config->contents[i].val;
break;
}
}
if (disks == NULL) {
fprintf(stderr, "Did not find provision XML in other_config.\n");
xen_string_string_map_free(other_config);
return NULL;
}
xen_sr_set *srs;
if (!xen_sr_get_by_name_label(session, &srs, sr_name) ||
srs->size < 1) {
fprintf(stderr, "SR lookup failed.\n");
print_error(session);
xen_vm_free(vm);
return NULL;
}
xen_sr sr = srs->contents[0];
char *sr_uuid;
if(!xen_sr_get_uuid(session, &sr_uuid, sr)){
//TODO free...?
return NULL;
}
char *new_str;
if(asprintf(&new_str, "sr=\"%s\"", sr_uuid) < 0) {
return NULL;
}
char *new_disks = replace_str(disks, "sr=\"\"", new_str);
free(new_str);
xen_string_string_map_free(other_config);
if (new_disks == NULL) {
fprintf(stderr, "Error replacing SR in provision XML.\n");
return NULL;
}
fprintf(stdout, "New provisions XML: %s\n", new_disks);
if (!xen_vm_remove_from_other_config(session, vm, "disks")) {
fprintf(stderr, "Error removing old value from other_config.\n");
print_error(session);
free(new_disks);
return NULL;
}
if (!xen_vm_add_to_other_config(session, vm, "disks", new_disks)) {
fprintf(stderr, "Error adding new value to other_config.\n");
print_error(session);
free(new_disks);
return NULL;
}
free(new_disks);
}
xen_vm_set_name_description(session, vm, "An example VM created via C bindings");
if (!session->ok)
{
fprintf(stderr, "Failed to set VM description.\n");
print_error(session);
return NULL;
}
xen_vm_provision(session, vm);
if (!session->ok)
{
fprintf(stderr, "Failed to provision VM.\n");
print_error(session);
return NULL;
}
if (PV)
return vm;
/*
* Create a new disk for the new VM.
*/
printf("Creating new (blank) disk image in 'Shared SR'\n");
xen_sr_set *srs;
if (!xen_sr_get_by_name_label(session, &srs, sr_name) ||
srs->size < 1)
{
fprintf(stderr, "SR lookup failed.\n");
print_error(session);
xen_vm_free(vm);
return NULL;
}
xen_sr_record_opt sr_record =
{
.u.handle = srs->contents[0]
};
xen_string_string_map* other_config = xen_string_string_map_alloc(0);
xen_vdi_record vdi0_record =
{
.name_label = "MyRootFS",
.name_description = "MyRootFS description",
.sr = &sr_record,
.virtual_size = (1024 * 1024 * 1024), /* 1 GiB in bytes */
.type = XEN_VDI_TYPE_SYSTEM,
.sharable = false,
.read_only = false,
.other_config = other_config
};
xen_vdi vdi0;
if (!xen_vdi_create(session, &vdi0, &vdi0_record))
{
fprintf(stderr, "VDI creation failed.\n");
print_error(session);
xen_sr_set_free(srs);
xen_vm_free(vm);
return NULL;
}
xen_vm_record_opt vm_record_opt =
{
.u.handle = vm
};
xen_vdi_record_opt vdi0_record_opt =
{
.u.handle = vdi0
};
xen_string_string_map* qos_algorithm_params = xen_string_string_map_alloc(0);
xen_string_string_map* vbd_other_config = xen_string_string_map_alloc(0);
enum xen_vbd_type vbd_type_disk = xen_vbd_type_from_string(session, "Disk");
printf("Attaching disk image to newly created VM\n");
xen_vbd_record vbd0_record =
{
.vm = &vm_record_opt,
.vdi = &vdi0_record_opt,
.userdevice = "xvda",
.type = vbd_type_disk,
.mode = XEN_VBD_MODE_RW,
.bootable = 1,
.qos_algorithm_params = qos_algorithm_params,
.other_config = vbd_other_config
};
xen_vbd vbd0;
if (!xen_vbd_create(session, &vbd0, &vbd0_record))
{
fprintf(stderr, "VBD creation failed.\n");
print_error(session);
xen_vdi_free(vdi0);
xen_sr_set_free(srs);
xen_vm_free(vm);
return NULL;
}
char *vm_uuid;
char *vdi0_uuid;
char *vbd0_uuid;
xen_vm_get_uuid(session, &vm_uuid, vm);
xen_vdi_get_uuid(session, &vdi0_uuid, vdi0);
xen_vbd_get_uuid(session, &vbd0_uuid, vbd0);
if (!session->ok)
{
fprintf(stderr, "get_uuid call failed.\n");
print_error(session);
xen_uuid_free(vm_uuid);
xen_uuid_free(vdi0_uuid);
xen_uuid_free(vbd0_uuid);
xen_vbd_free(vbd0);
xen_vdi_free(vdi0);
xen_sr_set_free(srs);
xen_vm_free(vm);
return NULL;
}
fprintf(stderr,
"Created a new VM, with UUID %s, VDI UUID %s, VBD "
"UUID %s.\n",
vm_uuid, vdi0_uuid, vbd0_uuid);
xen_uuid_free(vm_uuid);
xen_uuid_free(vdi0_uuid);
xen_uuid_free(vbd0_uuid);
xen_vbd_free(vbd0);
xen_vdi_free(vdi0);
xen_sr_set_free(srs);
return vm;
}
/**
* Print the power state for the given VM.
*/
static void print_vm_power_state(xen_session *session, xen_vm vm)
{
char *vm_uuid;
enum xen_vm_power_state power_state;
if (!xen_vm_get_uuid(session, &vm_uuid, vm))
{
print_error(session);
return;
}
if (!xen_vm_get_power_state(session, &power_state, vm))
{
xen_uuid_free(vm_uuid);
print_error(session);
return;
}
printf("VM %s power state is %s.\n", vm_uuid,
xen_vm_power_state_to_string(power_state));
xen_uuid_free(vm_uuid);
}
/*
* Replace all occurrences of orig in str with rep
*
* @returns newly malloc'd string - you must free it
*/
static char *replace_str(char *str, char *orig, char *rep)
{
int occurrences = 0;
int i = 0, k = 0;
char *p = str;
while ((p = strstr(p, orig)) != NULL) {
++occurrences;
p += strlen(orig);
}
char *buffer = malloc(strlen(str) + 1 - (occurrences * (strlen(orig) - strlen(rep))));
if(buffer == NULL)
return NULL;
p = str;
while ((p = strstr(p, orig)) != NULL) {
int j = p - str - k;
strncpy(buffer + i, str + k, j);
i += j;
strcpy(buffer + i, rep);
i += strlen(rep);
p += strlen(orig);
k += j + strlen(orig);
}
strncpy(buffer + i, str + k, strlen(str + k));
buffer[i + strlen(str + k)] = '\0';
return buffer;
}
int main(int argc, char **argv)
{
if (argc != 5)
{
usage();
}
url = argv[1];
char *sr_name = argv[2];
char *username = argv[3];
char *password = argv[4];
xmlInitParser();
xmlKeepBlanksDefault(0);
xen_init();
curl_global_init(CURL_GLOBAL_ALL);
#define CLEANUP \
do { \
xen_session_logout(session); \
curl_global_cleanup(); \
xen_fini(); \
xmlCleanupParser(); \
} while(0) \
xen_session *session =
xen_session_login_with_password(call_func, NULL, username, password,
xen_api_latest_version);
/* ---------------------------------------------------------------------
Read host, capabilities and API vsn
--------------------------------------------------------------------- */
printf("\n\nQuerying host...\n");
xen_host host;
if (!xen_session_get_this_host(session, &host, session))
{
print_error(session);
CLEANUP;
return 1;
}
xen_string_string_map *versions;
if (!xen_host_get_software_version(session, &versions, host))
{
print_error(session);
xen_host_free(host);
CLEANUP;
return 1;
}
xen_string_set *supported_bootloaders;
if (!xen_host_get_supported_bootloaders(session, &supported_bootloaders,
host))
{
print_error(session);
xen_string_string_map_free(versions);
xen_host_free(host);
CLEANUP;
return 1;
}
xen_string_set *capabilities;
if (!xen_host_get_capabilities(session, &capabilities, host))
{
print_error(session);
xen_string_set_free(supported_bootloaders);
xen_string_string_map_free(versions);
xen_host_free(host);
CLEANUP;
return 1;
}
for (size_t i = 0; i < versions->size; i++)
{
printf("%s -> %s.\n", versions->contents[i].key,
versions->contents[i].val);
}
printf("Host supports the following bootloaders:");
for (size_t i = 0; i < supported_bootloaders->size; i++)
{
printf(" %s", supported_bootloaders->contents[i]);
}
printf("\n");
printf("Host has the following capabilities:");
for (size_t i = 0; i < capabilities->size; i++)
{
printf(" %s", capabilities->contents[i]);
}
printf("\n");
xen_host_free(host);
xen_string_string_map_free(versions);
xen_string_set_free(supported_bootloaders);
xen_string_set_free(capabilities);
/* ---------------------------------------------------------------------
Create a new VM with a blank disk:
--------------------------------------------------------------------- */
printf("\n\nCreating new HVM VM...\n");
xen_vm hvm_vm = create_new_vm(session, "Other install media", sr_name, false);
if (!session->ok)
{
/* Error has been logged, just clean up. */
CLEANUP;
return 1;
}
print_vm_power_state(session, hvm_vm);
/* Blob handling used to crash when we tried to free the VM record:
* CA-38872. */
xen_blob blob;
xen_blob_create(session, &blob, "hello", false);
xen_vm_create_new_blob(session, &blob, hvm_vm, "test", "test", false);
printf("\nBlob created.\n");
xen_blob_record *blob_record;
xen_blob_get_record(session, &blob_record, blob);
printf("Blob record retrieved.\n");
printf("\nGetting VM record...\n");
xen_vm_record *vm_record;
xen_vm_get_record(session, &vm_record, hvm_vm);
printf("VM record: %s blob: %s\n",
(char *)vm_record->handle,
(char *)blob_record->handle);
printf("Freeing VM record...\n");
xen_vm_record_free(vm_record);
printf("VM record freed.\n");
printf("Freeing blob record...\n");
xen_blob_record_free(blob_record);
printf("Blob record freed.\n");
if (!session->ok)
{
/* Error has been logged, just clean up. */
xen_vm_free(hvm_vm);
CLEANUP;
return 1;
}
/*
Test Enum parsing by setting actions after shutdown
*/
xen_vm_set_actions_after_shutdown(session, hvm_vm, XEN_ON_NORMAL_EXIT_RESTART);
/*
Test getting a map and having a play
*/
xen_string_string_map *hvm_boot_params;
if (!xen_vm_get_hvm_boot_params(session, &hvm_boot_params, hvm_vm))
{
print_error(session);
CLEANUP;
return 1;
}
printf("HVM_boot_params contains:\n");
for (size_t i = 0; i < hvm_boot_params->size; i++)
{
printf("%s -> %s.\n", hvm_boot_params->contents[i].key,
hvm_boot_params->contents[i].val);
}
xen_string_string_map_free(hvm_boot_params);
cycle_vm(session, hvm_vm);
xen_vm_free(hvm_vm);
/* TODO uncomment this when we test against real
hosts, as SDK doesn't have debian template
printf("\n\nCreating new PV VM...\n");
xen_vm pv_vm = create_new_vm(session, "Debian Etch 4.0", sr_name, true);
if (!session->ok)
{
CLEANUP;
return 1;
}
if (!xen_vm_get_hvm_boot_params(session, &hvm_boot_params, pv_vm))
{
print_error(session);
CLEANUP;
return 1;
}
for (size_t i = 0; i < hvm_boot_params->size; i++)
{
printf("%s -> %s.\n", hvm_boot_params->contents[i].key,
hvm_boot_params->contents[i].val);
}
cycle_vm(session, pv_vm);
xen_vm_free(pv_vm);
*/
CLEANUP;
}
/*
* Async job worker that gets called on a separate thread (see Xen_Job.c)
*/
static void migrate_task(void *async_job)
{
/* Perform the migration */
Xen_job *job = (Xen_job *)async_job;
xen_utils_session *session = job->session;
int state = JobState_Exception;
CMPIrc statusrc = CMPI_RC_ERR_FAILED;
char *job_status_description = "ERROR: Migrate VM failed with unknown error";
char *xen_error = NULL;
migrate_job_context *job_context = (migrate_job_context *)job->job_context;
bool kvpNeedsReenabling=false;
bool error=false;
char *uuid=NULL;
xen_string_string_map *other_config=NULL;
_SBLIM_TRACE(_SBLIM_TRACE_LEVEL_INFO, ("Migration job started"));
state = JobState_Running;
job_change_state(job, session, state, 0, 0, STATE_MIGRATE_STARTED);
sleep(1);
if(!error && !xen_vm_get_uuid(session->xen, &uuid, job_context->vm)) {
_SBLIM_TRACE(_SBLIM_TRACE_LEVEL_ERROR, ("Could not get the UUID of the vm."));
error=true;
}
if(!error && !xen_vm_get_other_config(session->xen, &other_config, job_context->vm)) {
_SBLIM_TRACE(_SBLIM_TRACE_LEVEL_ERROR, ("Could not get other_config of the VM"));
error=true;
}
if(!error && xen_utils_get_from_string_string_map(other_config, "kvp_enabled")) {
_SBLIM_TRACE(_SBLIM_TRACE_LEVEL_INFO, ("KVP is enabled, disabling it to allow migration"));
kvpNeedsReenabling=true;
if(xen_utils_preparemigration_kvp_channel(session, uuid) != Xen_KVP_RC_OK) {
error=true;
_SBLIM_TRACE(_SBLIM_TRACE_LEVEL_ERROR, ("Could not prepare KVP for migration"));
}
}
if(!error) {
_SBLIM_TRACE(_SBLIM_TRACE_LEVEL_INFO, ("Doing the migration"));
xen_string_string_map *options = xen_string_string_map_alloc(0);
if(!xen_vm_pool_migrate(session->xen, job_context->vm, job_context->host, options)) {
_SBLIM_TRACE(_SBLIM_TRACE_LEVEL_ERROR, ("Could not do the migration"));
error=true;
}
xen_string_string_map_free(options);
}
if(!error) {
state = JobState_Completed;
statusrc = CMPI_RC_OK;
job_status_description = "Completed Successfully";
}
else {
state = JobState_Exception;
statusrc = CMPI_RC_ERR_FAILED;
xen_error = xen_utils_get_xen_error(session->xen);
job_status_description = xen_error;
}
// The reenabling of KVM is always done, it is not depending on whether the migration was succesfull / an error occured
if(kvpNeedsReenabling) {
_SBLIM_TRACE(_SBLIM_TRACE_LEVEL_INFO, ("Reenabling KVP"));
if (xen_utils_finishmigration_kvp_channel(session, uuid) != Xen_KVP_RC_OK) {
_SBLIM_TRACE(_SBLIM_TRACE_LEVEL_ERROR, ("Could not reenable KVP"));
state = JobState_Exception;
statusrc = CMPI_RC_ERR_FAILED;
job_status_description = "Error: Could not re-enable KVP channel";
}
}
_SBLIM_TRACE(_SBLIM_TRACE_LEVEL_INFO, ("Migration job status %d (%s)", statusrc, job_status_description));
job_change_state(job, session, state, 100, statusrc, job_status_description);
if(job_context->vm)
xen_vm_free(job_context->vm);
if(job_context->host)
xen_host_free(job_context->host);
free(job_context);
if(xen_error)
free(xen_error);
if(uuid)
free(uuid);
if(other_config)
free(other_config);
}
int main(int argc, char **argv)
{
if (argc != 6)
{
usage();
}
url = argv[1];
char *username = argv[2];
char *password = argv[3];
source_url = argv[4];
target_url = argv[5];
xmlInitParser();
xmlKeepBlanksDefault(0);
xen_init();
curl_global_init(CURL_GLOBAL_ALL);
#define CLEANUP \
do { \
xen_session_logout(session); \
curl_global_cleanup(); \
xen_fini(); \
xmlCleanupParser(); \
} while(0) \
xen_session *session =
xen_session_login_with_password(call_func, NULL, username, password,
xen_api_latest_version);
printf("\n\nQuerying host...\n");
xen_host host;
if (!xen_session_get_this_host(session, &host, session))
{
print_error(session);
CLEANUP;
return 1;
}
/* Read in the source host and target host using their name labels
*/
xen_host_set *source_hosts;
int rc = 0;
rc = get_host_names(session, &source_hosts, source_url );
if (rc !=0 )
{
fprintf(stderr, "source host lookup failed.\n");
print_error(session);
return 1;
}
xen_host_set *target_hosts;
rc = 0;
rc = get_host_names(session, &target_hosts, target_url );
if (rc !=0 )
{
fprintf(stderr, "target host lookup failed.\n");
print_error(session);
return 1;
}
struct xen_vm_set *all_vms_in_pool;
xen_vm_get_all(session, &all_vms_in_pool);
bool *vm_to_be_migrated = calloc(all_vms_in_pool->size, sizeof(bool));
int num_vms_to_migrate = 0;
enum xen_task_status_type task_status;
xen_vm_record* result;
for (size_t i = 0; i < all_vms_in_pool->size; i++ )
{
xen_vm a_vm = all_vms_in_pool->contents[i];
xen_vm_get_record(session, &result, a_vm);
/*
* we can only migrate VMs that are
* -not templates
* -not control domains
* -and are running
*
* resident_on is used to identify the eligible VMs on the user
* requested source_host
*/
if ( !result->is_a_template
&& !result->is_control_domain
&& (result->power_state == XEN_VM_POWER_STATE_RUNNING)
&& (strcmp(result->resident_on->u.handle,
(char*)source_hosts->contents[0]) == 0) )
{
// flag this VM as one suitable to migrate
vm_to_be_migrated[i] = true;
num_vms_to_migrate++;
}
else
{
vm_to_be_migrated[i] = false;
}
}
if (!session->ok)
{
/* Error has been logged, just clean up. */
xen_host_set_free(source_hosts);
xen_host_set_free(target_hosts);
xen_vm_set_free(all_vms_in_pool);
xen_vm_record_free(result);
free(vm_to_be_migrated);
CLEANUP;
return 1;
}
xen_task* task_list = calloc(num_vms_to_migrate, sizeof(xen_task));
xen_string_string_map* options = xen_string_string_map_alloc(0);
xen_string_set *error_msgs = NULL;
int idx = 0;
for (size_t i = 0; i < all_vms_in_pool->size; i++ )
{
if (vm_to_be_migrated[i] == true)
{
xen_vm_pool_migrate_async(session, &task_list[idx], all_vms_in_pool->contents[i],
target_hosts->contents[0], options );
idx++;
printf(" Migrating VM %zd \n", i);
}
}
// time out after certain number of iterations
int max_iter = 50;
int iter = 0;
int pause_interval_secs = 4;
int tasks_running = 0;
int tasks_completed = 0;
xen_task a_task;
bool tasks_still_pending = true;
/* Poll how many of the migration tasks have completed.
*
* The task querying below isn't is intended to provide a sample of useful
* syntax. In practice a user would probably consider using functions such
* as xen_task_cancel or indeed the asynchronous equivalent
* xen_task_cancel_async.
* These functions and other task handling ones are defined in xen_task.c
*/
while ( iter < max_iter && tasks_still_pending )
{
tasks_running = 0;
tasks_completed = 0;
for (int j = 0; j < num_vms_to_migrate; j++)
{
a_task = task_list[j];
xen_task_get_status(session, &task_status, a_task);
if (task_status == XEN_TASK_STATUS_TYPE_PENDING)
{
tasks_running++;
}
else
{
/* See the xen_task_status_type enum definitions
* defined in xen_task_status_type.h a task can have
* failed, or be cancelled or in the process of being cancelled
* amongst others.
* The definition of tasks_completed in this context is tasks
* not pending.
*/
if (task_status == XEN_TASK_STATUS_TYPE_FAILURE)
{
if (xen_task_get_error_info(session, &error_msgs, task_list[j] ))
{
/* VMs may need to meet certain criteria for migration to be
* possible between hosts; such as shared storage between
* hosts. It is advisable to check the criteria needed for
* migration on the particular version of XenServer.
* The error messages output below should give information
* that allows the identification of an unsupported
* operation
*/
printf("-------------------------------------\n");
printf("Failed while trying to migrate VM: \n");
for(size_t k=0; k<error_msgs->size; k++)
{
printf("error_msg %zu : %s \n", k, error_msgs->contents[k]);
}
}
}
tasks_completed++;
}
}
if (tasks_running == 0)
{
tasks_still_pending = false; // stop the iteration early
printf("All tasks completed \n");
}
printf("*********************************************\n");
printf("VM migration progress, poll number %d \n", iter);
printf("----------------------------------------\n");
printf(" Tasks pending : %d \n", tasks_running);
printf(" ended : %d \n", tasks_completed);
printf("*********************************************\n");
iter++;
sleep(pause_interval_secs);
}
xen_string_set_free(error_msgs);
xen_string_string_map_free(options);
xen_host_set_free(source_hosts);
xen_host_set_free(target_hosts);
free(task_list);
free(vm_to_be_migrated);
xen_vm_set_free(all_vms_in_pool);
CLEANUP;
}
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;
}
