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 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 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 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 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 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_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 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 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 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 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 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 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_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 test_unregister_validation(self):
res = secret.unregister(["this-is-not-a-uuid"])
self.assertEqual(res, response.error("secretBadRequestErr"))
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 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_unregister_validation(self):
res = secret.unregister(["this-is-not-a-uuid"])
self.assertEqual(res, response.error("secretBadRequestErr"))
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_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_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_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 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"))
