/*****************************************************************************
* Function to get a provider specific resource identified by an id
*
* @param res_uuid - resource identifier for the provider specific resource
* @param session - handle to the xen_utils_session object
* @param prov_res - provide_resource object to be filled in with the provider
* specific resource
* @return CMPIrc error codes
*****************************************************************************/
static CMPIrc xen_resource_record_get_from_id(
char *res_uuid, /* in */
xen_utils_session *session, /* in */
provider_resource *prov_res /* in , out */
)
{
xen_host host = NULL;
xen_host_record *host_rec = NULL;
char buf[MAX_INSTANCEID_LEN];
if (xen_utils_class_is_subclass_of(prov_res->broker, host_cn, prov_res->classname))
/* key property is of the form 'UUID' */
strncpy(buf, res_uuid, sizeof(buf)-1);
else
/* Key property is of the form 'Xen:UUID' */
_CMPIStrncpySystemNameFromID(buf, res_uuid, sizeof(buf)-1);
if (!xen_host_get_by_uuid(session->xen, &host, buf) ||
!xen_host_get_record(session->xen, &host_rec, host)) {
xen_utils_trace_error(session->xen, __FILE__, __LINE__);
return CMPI_RC_ERR_NOT_FOUND;
}
local_host_resource *ctx = calloc(sizeof(local_host_resource), 1);
if (ctx == NULL)
return CMPI_RC_ERR_FAILED;
ctx->host = host;
ctx->host_rec = host_rec;
prov_res->ctx = ctx;
return CMPI_RC_OK;
}
/*****************************************************************************
* Function to get the next provider specific resource in the resource list
*
* @param resources_list - handle to the provide_resource_list object
* @param session - handle to the xen_utils_session object
* @param prov_res - handle to the next provider_resource to be filled in.
* @return CMPIrc error codes
*****************************************************************************/
static CMPIrc xen_resource_record_getnext(
provider_resource_list *resources_list,/* in */
xen_utils_session *session,/* in */
provider_resource *prov_res /* in , out */
)
{
xen_host_set *host_set = (xen_host_set *)resources_list->ctx;
if (host_set == NULL || resources_list->current_resource == host_set->size)
return CMPI_RC_ERR_NOT_FOUND;
xen_host_record *host_rec = NULL;
if (!xen_host_get_record(
session->xen,
&host_rec,
host_set->contents[resources_list->current_resource]
)) {
xen_utils_trace_error(resources_list->session->xen, __FILE__, __LINE__);
return CMPI_RC_ERR_FAILED;
}
local_host_resource *ctx = calloc(sizeof(local_host_resource), 1);
if (ctx == NULL)
return CMPI_RC_ERR_FAILED;
ctx->host = host_set->contents[resources_list->current_resource];
ctx->host_rec = host_rec;
host_set->contents[resources_list->current_resource] = NULL; /* do not delete this*/
prov_res->ctx = ctx;
return CMPI_RC_OK;
}
void XSLoadHostThread::run()
{
QMutexLocker(data->xen_lock);
emit progressChanged(0, trUtf8("Connecting to %1").arg(data->name));
data->session = xen_session_login_with_password(call_func, reinterpret_cast<void*>(data), data->username.toUtf8().data(), data->password.toUtf8().data(), xen_api_latest_version);
if(data->session == nullptr)
return error(trUtf8("Failed to connect to %1").arg(data->name), nullptr);
data->connected = true;
data->connect_button->setText(trUtf8("Disconnect"));
emit progressChanged(10, trUtf8("Fetching Host"));
xen_host host_handle = nullptr;
if(!xen_session_get_this_host(data->session, &host_handle, data->session))
return error(trUtf8("Failed to fetch host!"), data->session);
emit progressChanged(15, trUtf8("Fetching Data"));
if(!xen_host_get_record(data->session, &data->data, host_handle))
return error(trUtf8("Failed to fetch data!"), data->session);
emit progressChanged(20, trUtf8("Fetching VMs"));
xen_vm_xen_vm_record_map *vms;
if(!xen_vm_get_all_records(data->session, &vms))
return error(trUtf8("Failed to fetch VMs!"), data->session);
data->vm_list_widget->clear();
data->vm_count = vms->size;
data->vms = new xsvm_data*[vms->size];
for(size_t i = 0; i < data->vm_count; i++)
{
xen_vm_record *vm = vms->contents[i].val;
xsvm_data *vm_data = new xsvm_data;
vm_data->data = vm;
vm_data->host = data;
vm_data->tunnel = nullptr;
vm_data->window = nullptr;
data->vms[i] = vm_data;
if(vm->is_a_snapshot || vm->is_a_template)
continue;
doInGUIThread([this,vm_data] { QListWidgetItem *item = new QListWidgetItem(QString::fromUtf8(vm_data->data->name_label), data->vm_list_widget);
item->setData(Qt::UserRole, QVariant::fromValue(reinterpret_cast<void*>(vm_data))); });
}
doInGUIThread([this] { data->vm_list_widget->setDisabled(false); });
emit progressChanged(100, trUtf8("Connected to %1").arg(data->name));
}
// automatically generated. Do not modify
static void testHosts(xen_session *session) {
printf("\nGet all the Host Records\n");
xen_host_set *host_set;
bool d = xen_host_get_all(session, &host_set);
if (d) {
size_t i = 0;
for (; i < host_set->size; ++i) {
xen_host_record *host_record;
xen_host_get_record(session, &host_record, host_set->contents[i]);
char *handle = (char*) host_record->handle;
char *opaque = (char*) host_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_record_free(host_record);
}
} else {
print_error(session);
}
#if 0
printf("== Get All ============================\n\n");
xen_host_xen_host_record_map *result;
bool ok = xen_host_get_all_records(session, &result);
if(!ok) {
print_error(session);
}
size_t i=0;
for(;i<result->size;++i) {
xen_host key = result->contents[i].key;
struct xen_host_record *val = result->contents[i].val;
if(strcmp((char*)key, (char*)val->handle)==0) {
} else {
printf("%s v.s. %s", (char*)key, (char*)val->handle);
}
xen_host_record_free(val);
xen_host_free(key);
}
free(result);
#endif
xen_host_set_free(host_set);
printf("\n==============================================\n\n");
}
/************************************************************************
* Function that sets the properties of a CIM object with values from the
* provider specific resource.
*
* @param resource - provider specific resource to get values from
* @param inst - CIM object whose properties are being set
* @return CMPIrc return values
*************************************************************************/
static CMPIrc xen_resource_set_properties(
provider_resource *resource,
CMPIInstance *inst)
{
xen_host_record* host_rec = NULL;
xen_host_cpu_record *cpu_rec = (xen_host_cpu_record *)resource->ctx;
if(cpu_rec->host->is_record)
host_rec = cpu_rec->host->u.record;
else
xen_host_get_record(resource->session->xen, &host_rec, cpu_rec->host->u.handle);
_SBLIM_TRACE(_SBLIM_TRACE_LEVEL_INFO, ("setting properties on %s", resource->classname));
if(xen_utils_class_is_subclass_of(resource->broker, hp_cn, resource->classname))
return hostprocessor_set_properties(resource, host_rec, inst);
else
return processor_metric_set_properties(resource->broker, resource, host_rec, inst);
}
/******************************************************************************
* checks for migratability or actually does the migration
******************************************************************************/
int MigrateVirtualSystem(
const CMPIBroker *broker, /* in - CMPI Broker that does most of the work */
const CMPIContext *context, /* in - CMPI context for the caller */
const CMPIArgs *argsin, /* in - All the arguments for the method */
const CMPIArgs *argsout, /* out - All the output arguments for the method */
xen_utils_session *session, /* in - Session for making xen calls */
bool host_ip, /* in - The host parameter is an IP address */
bool migrate_check_only, /* in -Check if migration is possible only, dont actually migrate */
CMPIStatus *status) /* out - Report CMPI status of method */
{
char *hostid = NULL, *vm_uuid = NULL;
CMPIData argdata;
xen_vm vm = NULL;
xen_host_set *host_set = NULL;
CMPIInstance *msd = NULL;
xen_host host = NULL;
int rc = Xen_VirtualSystemMigrationService_MigrateVirtualSystemToSystem_Invalid_Parameter;
CMPIrc statusrc = CMPI_RC_ERR_INVALID_PARAMETER;
char *error_msg = "ERROR: Unknown error";
xen_string_string_map *other_config=NULL;
/* For now only Live migrations are supported */
if(_GetArgument(broker, argsin, "MigrationSettingData", CMPI_chars, &argdata, status)) {
/* Argument passed in as a MOF string, parse it */
msd = xen_utils_parse_embedded_instance(broker, CMGetCharPtr(argdata.value.string));
if (msd == NULL) { // parser returns zero for success, non-zero for error
error_msg = "ERROR: Couldnt parse the 'MigrationSettingData' parameter";
goto Exit;
}
}
else
/* Argument could have been passed in as an intance */
if(_GetArgument(broker, argsin, "MigrationSettingData", CMPI_instance, &argdata, status))
msd = argdata.value.inst;
if(msd != NULL) {
CMPIData data = CMGetProperty(msd, "MigrationType", status);
if(data.value.uint16 != Xen_VirtualSystemMigrationSettingData_MigrationType_Live) {
error_msg = "ERROR: 'MigrationSettingData' contains an invalid MigrationType (Live expected)";
goto Exit;
}
}
/* Host to migrate to */
if(!host_ip) {
/* required parameters */
if(!_GetArgument(broker, argsin, "DestinationSystem", CMPI_ref, &argdata, status)){
error_msg = "ERROR: 'DestionationSystem' parameter is missing";
goto Exit;
}
else {
/* This is the CIM reference to an existing Host object */
CMPIData key;
key = CMGetKey(argdata.value.ref, "Name", status);
if(status->rc != CMPI_RC_OK || CMIsNullValue(key)) {
error_msg = "ERROR: 'DestinationSystem' is missing the required 'Name' key";
goto Exit;
}
hostid = CMGetCharPtr(key.value.string);
if(!xen_host_get_by_uuid(session->xen, &host, hostid))
goto Exit;
}
}
else {
if(!_GetArgument(broker, argsin, "DestinationHost", CMPI_string, &argdata, status)) {
error_msg = "ERROR: 'DestinationHost' parameter is missing";
goto Exit;
}
else {
/* Determing Xen host based on IP address,. Cannot use inet_pton() and so on since DNS may not have been configured properly */
hostid = CMGetCharPtr(argdata.value.string);
_SBLIM_TRACE(_SBLIM_TRACE_LEVEL_INFO, ("Trying to migrate to DestinationHost : %s", hostid));
if(!xen_host_get_all(session->xen, &host_set))
goto Exit;
int i=0;
for (i=0; i<host_set->size; i++) {
xen_host_record *host_rec = NULL;
if(!xen_host_get_record(session->xen, &host_rec, host_set->contents[i]))
goto Exit;
/* DestinationHost could be an IP address or the hostname */
if((host_rec->address && (strcmp(hostid, host_rec->address) == 0)) ||
(host_rec->hostname && (strcmp(hostid, host_rec->hostname) == 0)) ||
(host_rec->name_label && (strcmp(hostid, host_rec->name_label) == 0))) {
xen_host_record_free(host_rec);
host = host_set->contents[i];
host_set->contents[i] = NULL; /* dont free this one */
break;
}
xen_host_record_free(host_rec);
}
}
}
/* VM to migrate - required parameter */
if(!_GetArgument(broker, argsin, "ComputerSystem", CMPI_ref, &argdata, status)) {
if(!_GetArgument(broker, argsin, "ComputerSystem", CMPI_string, &argdata, status)) {
error_msg = "ERROR: Missing the required 'ComputerSystem' parameter";
goto Exit;
}
else
vm_uuid = CMGetCharPtr(argdata.value.string);
} else {
argdata = CMGetKey(argdata.value.ref, "Name", status);
if(status->rc != CMPI_RC_OK || CMIsNullValue(argdata)) {
error_msg = "ERROR: ComputerSystem is missing the required 'Name' key";
goto Exit;
}
vm_uuid = CMGetCharPtr(argdata.value.string);
}
status->rc = CMPI_RC_ERR_FAILED;
rc = Xen_VirtualSystemMigrationService_MigrateVirtualSystemToSystem_Failed;
if(xen_vm_get_by_uuid(session->xen, &vm, vm_uuid)) {
_SBLIM_TRACE(_SBLIM_TRACE_LEVEL_ERROR, ("Migrating %s to %s", vm_uuid, hostid));
if(migrate_check_only) {
/* Check to see if migration is possible */
statusrc = CMPI_RC_OK;
rc = Xen_VirtualSystemMigrationService_MigrateVirtualSystemToSystem_Completed_with_No_Error;
bool migratable = xen_vm_assert_can_boot_here(session->xen, vm, host);
if(migratable == false || !session->xen->ok) {
migratable = false;
// Workaround for kvp migration
if(session->xen->error_description_count==1) {
if(xen_vm_get_other_config(session->xen, &other_config, vm)) {
if(xen_utils_get_from_string_string_map(other_config, "kvp_enabled")) {
_SBLIM_TRACE(_SBLIM_TRACE_LEVEL_INFO, ("Overwriting migratable to mark kvp vm as migratable, although its network"));
migratable=true;
RESET_XEN_ERROR(session->xen);
}
free(other_config);
} else {
_SBLIM_TRACE(_SBLIM_TRACE_LEVEL_ERROR, ("Could not get other config."));
}
}
if(migratable == false && session->xen->error_description) {
/* This is not part of the MOF (and is not documented), but nice to have */
char *xen_error = xen_utils_get_xen_error(session->xen);
CMAddArg(argsout, "Reason", (CMPIValue *)xen_error, CMPI_chars);
free(xen_error);
}
}
CMAddArg(argsout, "IsMigratable", (CMPIValue *)&migratable, CMPI_boolean);
}
else {
/* Do the actual migration, this could take a few minutes */
CMPIObjectPath* job_instance_op = NULL;
migrate_job_context *job_context = calloc(1, sizeof(migrate_job_context));
if(!job_context) {
error_msg = "ERROR: Couldn't allocate memory for the migrate job.";
goto Exit;
}
job_context->vm = vm;
job_context->host = host;
if(!job_create(broker, context, session, MIGRATE_VM_TASK_NAME, vm_uuid,
migrate_task, job_context, &job_instance_op, status)) {
error_msg = "ERROR: Couldn't prepare the Migrate job. Job wasnt started.";
goto Exit;
}
statusrc = CMPI_RC_OK;
rc = Xen_VirtualSystemMigrationService_MigrateVirtualSystemToHost_Method_Parameters_Checked___Job_Started;
CMAddArg(argsout, "Job", (CMPIValue *)&job_instance_op, CMPI_ref);
vm = NULL; /* freed by async thread */
host = NULL; /* freed by async thread */
}
}
Exit:
if(host)
xen_host_free(host);
if(vm)
xen_vm_free(vm);
if(host_set)
xen_host_set_free(host_set);
xen_utils_set_status(broker, status, statusrc, error_msg, session->xen);
return rc;
}
