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.")