def unregister(uuids): try: uuids = [str(uuid.UUID(s)) for s in uuids] except ValueError as e: logging.warning("Attempt to unregister invalid uuid %s: %s" % (uuids, e)) return response.error("secretBadRequestErr") con = libvirtconnection.get() try: for sec_uuid in uuids: logging.info("Unregistering secret %r", sec_uuid) try: virsecret = con.secretLookupByUUIDString(sec_uuid) except libvirt.libvirtError as e: if e.get_error_code() != libvirt.VIR_ERR_NO_SECRET: raise logging.debug("No such secret %r", sec_uuid) else: virsecret.undefine() except libvirt.libvirtError as e: logging.error("Could not unregister secrets: %s", e) return response.error("secretUnregisterErr") return response.success()
def delete(job_id): try: _delete(job_id) except ClientError as e: logging.info('Cannot delete job, error: %s', e) return response.error(e.name) return response.success()
def test_register_libvirt_error(self): def fail(xml): raise vmfakelib.Error(libvirt.VIR_ERR_INTERNAL_ERROR) self.connection.secretDefineXML = fail res = secret.register([make_secret()]) self.assertEqual(res, response.error("secretRegisterErr"))
def run(self): try: startTime = time.time() self._setupVdsConnection() self._setupRemoteMachineParams() self._prepareGuest() with SourceThread._ongoingMigrations: try: if self._migrationCanceledEvt: self._raiseAbortError() self.log.debug("migration semaphore acquired " "after %d seconds", time.time() - startTime) params = { 'dst': self._dst, 'mode': self._mode, 'method': METHOD_ONLINE, 'dstparams': self._dstparams, 'dstqemu': self._dstqemu, } with self._vm.migration_parameters(params): self._vm.saveState() self._startUnderlyingMigration(time.time()) self._finishSuccessfully() except libvirt.libvirtError as e: if e.get_error_code() == libvirt.VIR_ERR_OPERATION_ABORTED: self.status = response.error( 'migCancelErr', message='Migration canceled') raise except MigrationDestinationSetupError as e: self._recover(str(e)) # we know what happened, no need to dump hollow stack trace except Exception as e: self._recover(str(e)) self.log.exception("Failed to migrate")
def test_unregister_libvirt_error(self): def fail(uuid): raise vmfakelib.Error(libvirt.VIR_ERR_INTERNAL_ERROR) self.connection.secretLookupByUUIDString = fail res = secret.unregister([str(uuid.uuid4())]) self.assertEqual(res, response.error("secretUnregisterErr"))
def abort(job_id): try: job = get(job_id) job.abort() except ClientError as e: logging.info('Cannot abort job, error: %s', e) return response.error(e.name) return response.success()
def test_error(self): NAME = 'noVM' # no special meaning, any error is fine res = response.error(NAME) template = errCode[NAME] self.assertEqual(res["status"]["code"], template["status"]["code"]) self.assertEqual(res["status"]["message"], template["status"]["message"])
def test_error_with_message(self): NAME = 'noVM' # no special meaning, any error is fine MESSAGE = 'we want a specific message here' res = response.error(NAME, MESSAGE) template = errCode[NAME] self.assertEqual(res["status"]["code"], template["status"]["code"]) self.assertEqual(res["status"]["message"], MESSAGE)
def delete(job_id): try: job = get(job_id) job.validate_not_active() _delete(job_id) except ClientError as e: logging.info('Cannot delete job, error: %s', e) return response.error(e.name) return response.success()
def delete(job_id): try: job = get(job_id) job.validate_not_running() _delete(job_id) except ClientError as e: logging.info('Cannot delete job, error: %s', e) return response.error(e.name) return response.success()
def run(self): self._update_outgoing_limit() try: startTime = time.time() self._setupVdsConnection() self._setupRemoteMachineParams() self._prepareGuest() while self._progress < 100: try: with SourceThread.ongoingMigrations: timeout = config.getint( 'vars', 'guest_lifecycle_event_reply_timeout') if self.hibernating: self._vm.guestAgent.events.before_hibernation( wait_timeout=timeout) elif self._enableGuestEvents: self._vm.guestAgent.events.before_migration( wait_timeout=timeout) if self._migrationCanceledEvt.is_set(): self._raiseAbortError() self.log.debug( "migration semaphore acquired " "after %d seconds", time.time() - startTime) params = { 'dst': self._dst, 'mode': self._mode, 'method': METHOD_ONLINE, 'dstparams': self._dstparams, 'dstqemu': self._dstqemu, } with self._vm.migration_parameters(params): self._vm.saveState() self._startUnderlyingMigration(time.time()) self._finishSuccessfully() except libvirt.libvirtError as e: if e.get_error_code() == libvirt.VIR_ERR_OPERATION_ABORTED: self.status = response.error( 'migCancelErr', message='Migration canceled') raise except MigrationLimitExceeded: retry_timeout = config.getint('vars', 'migration_retry_timeout') self.log.debug( "Migration destination busy. Initiating " "retry in %d seconds.", retry_timeout) self._migrationCanceledEvt.wait(retry_timeout) except MigrationDestinationSetupError as e: self._recover(str(e)) # we know what happened, no need to dump hollow stack trace except Exception as e: self._recover(str(e)) self.log.exception("Failed to migrate")
def get_external_vm_names(uri, username, password): try: conn = libvirtconnection.open_connection(uri=uri, username=username, passwd=password) except libvirt.libvirtError as e: logging.error('error connecting to hypervisor: %r', e.message) return response.error('V2VConnection', e.message) with closing(conn): vms = [vm.name() for vm in _list_domains(conn)] return response.success(vmNames=vms)
def run(self): self._update_outgoing_limit() try: startTime = time.time() self._setupVdsConnection() self._setupRemoteMachineParams() self._prepareGuest() while self._progress < 100: try: with SourceThread.ongoingMigrations: timeout = config.getint( 'vars', 'guest_lifecycle_event_reply_timeout') if self.hibernating: self._vm.guestAgent.events.before_hibernation( wait_timeout=timeout) elif self._enableGuestEvents: self._vm.guestAgent.events.before_migration( wait_timeout=timeout) if self._migrationCanceledEvt.is_set(): self._raiseAbortError() self.log.debug("migration semaphore acquired " "after %d seconds", time.time() - startTime) params = { 'dst': self._dst, 'mode': self._mode, 'method': METHOD_ONLINE, 'dstparams': self._dstparams, 'dstqemu': self._dstqemu, } with self._vm.migration_parameters(params): self._vm.saveState() self._startUnderlyingMigration(time.time()) self._finishSuccessfully() except libvirt.libvirtError as e: if e.get_error_code() == libvirt.VIR_ERR_OPERATION_ABORTED: self.status = response.error( 'migCancelErr', message='Migration canceled') raise except MigrationLimitExceeded: retry_timeout = config.getint('vars', 'migration_retry_timeout') self.log.debug("Migration destination busy. Initiating " "retry in %d seconds.", retry_timeout) self._migrationCanceledEvt.wait(retry_timeout) except MigrationDestinationSetupError as e: self._recover(str(e)) # we know what happened, no need to dump hollow stack trace except Exception as e: self._recover(str(e)) self.log.exception("Failed to migrate")
def register(secrets, clear=False): try: secrets = [Secret(params) for params in secrets] except ValueError as e: logging.warning("Attempt to register invalid secret: %s", e) return response.error("secretBadRequestErr") con = libvirtconnection.get() try: for secret in secrets: logging.info("Registering secret %s", secret) secret.register(con) if clear: uuids = frozenset(sec.uuid for sec in secrets) for virsecret in con.listAllSecrets(): if (virsecret.UUIDString() not in uuids and _is_ovirt_secret(virsecret)): virsecret.undefine() except libvirt.libvirtError as e: logging.error("Could not register secret %s: %s", secret, e) return response.error("secretRegisterErr") return response.success()
def testSetNumberOfVcpusFailed(self, virt_error, vdsm_error, error_message): def _fail(*args): raise_libvirt_error(virt_error, error_message) with MonkeyPatchScope([(hooks, 'before_set_num_of_cpus', lambda: None)]): with fake.VM() as testvm: dom = fake.Domain() dom.setVcpusFlags = _fail testvm._dom = dom res = testvm.setNumberOfCpus(4) # random value self.assertEqual(res, response.error(vdsm_error))
def _recover(self, message): if not response.is_error(self.status): self.status = response.error('migrateErr') self.log.error(message) if not self.hibernating: try: self._destServer.destroy(self._vm.id) except Exception: self.log.exception("Failed to destroy remote VM") # if the guest was stopped before migration, we need to cont it if self.hibernating: self._vm.cont() # either way, migration has finished self._vm.lastStatus = vmstatus.UP self._vm.send_status_event()
def _recover(self, message): if not response.is_error(self.status): self.status = response.error('migrateErr') self.log.error(message) if not self.hibernating and self._destServer is not None: try: self._destServer.destroy(self._vm.id) except Exception: self.log.exception("Failed to destroy remote VM") # if the guest was stopped before migration, we need to cont it if self.hibernating: self._vm.cont() # either way, migration has finished self._vm.lastStatus = vmstatus.UP self._vm.send_status_event()
def testUpdateDeviceGraphicsFailed(self): with fake.VM(devices=self.GRAPHIC_DEVICES) as testvm: message = 'fake timeout while setting ticket' device = 'spice' domXml = ''' <devices> <graphics type="%s" port="5900" /> </devices>''' % device def _fail(*args): raise virdomain.TimeoutError(defmsg=message) domain = fake.Domain(domXml) domain.updateDeviceFlags = _fail testvm._dom = domain res = self._updateGraphicsDevice(testvm, device) self.assertEqual(res, response.error('ticketErr', message))
def _recover(self, message): if not response.is_error(self.status): self.status = response.error('migrateErr') self.log.error(message) if not self.hibernating and self._destServer is not None: try: self._destServer.destroy(self._vm.id) except Exception: self.log.exception("Failed to destroy remote VM") # if the guest was stopped before migration, we need to cont it if self.hibernating: self._vm.cont(ignoreStatus=True) if self._enableGuestEvents: self._vm.guestAgent.events.after_hibernation_failure() elif self._enableGuestEvents: self._vm.guestAgent.events.after_migration_failure() # either way, migration has finished self._vm.lastStatus = vmstatus.UP self._vm.send_status_event()
def run(self): try: startTime = time.time() self._setupVdsConnection() self._setupRemoteMachineParams() self._prepareGuest() with SourceThread._ongoingMigrations: try: if self._migrationCanceledEvt: self._raiseAbortError() self.log.debug( "migration semaphore acquired " "after %d seconds", time.time() - startTime) params = { 'dst': self._dst, 'mode': self._mode, 'method': METHOD_ONLINE, 'dstparams': self._dstparams, 'dstqemu': self._dstqemu, } with self._vm.migration_parameters(params): self._vm.saveState() self._startUnderlyingMigration(time.time()) self._finishSuccessfully() except libvirt.libvirtError as e: if e.get_error_code() == libvirt.VIR_ERR_OPERATION_ABORTED: self.status = response.error( 'migCancelErr', message='Migration canceled') raise except MigrationDestinationSetupError as e: self._recover(str(e)) # we know what happened, no need to dump hollow stack trace except Exception as e: self._recover(str(e)) self.log.exception("Failed to migrate")
def test_unregister_validation(self): res = secret.unregister(["this-is-not-a-uuid"]) self.assertEqual(res, response.error("secretBadRequestErr"))
def test_legacy_error_code(self): for code, res in errCode.items(): self.assertTrue(response.is_error(res)) self.assertEqual(res, response.error(code))
def test_is_error(self): NAME = 'noVM' # no special meaning, any error is fine self.assertTrue(response.is_error(response.error(NAME)))
def test_delete_running_job(self): job = TestingJob() jobs.add(job) self.assertEqual(response.error(jobs.JobNotDone.name), jobs.delete(job.id))
def _createVm_fails(*args, **kwargs): return response.error('noVM')
def test_delete_unknown_job(self): self.assertEqual(response.error(jobs.NoSuchJob.name), jobs.delete('foo'))
def test_delete_active_job(self, status): job = TestingJob() job._status = status jobs.add(job) self.assertEqual(response.error(jobs.JobNotDone.name), jobs.delete(job.id))
def test_abort_not_supported(self): job = jobs.Job(str(uuid.uuid4())) jobs.add(job) self.assertEqual(response.error(jobs.AbortNotSupported.name), jobs.abort(job.id))
def test_abort_unknown_job(self): self.assertEqual(response.error(jobs.NoSuchJob.name), jobs.abort('foo'))
def test_is_specific_error(self, actual_err, expected_err): match = actual_err == expected_err self.assertEquals( match, response.is_error(response.error(actual_err), err=expected_err))
def test_register_validation(self): res = secret.register([{"invalid": "secret"}]) self.assertEqual(res, response.error("secretBadRequestErr"))
def test_is_specific_error(self, actual_err, expected_err): match = actual_err == expected_err self.assertEquals(match, response.is_error(response.error(actual_err), err=expected_err))