def test_read_status_bad_source_credentials(self, virt):
config = self.create_config('test', None, type='libvirt')
virt.return_value.getCapabilities.return_value = LIBVIRT_CAPABILITIES_XML
virt.return_value.getType.return_value = "LIBVIRT_TYPE"
virt.return_value.getVersion.return_value = "VERSION 1337"
v = Virt.from_config(self.logger,
config,
Datastore(),
interval=DefaultInterval)
v._terminate_event = Event()
v._interval = 3600
v._oneshot = True
v._createEventLoop = Mock()
v.status = True
v._send_data = Mock()
v.statusConfirmConnection = Mock()
v.statusConfirmConnection.side_effect = VirtError(
"Incorrect domain/username/password")
v.run()
v._send_data.assert_called_once_with(data_to_send=ANY)
self.assertTrue(
isinstance(v._send_data.mock_calls[0].kwargs['data_to_send'],
StatusReport))
self.assertEqual(
v._send_data.mock_calls[0].kwargs['data_to_send'].data['source']
['server'], None)
self.assertEqual(
v._send_data.mock_calls[0].kwargs['data_to_send'].data['source']
['message'], "Incorrect domain/username/password.")
def test_staus_bad_source_credentials(self, get):
get.return_value.content = '<xml></xml>'
get.return_value.status_code = 200
self.rhevm.status = True
self.rhevm._send_data = Mock()
self.rhevm.statusConfirmConnection = Mock()
self.rhevm.statusConfirmConnection.side_effect = VirtError(
"Incorrect domain/username/password")
self.rhevm.dest = Queue()
self.rhevm._terminate_event = Event()
self.rhevm._oneshot = True
self.rhevm._interval = 0
self.rhevm.run()
self.rhevm._send_data.assert_called_once_with(data_to_send=ANY)
self.assertTrue(
isinstance(
self.rhevm._send_data.mock_calls[0].kwargs['data_to_send'],
StatusReport))
self.assertEqual(
self.rhevm._send_data.mock_calls[0].kwargs['data_to_send'].
data['source']['server'], self.rhevm.config['server'])
self.assertEqual(
self.rhevm._send_data.mock_calls[0].kwargs['data_to_send'].
data['source']['message'], "Incorrect domain/username/password.")
def _listDomains(self):
domains = []
try:
# Active domains
for domainID in self.virt.listDomainsID():
domain = self._lookupDomain(self.virt.lookupByID, domainID)
if domain is None:
# Domain not found, most likely it was just destroyed, ignoring
self.logger.debug("Lookup for domain by ID %s failed, probably it was just destroyed, ignoring" % domainID)
continue
if domain.UUIDString() == "00000000-0000-0000-0000-000000000000":
# Don't send Domain-0 on xen (zeroed uuid)
continue
domains.append(LibvirtdGuest(domain))
# Non active domains
for domainName in self.virt.listDefinedDomains():
domain = self._lookupDomain(self.virt.lookupByName, domainName)
if domain is None:
# Domain not found, most likely it was just destroyed, ignoring
self.logger.debug("Lookup for domain by name '%s' failed, probably it was just destroyed, ignoring" % domainName)
continue
domains.append(LibvirtdGuest(domain))
except libvirt.libvirtError as e:
self.virt.close()
raise VirtError(str(e))
self.logger.debug("Libvirt domains found: %s", ", ".join(guest.uuid for guest in domains))
return domains
def _get_data(self):
# TODO: do some checking of the file content
try:
with open(self.config.file, 'r') as f:
return json.load(f, object_hook=decode)
except (IOError, ValueError) as e:
raise VirtError("Can't read fake '%s' virt data: %s" % (self.config.file, str(e)))
def test_status_error(self):
config_values = {
'type': 'virt',
'server': 'localhost',
'username': '******',
'password': '******',
'owner': 'owner',
}
config = VirtConfigSection('test', None)
config.update(**config_values)
self.virt = Virt(self.logger, config, None,
interval=60) # No dest given here
self.virt.status = True
self.virt._send_data = Mock()
self.virt._run = Mock(
side_effect=VirtError('unable to connect to source'))
self.run_once()
self.virt._send_data.assert_called_once_with(data_to_send=ANY)
self.assertTrue(
isinstance(
self.virt._send_data.mock_calls[0].kwargs['data_to_send'],
StatusReport))
self.assertEqual(
self.virt._send_data.mock_calls[0].kwargs['data_to_send'].
data['source']['message'], 'unable to connect to source.')
def getHostGuestMapping(self):
assoc = {'hypervisors': []}
try:
for hypervisor in self._get_data()['hypervisors']:
assoc['hypervisors'].append(self._process_hypervisor(hypervisor))
except KeyError as e:
raise VirtError("Fake virt file '%s' is not properly formed: %s" % (self.config.file, str(e)))
return assoc
def listDomains(self):
hypervisor = self._get_data()['hypervisors'][0]
if 'uuid' in hypervisor:
raise VirtError("Fake virt file '%s' is not properly formed: "
"uuid key shouldn't be present, try to check is_hypervisor value" %
self.config.file)
guests = []
for guest in hypervisor['guests']:
guests.append(self._process_guest(guest))
return guests
def list_domains_from_file(cls, file_path):
hypervisor = cls._read_data(file_path)['hypervisors'][0]
if 'hypervisorId' in hypervisor:
raise VirtError(
"Fake virt file '%s' is not properly formed: "
"uuid key shouldn't be present, try to check is_hypervisor value"
% file_path)
guests = []
for guest in hypervisor['guestIds']:
guests.append(cls.process_guest(guest))
return guests
def read_host_guest_mapping_from_file(cls, file_path):
# Used to read the host-guest mapping from a file. Raises VirtError if
# we are unable to parse the file
assoc = {'hypervisors': []}
try:
for hypervisor in cls._read_data(file_path)['hypervisors']:
assoc['hypervisors'].append(cls.process_hypervisor(hypervisor))
except KeyError as e:
raise VirtError("Fake virt file '%s' is not properly formed: %s" %
(file_path, str(e)))
return assoc
def _remote_host_id(self):
if self._host_uuid is None:
if self.config.hypervisor_id == 'uuid':
self._host_uuid = self.host_capabilities_xml.find(
'host/uuid').text
elif self.config.hypervisor_id == 'hostname':
self._host_uuid = self.virt.getHostname()
else:
raise VirtError(
'Invalid option %s for hypervisor_id, use one of: uuid, or hostname'
% self.config.hypervisor_id)
return self._host_uuid
def _connect(self):
url = self.config.get('server', "")
self.logger.info("Using libvirt url: %s", url if url else '""')
try:
if self.config.get('password', None):
auth = [[libvirt.VIR_CRED_AUTHNAME, libvirt.VIR_CRED_PASSPHRASE], libvirt_cred_request, self.config]
v = libvirt.openAuth(url, auth, libvirt.VIR_CONNECT_RO)
else:
v = libvirt.openReadOnly(url)
except libvirt.libvirtError as e:
self.logger.exception("Error in libvirt backend")
raise VirtError(str(e))
v.domainEventRegister(self._callback, None)
v.setKeepAlive(5, 3)
return v
def test_status_bad_source_credentials(self, cfg, _, kube_client):
cfg.return_value = Config()
kube_client.get_nodes = Mock(return_value=self.nodes())
kube_client.get_vms.return_value = Mock(return_value=self.vms())
self.config = self.create_config(name='test',
wrapper=None,
type='kubevirt',
owner='owner',
kubeconfig='/etc/hosts',
kubeversion='version',
hypervisor_id='hostname')
self.config['server'] = 'kubeserver'
with patch.dict('os.environ', {'KUBECONFIG': '/dev/null'}):
kubevirt = Virt.from_config(self.logger, self.config, Datastore())
kubevirt.status = True
kubevirt._send_data = Mock()
kubevirt.statusConfirmConnection = Mock()
kubevirt.statusConfirmConnection.side_effect = VirtError(
"Incorrect domain/username/password")
kubevirt.dest = Mock(spec=Datastore())
kubevirt._terminate_event = Event()
kubevirt._oneshot = True
kubevirt._interval = 0
kubevirt.run()
kubevirt._send_data.assert_called_once_with(data_to_send=ANY)
self.assertTrue(
isinstance(
kubevirt._send_data.mock_calls[0].kwargs['data_to_send'],
StatusReport))
self.assertEqual(
kubevirt._send_data.mock_calls[0].kwargs['data_to_send'].
data['source']['server'], self.config['server'])
self.assertEqual(
kubevirt._send_data.mock_calls[0].kwargs['data_to_send'].
data['source']['message'],
"Incorrect domain/username/password.")
def test_status_bad_source_credentials(self, session):
session.return_value.post.side_effect = HyperVMock.post
self.hyperv.status = True
self.hyperv._send_data = Mock()
self.hyperv.statusConfirmConnection = Mock()
self.hyperv.statusConfirmConnection.side_effect = VirtError(
"Incorrect domain/username/password")
self.hyperv._oneshot = True
self.hyperv.dest = Queue()
self.hyperv._terminate_event = Event()
self.hyperv._interval = 0
self.hyperv.run()
self.hyperv._send_data.assert_called_once_with(data_to_send=ANY)
self.assertTrue(
isinstance(
self.hyperv._send_data.mock_calls[0].kwargs['data_to_send'],
StatusReport))
self.assertEqual(
self.hyperv._send_data.mock_calls[0].kwargs['data_to_send'].
data['source']['server'], self.hyperv.config['server'])
self.assertEqual(
self.hyperv._send_data.mock_calls[0].kwargs['data_to_send'].
data['source']['message'], "Incorrect domain/username/password.")