def test_hypervisorCheckIn(self, server):
options = MagicMock()
server.return_value.registration.new_system_user_pass.return_value = {
'system_id': '123'
}
config, d = self.create_fake_config('test', **self.default_config_args)
manager = Manager.from_config(self.logger, config)
self.host_guest_report._config = config
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 _create_destinations(self):
"""Populate self.destinations with a list of list with them
@param reset: Whether to kill existing destinations or not, defaults
to false
@type: bool
"""
dests = []
for info in self.dest_to_source_mapper.dests:
# Dests should already include all destinations we want created
# at this time. This method will make no assumptions of creating
# defaults of any kind.
source_keys = self.dest_to_source_mapper.dest_to_sources_map[info]
info.name = "destination_%s" % hash(info)
logger = log.getLogger(name=info.name)
manager = Manager.fromInfo(logger, self.options, info)
dest_class = info_to_destination_class[type(info)]
dest = dest_class(config=info, logger=logger,
source_keys=source_keys,
options=self.options,
source=self.datastore, dest=manager,
terminate_event=self.terminate_event,
interval=self.options[VW_GLOBAL]['interval'],
oneshot=self.options[VW_GLOBAL]['oneshot'])
dests.append(dest)
return dests
def test_satellite_config_file(self):
# Username and password are required for a valid sat5 destination
with open(os.path.join(self.config_dir, "test.conf"), "w") as f:
f.write("""
[test]
type=libvirt
sat_server=sat.example.com
sat_username=sat_username
sat_password=sat_password
""")
conf = parse_file(os.path.join(self.config_dir, "test.conf"))
effective_config = EffectiveConfig()
conf_values = conf.pop("test")
effective_config["test"] = ConfigSection.from_dict(
conf_values,
"test",
effective_config
)
config_manager = DestinationToSourceMapper(effective_config)
self.assertEqual(len(config_manager.configs), 1)
# There should only be one destination detected
self.assertEqual(len(config_manager.dests), 1)
# Which should be a Satellite5DestinationInfo
dest_info = config_manager.dests.pop()
self.assertTrue(isinstance(dest_info, Satellite5DestinationInfo), 'The destination info '
'we got was not of the '
'expected type')
manager = Manager.fromInfo(self.logger, effective_config, dest_info)
self.assertTrue(isinstance(manager, Satellite))
self.assertEqual(dest_info.sat_server, 'sat.example.com')
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_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_per_config_options_encrypted(self, can_write):
options = Mock()
options.force_register = True
can_write.return_value = True
with tempfile.NamedTemporaryFile() as tmp:
password.Password.KEYFILE = tmp.name
config_dict = {
"sat_server":
"http://localhost:%s" % TEST_PORT,
"sat_username":
"******",
"sat_encrypted_password":
hexlify(password.Password.encrypt('password')),
"type":
"libvirt",
}
config = VirtConfigSection.from_dict(config_dict, 'test', None)
config.validate()
dests = DestinationToSourceMapper.parse_dests_from_dict(
config._values)
self.assertEqual(len(dests), 1)
dest_info = dests.pop()
s = Manager.fromInfo(self.logger, options, dest_info)
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 _create_destinations(self):
"""Populate self.destinations with a list of list with them
@param reset: Whether to kill existing destinations or not, defaults
to false
@type: bool
"""
dests = []
for info in self.dest_to_source_mapper.dests:
# Dests should already include all destinations we want created
# at this time. This method will make no assumptions of creating
# defaults of any kind.
source_keys = self.dest_to_source_mapper.dest_to_sources_map[info]
info.name = "destination_%s" % hash(info)
logger = log.getLogger(name=info.name)
manager = Manager.fromInfo(logger, self.options, info)
dest_class = info_to_destination_class[type(info)]
dest = dest_class(config=info,
logger=logger,
source_keys=source_keys,
options=self.options,
source=self.datastore,
dest=manager,
terminate_event=self.terminate_event,
interval=self.options[VW_GLOBAL]['interval'],
oneshot=self.options[VW_GLOBAL]['oneshot'],
status=self.options[VW_GLOBAL]['status'])
dests.append(dest)
return dests
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 = VirtConfigSection.from_dict({'type': 'libvirt', 'sm_type': 'sam'}, 'test', None)
manager = Manager.from_config(self.logger, 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_cmd(self):
os.environ = {}
sys.argv = ["virt-who", "--sam", "--libvirt"]
logger, effective_config = parse_options()
config_manager = DestinationToSourceMapper(effective_config)
self.assertEqual(len(config_manager.configs), 1)
config = dict(config_manager.configs)[VW_ENV_CLI_SECTION_NAME]
manager = Manager.from_config(self.logger, config)
self.assertTrue(isinstance(manager, SubscriptionManager))
def test_sm_config_env(self):
os.environ = {
"VIRTWHO_SAM": '1',
"VIRTWHO_LIBVIRT": '1'
}
sys.argv = ["virt-who"]
logger, config = parse_options()
manager = Manager.from_config(logger, config)
self.assertTrue(isinstance(manager, SubscriptionManager))
def test_sm_config_cmd(self):
os.environ = {}
sys.argv = ["virt-who", "--sam", "--libvirt"]
logger, effective_config = parse_options()
config_manager = DestinationToSourceMapper(effective_config)
self.assertEqual(len(config_manager.configs), 1)
config = dict(config_manager.configs)[VW_ENV_CLI_SECTION_NAME]
manager = Manager.from_config(self.logger, config)
self.assertTrue(isinstance(manager, SubscriptionManager))
def test_sendVirtGuests(self):
config = VirtConfigSection.from_dict(
{
'type': 'libvirt',
'sat_server': 'localhost'
}, 'test', None)
manager = Manager.from_config(self.logger, config)
self.assertRaises(ManagerError, manager.sendVirtGuests,
self.domain_report)
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_sendVirtGuests(self, create_from_file, connection):
self.prepare(create_from_file, connection)
config, d = self.create_fake_config('test', **self.default_config_args)
manager = Manager.from_config(self.logger, config)
self.domain_report._config = 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_sendVirtGuests(self, create_from_file, connection):
self.prepare(create_from_file, connection)
config = VirtConfigSection.from_dict(
{
'type': 'libvirt',
'sm_type': 'sam'
}, 'test', None)
manager = Manager.from_config(self.logger, 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_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_hypervisorCheckIn(self, create_from_file, connection):
self.prepare(create_from_file, connection)
config, d = self.create_fake_config('test', **self.default_config_args)
d['owner'] = 'OWNER'
manager = Manager.from_config(self.logger, config)
# TODO additional mocking. Specifically, mock out the host_guest_report and config...
self.host_guest_report._config = config
manager.hypervisorCheckIn(self.host_guest_report)
manager.connection.hypervisorCheckIn.assert_called_with(
d['owner'],
'',
dict(
(host.hypervisorId,
[guest.toDict() for guest in host.guestIds])
for host in self.host_guest_report.association['hypervisors']),
options=ANY)
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_cmd(self):
os.environ = {}
sys.argv = ["virt-who", "--satellite",
"--satellite-server=sat.example.com",
"--satellite-username=username",
"--satellite-password=password",
"--libvirt"]
logger, effective_config = parse_options()
config_manager = DestinationToSourceMapper(effective_config)
# Again there should only be one config parsed out (and one dest)
self.assertEqual(len(config_manager.configs), 1)
self.assertEqual(len(config_manager.dests), 1)
dest_info = config_manager.dests.pop()
self.assertTrue(isinstance(dest_info, Satellite5DestinationInfo))
manager = Manager.fromInfo(self.logger, effective_config, dest_info)
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_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_sm_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
owner=owner
env=env
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
rhsm_no_proxy=filter
""")
config_manager = DestinationToSourceMapper(
init_config({}, {}, config_dir=config_dir))
self.assertEqual(len(config_manager.configs), 1)
config = dict(config_manager.configs)["test"]
manager = Manager.from_config(self.logger, config)
self.assertTrue(isinstance(manager, SubscriptionManager))
self.assertEqual(config['rhsm_hostname'], 'host')
self.assertEqual(config['rhsm_port'], '8080')
manager._connect(config)
self.sm.connection.assert_called_with(
username='******',
password='******',
host='host',
ssl_port=8080,
handler='prefix',
proxy_hostname='proxy_host',
proxy_port='9090',
proxy_user='******',
proxy_password='******',
no_proxy='filter',
insecure='1',
correlation_id=manager.correlation_id)
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, effective_config = parse_options()
config_manager = DestinationToSourceMapper(effective_config)
# Again there should only be one config parsed out (and one dest)
self.assertEqual(len(config_manager.configs), 1)
self.assertEqual(len(config_manager.dests), 1)
dest_info = config_manager.dests.pop()
self.assertTrue(isinstance(dest_info, Satellite5DestinationInfo))
manager = Manager.fromInfo(self.logger, effective_config, dest_info)
self.assertTrue(isinstance(manager, Satellite))
def test_sm_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
owner=owner
env=env
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
rhsm_no_proxy=filter
""")
config_manager = DestinationToSourceMapper(init_config({}, {}, config_dir=config_dir))
self.assertEqual(len(config_manager.configs), 1)
config = dict(config_manager.configs)["test"]
manager = Manager.from_config(self.logger, config)
self.assertTrue(isinstance(manager, SubscriptionManager))
self.assertEqual(config['rhsm_hostname'], 'host')
self.assertEqual(config['rhsm_port'], '8080')
manager._connect(config)
self.sm.connection.assert_called_with(
username='******',
password='******',
host='host',
ssl_port=8080,
handler='prefix',
proxy_hostname='proxy_host',
proxy_port='9090',
proxy_user='******',
proxy_password='******',
no_proxy='filter',
insecure='1',
correlation_id=manager.correlation_id)
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_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_hypervisorCheckIn(self, create_from_file, connection):
self.prepare(create_from_file, connection)
config, d = self.create_fake_config('test', **self.default_config_args)
d['owner'] = 'OWNER'
manager = Manager.from_config(self.logger, config)
# TODO additional mocking. Specifically, mock out the host_guest_report and config...
self.host_guest_report._config = config
manager.hypervisorCheckIn(self.host_guest_report)
manager.connection.hypervisorCheckIn.assert_called_with(
d['owner'],
'',
dict(
(
host.hypervisorId,
[
guest.toDict()
for guest in host.guestIds
]
)
for host in self.host_guest_report.association['hypervisors']),
options=ANY)
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 test_per_config_options_encrypted(self, can_write):
options = Mock()
options.force_register = True
can_write.return_value = True
with tempfile.NamedTemporaryFile() as tmp:
password.Password.KEYFILE = tmp.name
config_dict = {
"sat_server": "http://localhost:%s" % TEST_PORT,
"sat_username": "******",
"sat_encrypted_password": hexlify(password.Password.encrypt('password')),
"type": "libvirt",
}
config = VirtConfigSection.from_dict(config_dict, 'test', None)
config.validate()
dests = DestinationToSourceMapper.parse_dests_from_dict(config._values)
self.assertEqual(len(dests), 1)
dest_info = dests.pop()
s = Manager.fromInfo(self.logger, options, dest_info)
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 __init__(self, logger, config):
self.logger = logger
self.config = config
self.sm_manager = Manager.fromOptions(logger, config, config)
self.connection = None
def test_sm_config_env(self):
os.environ = {"VIRTWHO_SAM": '1', "VIRTWHO_LIBVIRT": '1'}
sys.argv = ["virt-who"]
logger, config = parse_options()
manager = Manager.from_config(logger, config)
self.assertTrue(isinstance(manager, SubscriptionManager))
def _sendGuestAssociation(self, report):
manager = Manager.fromOptions(self.logger, self.options, report.config)
manager.hypervisorCheckIn(report, self.options)
def _sendGuestList(self, report):
manager = Manager.fromOptions(self.logger, self.options, report.config)
manager.sendVirtGuests(report, self.options)
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 _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):
config = VirtConfigSection.from_dict({'type': 'libvirt', 'sat_server': 'localhost'}, 'test', None)
manager = Manager.from_config(self.logger, config)
self.assertRaises(ManagerError, manager.sendVirtGuests, self.domain_report)
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)
