/***************************************************************************** * 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; }