def test_getHostGuestMapping_with_hm(self):
client = Mock()
client.get_nodes.return_value = self.nodes()
client.get_vms.return_value = self.vms()
config = self.create_config(name='test', wrapper=None, type='kubevirt',
owner='owner', kubeconfig='/etc/hosts',
hypervisor_id='hostname')
with patch.dict('os.environ', {'KUBECONFIG':'/dev/null'}):
kubevirt = Virt.from_config(self.logger, config, Datastore())
kubevirt._client = client
expected_result = Hypervisor(
hypervisorId='minikube',
name='master',
guestIds=[
Guest(
'f83c5f73-5244-4bd1-90cf-02bac2dda608',
kubevirt.CONFIG_TYPE,
Guest.STATE_RUNNING,
)
],
facts={
Hypervisor.CPU_SOCKET_FACT: '2',
Hypervisor.HYPERVISOR_TYPE_FACT: 'qemu',
Hypervisor.HYPERVISOR_VERSION_FACT: 'v1.9.1+a0ce1bc657',
}
)
result = kubevirt.getHostGuestMapping()['hypervisors'][0]
self.assertEqual(expected_result.toDict(), result.toDict())
def test_pending_vm(self):
client = Mock()
client.get_nodes.return_value = self.nodes()
client.get_vms.return_value = self.pending_vms()
config = self.create_config(name='test',
wrapper=None,
type='kubevirt',
owner='owner',
kubeconfig='/etc/hosts')
with patch.dict('os.environ', {'KUBECONFIG': '/dev/null'}):
kubevirt = Virt.from_config(self.logger, config, Datastore())
kubevirt._client = client
expected_result = Hypervisor(
hypervisorId='52c01ad890e84b15a1be4be18bd64ecd',
name='main',
guestIds=[],
facts={
Hypervisor.CPU_SOCKET_FACT: '2',
Hypervisor.HYPERVISOR_TYPE_FACT: 'qemu',
Hypervisor.SYSTEM_UUID_FACT:
'52c01ad890e84b15a1be4be18bd64ecd',
Hypervisor.HYPERVISOR_VERSION_FACT: 'v1.9.1+a0ce1bc657',
})
result = kubevirt.getHostGuestMapping()['hypervisors'][0]
self.assertEqual(expected_result.toDict(), result.toDict())
def test_read_hypervisor(self):
with open(self.hypervisor_file, "w") as f:
f.write(HYPERVISOR_JSON)
with open(self.config_file, "w") as f:
f.write("""
[test]
type=fake
is_hypervisor=true
owner=taylor
env=swift
file=%s
""" % self.hypervisor_file)
effective_config = init_config({}, {}, config_dir=self.config_dir)
manager = DestinationToSourceMapper(effective_config)
self.assertEqual(len(manager.configs), 1)
virt = Virt.from_config(self.logger, manager.configs[0][1], None)
self.assertEqual(type(virt), FakeVirt)
mapping = virt.getHostGuestMapping()
self.assertTrue("hypervisors" in mapping)
hypervisors = mapping["hypervisors"]
self.assertEqual(len(hypervisors), 1)
hypervisor = hypervisors[0]
self.assertEqual(type(hypervisor), Hypervisor)
self.assertEqual(hypervisor.hypervisorId,
"60527517-6284-7593-6AAB-75BF2A6375EF")
self.assertEqual(len(hypervisor.guestIds), 1)
guest = hypervisor.guestIds[0]
self.assertEqual(guest.uuid, "07ED8178-95D5-4244-BC7D-582A54A48FF8")
self.assertEqual(guest.state, 1)
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 setUp(self, is_pc=False):
config = self.create_config(name='test', wrapper=None, type='ahv',
server='10.10.10.10', username='******',
password='******', owner='owner',
prism_central=is_pc)
self.ahv = Virt.from_config(self.logger, config, Datastore(),
interval=DefaultInterval)
def test_status(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()
self.run_once(kubevirt)
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'])
def test_milicpu(self):
client = Mock()
client.get_nodes.return_value = self.new_nodes()
client.get_vms.return_value = self.vms()
config = self.create_config(name='test',
wrapper=None,
type='kubevirt',
owner='owner',
kubeconfig='/etc/hosts')
with patch.dict('os.environ', {'KUBECONFIG': '/dev/null'}):
kubevirt = Virt.from_config(self.logger, config, Datastore())
kubevirt._client = client
expected_result = Hypervisor(
hypervisorId='52c01ad890e84b15a1be4be18bd64ecd',
name='main',
guestIds=[
Guest(
'f83c5f73-5244-4bd1-90cf-02bac2dda608',
kubevirt.CONFIG_TYPE,
Guest.STATE_RUNNING,
)
],
facts={
Hypervisor.CPU_SOCKET_FACT: '7',
Hypervisor.HYPERVISOR_TYPE_FACT: 'qemu',
Hypervisor.SYSTEM_UUID_FACT:
'52c01ad890e84b15a1be4be18bd64ecd',
Hypervisor.HYPERVISOR_VERSION_FACT: 'v1.18.0-rc.1',
})
result = kubevirt.getHostGuestMapping()['hypervisors'][0]
self.assertEqual(expected_result.toDict(), result.toDict())
def test_staus(self):
with open(self.hypervisor_file, "w") as f:
f.write(NON_HYPERVISOR_JSON)
with open(self.config_file, "w") as f:
f.write(f"""
[test]
type=fake
is_hypervisor=false
file={self.hypervisor_file}""")
effective_config = init_config({}, config_dir=self.config_dir)
manager = DestinationToSourceMapper(effective_config)
self.assertEqual(len(manager.configs), 1)
self.fake = Virt.from_config(self.logger, manager.configs[0][1], None)
self.fake.status = True
self.fake._send_data = Mock()
self.run_once()
self.fake._send_data.assert_called_once_with(data_to_send=ANY)
self.assertTrue(
isinstance(
self.fake._send_data.mock_calls[0].kwargs['data_to_send'],
StatusReport))
self.assertEqual(
self.fake._send_data.mock_calls[0].kwargs['data_to_send'].
data['source']['server'], None)
def run_virt(self, config, datastore=None):
v = Virt.from_config(self.logger, config, datastore or Datastore())
v._terminate_event = Event()
v._interval = 3600
v._oneshot = True
v._createEventLoop = Mock()
v._run()
def test_read_hypervisor(self):
with open(self.hypervisor_file, "w") as f:
f.write(HYPERVISOR_JSON)
with open(self.config_file, "w") as f:
f.write("""
[test]
type=fake
is_hypervisor=true
file=%s
""" % self.hypervisor_file)
manager = ConfigManager(self.logger, self.config_dir)
self.assertEquals(len(manager.configs), 1)
virt = Virt.from_config(self.logger, manager.configs[0], None)
self.assertEquals(type(virt), FakeVirt)
mapping = virt.getHostGuestMapping()
self.assertTrue("hypervisors" in mapping)
hypervisors = mapping["hypervisors"]
self.assertEquals(len(hypervisors), 1)
hypervisor = hypervisors[0]
self.assertEquals(type(hypervisor), Hypervisor)
self.assertEquals(hypervisor.hypervisorId,
"60527517-6284-7593-6AAB-75BF2A6375EF")
self.assertEquals(len(hypervisor.guestIds), 1)
guest = hypervisor.guestIds[0]
self.assertEquals(guest.uuid, "07ED8178-95D5-4244-BC7D-582A54A48FF8")
self.assertEquals(guest.state, 1)
def test_read_hypervisor(self):
with open(self.hypervisor_file, "w") as f:
f.write(HYPERVISOR_JSON)
with open(self.config_file, "w") as f:
f.write("""
[test]
type=fake
is_hypervisor=true
owner=taylor
env=swift
file=%s
""" % self.hypervisor_file)
effective_config = init_config({}, {}, config_dir=self.config_dir)
manager = DestinationToSourceMapper(effective_config)
self.assertEqual(len(manager.configs), 1)
virt = Virt.from_config(self.logger, manager.configs[0][1], None)
self.assertEqual(type(virt), FakeVirt)
mapping = virt.getHostGuestMapping()
self.assertTrue("hypervisors" in mapping)
hypervisors = mapping["hypervisors"]
self.assertEqual(len(hypervisors), 1)
hypervisor = hypervisors[0]
self.assertEqual(type(hypervisor), Hypervisor)
self.assertEqual(hypervisor.hypervisorId, "60527517-6284-7593-6AAB-75BF2A6375EF")
self.assertEqual(len(hypervisor.guestIds), 1)
guest = hypervisor.guestIds[0]
self.assertEqual(guest.uuid, "07ED8178-95D5-4244-BC7D-582A54A48FF8")
self.assertEqual(guest.state, 1)
def test_getHostGuestMapping(self):
client = Mock()
client.get_nodes.return_value = self.nodes()
client.get_vms.return_value = self.vms()
config = self.create_config(name='test', wrapper=None, type='kubevirt',
owner='owner', kubeconfig='/etc/hosts')
with patch.dict('os.environ', {'KUBECONFIG':'/dev/null'}):
kubevirt = Virt.from_config(self.logger, config, Datastore())
kubevirt._client = client
expected_result = Hypervisor(
hypervisorId='52c01ad890e84b15a1be4be18bd64ecd',
name='master',
guestIds=[
Guest(
'f83c5f73-5244-4bd1-90cf-02bac2dda608',
kubevirt.CONFIG_TYPE,
Guest.STATE_RUNNING,
)
],
facts={
Hypervisor.CPU_SOCKET_FACT: '2',
Hypervisor.HYPERVISOR_TYPE_FACT: 'qemu',
Hypervisor.HYPERVISOR_VERSION_FACT: 'v1.9.1+a0ce1bc657',
}
)
result = kubevirt.getHostGuestMapping()['hypervisors'][0]
self.assertEqual(expected_result.toDict(), result.toDict())
def run_virt(self, config, datastore=None):
v = Virt.from_config(self.logger, config, datastore or Datastore(),
interval=DefaultInterval)
v._terminate_event = Event()
v._interval = 3600
v._oneshot = True
v._createEventLoop = Mock()
v._run()
def test_empty_kubeconfig(self):
config = self.create_config(name='test',
wrapper=None,
type='kubevirt',
owner='owner')
kubevirt = Virt.from_config(self.logger, config, Datastore())
self.assertEqual("~/.kube/config", kubevirt._path)
def setUp(self):
config = self.create_config(name='test',
wrapper=None,
type='kubevirt',
owner='owner',
env='env')
with patch.dict('os.environ', {'KUBECONFIG': '/dev/null'}):
self.kubevirt = Virt.from_config(self.logger, config, Datastore())
def setUp(self):
config = self.create_config(name='test',
wrapper=None,
type='rhevm',
server='localhost',
username='******',
password=u'1€345678',
owner='owner')
self.rhevm = Virt.from_config(self.logger, config, Datastore())
self.rhevm.build_urls()
def setUp(self):
config = self.create_config(name='test',
wrapper=None,
type='rhevm',
server='localhost',
username='******',
password='******',
owner='owner',
env='env')
self.rhevm = Virt.from_config(self.logger, config, Datastore())
self.rhevm.major_version = '3'
self.rhevm.build_urls()
def setUp(self):
config = self.create_config(name='test',
wrapper=None,
type='xen',
server='localhost',
username='******',
password='******',
owner='owner',
env='env')
self.xen = Virt.from_config(self.logger,
config,
Datastore(),
interval=DefaultInterval)
def test_insecure(self, cfg, _):
cfg.return_value = Config()
config = self.create_config(name='test',
wrapper=None,
type='kubevirt',
owner='owner',
kubeconfig='/etc/hosts',
kubeversion='v1alpha3',
hypervisor_id='hostname',
insecure='')
kubevirt = Virt.from_config(self.logger, config, Datastore())
kubevirt.prepare()
self.assertFalse(kubevirt._insecure)
def test_version_override(self, cfg, _):
version = 'v1alpha3'
cfg.return_value = Config()
config = self.create_config(name='test',
wrapper=None,
type='kubevirt',
owner='owner',
kubeconfig='/etc/hosts',
kubeversion=version,
hypervisor_id='hostname')
kubevirt = Virt.from_config(self.logger, config, Datastore())
kubevirt.prepare()
self.assertEqual(version, kubevirt._version)
def _create_virt_backends(self):
"""
Create virts list with virt backend threads
"""
virts = []
for name, config in self.dest_to_source_mapper.configs:
try:
virt = Virt.from_config(self.logger, config, self.datastore,
terminate_event=self.terminate_event,
interval=self.options[VW_GLOBAL]['interval'],
oneshot=self.options[VW_GLOBAL]['oneshot'])
except Exception as e:
self.logger.error('Unable to use configuration "%s": %s', name, str(e))
continue
virts.append(virt)
return virts
def test_read_non_hypervisor_from_hypervisor(self):
with open(self.hypervisor_file, "w") as f:
f.write(HYPERVISOR_JSON)
with open(self.config_file, "w") as f:
f.write("""
[test]
type=fake
is_hypervisor=false
file=%s
""" % self.hypervisor_file)
manager = ConfigManager(self.logger, self.config_dir)
self.assertEquals(len(manager.configs), 1)
virt = Virt.from_config(self.logger, manager.configs[0], None)
self.assertEquals(type(virt), FakeVirt)
self.assertRaises(VirtError, virt.listDomains)
def _create_virt_backends(self):
"""
Create virts list with virt backend threads
"""
virts = []
for name, config in self.dest_to_source_mapper.configs:
try:
virt = Virt.from_config(
self.logger,
config,
self.datastore,
terminate_event=self.terminate_event,
interval=self.options[VW_GLOBAL]['interval'],
oneshot=self.options[VW_GLOBAL]['oneshot'])
except Exception as e:
self.logger.error('Unable to use configuration "%s": %s', name,
str(e))
continue
virts.append(virt)
return virts
def test_read_non_hypervisor(self):
with open(self.hypervisor_file, "w") as f:
f.write(NON_HYPERVISOR_JSON)
with open(self.config_file, "w") as f:
f.write("""
[test]
type=fake
is_hypervisor=false
file=%s
""" % self.hypervisor_file)
manager = ConfigManager(self.logger, self.config_dir)
self.assertEquals(len(manager.configs), 1)
virt = Virt.from_config(self.logger, manager.configs[0], None)
self.assertEquals(type(virt), FakeVirt)
guests = virt.listDomains()
self.assertEquals(len(guests), 1)
guest = guests[0]
self.assertEquals(guest.uuid, "9f06a84d-5f56-4e7e-be0c-937b3c1924d7")
self.assertEquals(guest.state, 1)
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_read_non_hypervisor(self):
with open(self.hypervisor_file, "w") as f:
f.write(NON_HYPERVISOR_JSON)
with open(self.config_file, "w") as f:
f.write("""
[test]
type=fake
is_hypervisor=false
file=%s
""" % self.hypervisor_file)
effective_config = init_config({}, {}, config_dir=self.config_dir)
manager = DestinationToSourceMapper(effective_config)
self.assertEqual(len(manager.configs), 1)
virt = Virt.from_config(self.logger, manager.configs[0][1], None)
self.assertEqual(type(virt), FakeVirt)
guests = virt.listDomains()
self.assertEqual(len(guests), 1)
guest = guests[0]
self.assertEqual(guest.uuid, "9f06a84d-5f56-4e7e-be0c-937b3c1924d7")
self.assertEqual(guest.state, 1)
def test_read_non_hypervisor(self):
with open(self.hypervisor_file, "w") as f:
f.write(NON_HYPERVISOR_JSON)
with open(self.config_file, "w") as f:
f.write("""
[test]
type=fake
is_hypervisor=false
file=%s
""" % self.hypervisor_file)
effective_config = init_config({}, {}, config_dir=self.config_dir)
manager = DestinationToSourceMapper(effective_config)
self.assertEqual(len(manager.configs), 1)
virt = Virt.from_config(self.logger, manager.configs[0][1], None)
self.assertEqual(type(virt), FakeVirt)
guests = virt.listDomains()
self.assertEqual(len(guests), 1)
guest = guests[0]
self.assertEqual(guest.uuid, "9f06a84d-5f56-4e7e-be0c-937b3c1924d7")
self.assertEqual(guest.state, 1)
def setUp(self):
config = self.create_config(name='test', wrapper=None, type='xen', server='localhost', username='******',
password='******', owner='owner', env='env')
self.xen = Virt.from_config(self.logger, config, Datastore(), interval=DefaultInterval)
def setUp(self):
config = self.create_config(name='test', wrapper=None, type='rhevm', server='localhost', username='******',
password=u'1€345678', owner='owner', env='env')
self.rhevm = Virt.from_config(self.logger, config, Datastore())
self.rhevm.major_version = '3'
self.rhevm.build_urls()
