def test_hypervisorCheckIn(self, server):
options = MagicMock()
server.return_value.registration.new_system_user_pass.return_value = {
'system_id': '123'
}
config = Config('test', 'libvirt', sat_server='localhost')
manager = Manager.fromOptions(self.logger, options, config)
options.env = "ENV"
options.owner = "OWNER"
manager.hypervisorCheckIn(self.host_guest_report, options)
manager.server_xmlrpc.registration.virt_notify.assert_called_with(ANY, [
[0, "exists", "system", {"identity": "host", "uuid": "0000000000000000"}],
[0, "crawl_began", "system", {}],
[0, "exists", "domain", {
"memory_size": 0,
"name": "VM 9c927368-e888-43b4-9cdb-91b10431b258 from libvirt hypervisor ad58b739-5288-4cbc-a984-bd771612d670",
"state": "running",
"uuid": "9c927368e88843b49cdb91b10431b258",
"vcpus": 1,
"virt_type": "fully_virtualized"
}],
[0, "exists", "domain", {
"memory_size": 0,
"name": "VM d5ffceb5-f79d-41be-a4c1-204f836e144a from libvirt hypervisor ad58b739-5288-4cbc-a984-bd771612d670",
"state": "shutoff",
"uuid": "d5ffceb5f79d41bea4c1204f836e144a",
"vcpus": 1,
"virt_type": "fully_virtualized"
}],
[0, "crawl_ended", "system", {}]
])
def test_sm_config_override(self, initConfig, HTTPSConnection, RhsmProxyHTTPSConnection):
"""Test if overriding options from rhsm.conf works."""
conn = MagicMock()
conn.getresponse.return_value.status = 200
conn.getresponse.return_value.read.return_value = '{"result": "ok"}'
HTTPSConnection.return_value = conn
RhsmProxyHTTPSConnection.return_value = conn
def config_get(section, key):
return {
'server/proxy_hostname': 'proxy.server.test',
'rhsm/consumerCertDir': '',
'server/hostname': 'server.test',
'server/port': '8081',
'server/prefix': 'old_prefix',
}.get('%s/%s' % (section, key), None)
initConfig.return_value.get.side_effect = config_get
config_dir = tempfile.mkdtemp()
self.addCleanup(shutil.rmtree, config_dir)
with open(os.path.join(config_dir, "test.conf"), "w") as f:
f.write("""
[test]
type=libvirt
owner=owner
env=env
rhsm_hostname=host
rhsm_port=8080
rhsm_prefix=/prefix
rhsm_proxy_hostname=
rhsm_proxy_port=8443
rhsm_insecure=1
rhsm_username=user
rhsm_password=passwd
""")
conf = parse_file(os.path.join(config_dir, "test.conf"))
effective_config = EffectiveConfig()
conf_values = conf.pop("test")
effective_config["test"] = VirtConfigSection.from_dict(
conf_values,
"test",
effective_config
)
config_manager = DestinationToSourceMapper(effective_config)
self.assertEqual(len(config_manager.configs), 1)
config = config_manager.configs[0]
manager = Manager.fromOptions(self.logger, Mock(), config)
self.assertTrue(isinstance(manager, SubscriptionManager))
self.assertEqual(config.rhsm_hostname, 'host')
self.assertEqual(config.rhsm_port, '8080')
manager._connect(config)
self.assertFalse(RhsmProxyHTTPSConnection.called, "It shouldn't use proxy")
self.assertTrue(HTTPSConnection.called)
conn.request.assert_called_with(
'GET',
'/prefix/status/',
body=ANY,
headers=ANY)
def test_sm_config_override(self, initConfig, HTTPSConnection,
RhsmProxyHTTPSConnection):
"""Test if overriding options from rhsm.conf works."""
conn = MagicMock()
conn.getresponse.return_value.status = 200
conn.getresponse.return_value.read.return_value = '{"result": "ok"}'
HTTPSConnection.return_value = conn
RhsmProxyHTTPSConnection.return_value = conn
def config_get(section, key):
return {
'server/proxy_hostname': 'proxy.server.test',
'rhsm/consumerCertDir': '',
'server/hostname': 'server.test',
'server/port': '8081',
'server/prefix': 'old_prefix',
}.get('%s/%s' % (section, key), None)
initConfig.return_value.get.side_effect = config_get
config_dir = tempfile.mkdtemp()
self.addCleanup(shutil.rmtree, config_dir)
with open(os.path.join(config_dir, "test.conf"), "w") as f:
f.write("""
[test]
type=libvirt
owner=owner
env=env
rhsm_hostname=host
rhsm_port=8080
rhsm_prefix=/prefix
rhsm_proxy_hostname=
rhsm_proxy_port=8443
rhsm_insecure=1
rhsm_username=user
rhsm_password=passwd
""")
conf = parse_file(os.path.join(config_dir, "test.conf"))
effective_config = EffectiveConfig()
conf_values = conf.pop("test")
effective_config["test"] = VirtConfigSection.from_dict(
conf_values, "test", effective_config)
config_manager = DestinationToSourceMapper(effective_config)
self.assertEqual(len(config_manager.configs), 1)
config = config_manager.configs[0]
manager = Manager.fromOptions(self.logger, Mock(), config)
self.assertTrue(isinstance(manager, SubscriptionManager))
self.assertEqual(config.rhsm_hostname, 'host')
self.assertEqual(config.rhsm_port, '8080')
manager._connect(config)
self.assertFalse(RhsmProxyHTTPSConnection.called,
"It shouldn't use proxy")
self.assertTrue(HTTPSConnection.called)
conn.request.assert_called_with('GET',
'/prefix/status/',
body=ANY,
headers=ANY)
def test_sm_config_cmd(self):
os.environ = {}
sys.argv = ["virt-who", "--sam", "--libvirt"]
logger, options = parseOptions()
config = Config("env/cmdline", options.virtType, defaults={}, **options)
config.checkOptions(logger)
manager = Manager.fromOptions(logger, options, config)
self.assertTrue(isinstance(manager, SubscriptionManager))
def test_sendVirtGuests(self, create_from_file, connection):
self.prepare(create_from_file, connection)
config = Config('test', 'libvirt')
config.smType = 'sam'
manager = Manager.fromOptions(self.logger, self.options, config)
manager.sendVirtGuests(self.domain_report, self.options)
manager.connection.updateConsumer.assert_called_with(
ANY,
guest_uuids=[guest.toDict() for guest in self.guestInfo],
hypervisor_id=self.hypervisor_id)
def test_sm_config_env(self):
os.environ = {
"VIRTWHO_SAM": '1',
"VIRTWHO_LIBVIRT": '1'
}
sys.argv = ["virt-who"]
logger, options = parseOptions()
config = Config("env/cmdline", options.virtType, defaults={}, **options)
config.checkOptions(logger)
manager = Manager.fromOptions(logger, options, config)
self.assertTrue(isinstance(manager, SubscriptionManager))
def test_satellite_config_cmd(self):
os.environ = {}
sys.argv = ["virt-who", "--satellite",
"--satellite-server=sat.example.com",
"--satellite-username=username",
"--satellite-password=password",
"--libvirt"]
logger, options = parseOptions()
config = Config("env/cmdline", options.virtType, defaults={}, **options)
config.checkOptions(logger)
manager = Manager.fromOptions(logger, options, config)
self.assertTrue(isinstance(manager, Satellite))
def test_satellite_config_env(self):
os.environ = {
"VIRTWHO_SATELLITE": '1',
"VIRTWHO_SATELLITE_SERVER": 'sat.example.com',
"VIRTWHO_SATELLITE_USERNAME": '******',
"VIRTWHO_SATELLITE_PASSWORD": '******',
"VIRTWHO_LIBVIRT": '1'
}
sys.argv = ["virt-who"]
logger, options = parseOptions()
config = Config("env/cmdline", options.virtType, defaults={}, **options)
config.checkOptions(logger)
manager = Manager.fromOptions(logger, options, config)
self.assertTrue(isinstance(manager, Satellite))
def test_satellite_config_cmd(self):
os.environ = {}
sys.argv = [
"virt-who", "--satellite", "--satellite-server=sat.example.com",
"--satellite-username=username", "--satellite-password=password",
"--libvirt"
]
logger, options = parseOptions()
config = Config("env/cmdline",
options.virtType,
defaults={},
**options)
config.checkOptions(logger)
manager = Manager.fromOptions(logger, options, config)
self.assertTrue(isinstance(manager, Satellite))
def test_satellite_config_file(self):
config_dir = tempfile.mkdtemp()
self.addCleanup(shutil.rmtree, config_dir)
with open(os.path.join(config_dir, "test.conf"), "w") as f:
f.write("""
[test]
type=libvirt
sat_server=sat.example.com
""")
config_manager = ConfigManager(self.logger, config_dir)
self.assertEqual(len(config_manager.configs), 1)
config = config_manager.configs[0]
manager = Manager.fromOptions(self.logger, MagicMock(), config)
self.assertTrue(isinstance(manager, Satellite))
self.assertEqual(config.sat_server, 'sat.example.com')
def test_satellite_config_file(self):
config_dir = tempfile.mkdtemp()
self.addCleanup(shutil.rmtree, config_dir)
with open(os.path.join(config_dir, "test.conf"), "w") as f:
f.write("""
[test]
type=libvirt
sat_server=sat.example.com
""")
config_manager = ConfigManager(self.logger, config_dir)
self.assertEqual(len(config_manager.configs), 1)
config = config_manager.configs[0]
manager = Manager.fromOptions(self.logger, MagicMock(), config)
self.assertTrue(isinstance(manager, Satellite))
self.assertEqual(config.sat_server, 'sat.example.com')
def test_satellite_config_env(self):
os.environ = {
"VIRTWHO_SATELLITE": '1',
"VIRTWHO_SATELLITE_SERVER": 'sat.example.com',
"VIRTWHO_SATELLITE_USERNAME": '******',
"VIRTWHO_SATELLITE_PASSWORD": '******',
"VIRTWHO_LIBVIRT": '1'
}
sys.argv = ["virt-who"]
logger, options = parseOptions()
config = Config("env/cmdline",
options.virtType,
defaults={},
**options)
config.checkOptions(logger)
manager = Manager.fromOptions(logger, options, config)
self.assertTrue(isinstance(manager, Satellite))
def test_per_config_options_encrypted(self, can_write):
options = Options(None, None, None)
options.force_register = True
can_write.return_value = True
with tempfile.NamedTemporaryFile() as tmp:
password.Password.KEYFILE = tmp.name
config = Config('test', 'libvirt',
sat_server="http://localhost:%s" % TEST_PORT,
sat_username='******',
sat_encrypted_password=hexlify(password.Password.encrypt('password')))
s = Manager.fromOptions(self.logger, options, config)
self.assertTrue(isinstance(s, Satellite))
report = HostGuestAssociationReport(config, self.mapping)
result = s.hypervisorCheckIn(report, options)
self.assertTrue("failedUpdate" in result)
self.assertTrue("created" in result)
self.assertTrue("updated" in result)
def check_sm_connection(self, config):
errors = []
try:
sm_manager = Manager.fromOptions(self.logger, config, config)
sm_manager._connect(config)
if self.smType == "sat":
if hasattr(sm_manager, 'server_xmlrpc'):
server = 'server_xmlrpc'
else:
server = 'server'
session = getattr(sm_manager, server).auth.login(config.sat_username, config.sat_password)
getattr(sm_manager, server).auth.logout(session)
except Exception as e:
if issubclass(e.__class__, ManagerError) or issubclass(e.__class__, ManagerFatalError) or isinstance(e, ConnectionError):
errors.append(repr(e))
else:
raise e
return errors
def test_per_config_options_encrypted(self, can_write):
options = Options(None, None, None)
options.force_register = True
can_write.return_value = True
with tempfile.NamedTemporaryFile() as tmp:
password.Password.KEYFILE = tmp.name
config = Config('test',
'libvirt',
sat_server="http://localhost:%s" % TEST_PORT,
sat_username='******',
sat_encrypted_password=hexlify(
password.Password.encrypt('password')))
s = Manager.fromOptions(self.logger, options, config)
self.assertTrue(isinstance(s, Satellite))
report = HostGuestAssociationReport(config, self.mapping)
result = s.hypervisorCheckIn(report, options)
self.assertTrue("failedUpdate" in result)
self.assertTrue("created" in result)
self.assertTrue("updated" in result)
def test_hypervisorCheckIn(self, create_from_file, connection):
self.prepare(create_from_file, connection)
config = Config('test', 'libvirt')
config.smType = 'sam'
manager = Manager.fromOptions(self.logger, self.options, config)
self.options.env = "ENV"
self.options.owner = "OWNER"
manager.hypervisorCheckIn(self.host_guest_report, self.options)
manager.connection.hypervisorCheckIn.assert_called_with(
self.options.owner,
self.options.env,
dict(
(
host.hypervisorId,
[
guest.toDict()
for guest in host.guestIds
]
)
for host in self.host_guest_report.association['hypervisors']),
options=self.options)
def test_sm_config_file(self, rhsmconnection):
config_dir = tempfile.mkdtemp()
self.addCleanup(shutil.rmtree, config_dir)
with open(os.path.join(config_dir, "test.conf"), "w") as f:
f.write("""
[test]
type=libvirt
rhsm_hostname=host
rhsm_port=8080
rhsm_prefix=prefix
rhsm_proxy_hostname=proxy_host
rhsm_proxy_port=9090
rhsm_proxy_user=proxy_user
rhsm_proxy_password=proxy_password
rhsm_insecure=1
rhsm_username=user
rhsm_password=passwd
""")
config_manager = ConfigManager(self.logger, config_dir)
self.assertEqual(len(config_manager.configs), 1)
config = config_manager.configs[0]
manager = Manager.fromOptions(self.logger, Mock(), config)
self.assertTrue(isinstance(manager, SubscriptionManager))
self.assertEqual(config.rhsm_hostname, 'host')
self.assertEqual(config.rhsm_port, '8080')
manager._connect(config)
rhsmconnection.assert_called_with(
username='******',
password='******',
host='host',
ssl_port=8080,
handler='prefix',
proxy_hostname='proxy_host',
proxy_port='9090',
proxy_user='******',
proxy_password='******',
insecure='1')
def _sendGuestList(self, report):
manager = Manager.fromOptions(self.logger, self.options, report.config)
manager.sendVirtGuests(report, self.options)
def _sendGuestList(self, report):
manager = Manager.fromOptions(self.logger, self.options, report.config)
manager.sendVirtGuests(report, self.options)
def _sendGuestAssociation(self, report):
manager = Manager.fromOptions(self.logger, self.options, report.config)
manager.hypervisorCheckIn(report, self.options)
def check_report_state(self, report):
''' Check state of one report that is being processed on server. '''
manager = Manager.fromOptions(self.logger, self.options, report.config)
manager.check_report_state(report)
def test_sendVirtGuests(self):
options = MagicMock()
config = Config('test', 'libvirt', sat_server='localhost')
manager = Manager.fromOptions(self.logger, options, config)
self.assertRaises(ManagerError, manager.sendVirtGuests, self.domain_report)
def _sendGuestAssociation(self, report):
manager = Manager.fromOptions(self.logger, self.options, report.config)
manager.hypervisorCheckIn(report, self.options)
def __init__(self, logger, config):
self.logger = logger
self.config = config
self.sm_manager = Manager.fromOptions(logger, config, config)
self.connection = None
def check_report_state(self, report):
''' Check state of one report that is being processed on server. '''
manager = Manager.fromOptions(self.logger, self.options, report.config)
manager.check_report_state(report)
