def test_positive_deploy_configure_by_script(self, form_data, virtwho_config):
""" Verify " hammer virt-who-config fetch"
:id: ef0f1e33-7084-4d0e-95f1-d3080dfbb4cc
:expectedresults: Config can be created, fetch and deploy
:CaseLevel: Integration
:CaseImportance: High
"""
assert virtwho_config['status'] == 'No Report Yet'
script = VirtWhoConfig.fetch({'id': virtwho_config['id']}, output_format='base')
hypervisor_name, guest_name = deploy_configure_by_script(script, debug=True)
virt_who_instance = VirtWhoConfig.info({'id': virtwho_config['id']})[
'general-information'
]['status']
assert virt_who_instance == 'OK'
hosts = [
(hypervisor_name, f'product_id={settings.virtwho.sku_vdc_physical} and type=NORMAL'),
(guest_name, f'product_id={settings.virtwho.sku_vdc_physical} and type=STACK_DERIVED'),
]
for hostname, sku in hosts:
host = Host.list({'search': hostname})[0]
subscriptions = Subscription.list({'organization': DEFAULT_ORG, 'search': sku})
vdc_id = subscriptions[0]['id']
if 'type=STACK_DERIVED' in sku:
for item in subscriptions:
if hypervisor_name.lower() in item['type']:
vdc_id = item['id']
break
result = Host.subscription_attach({'host-id': host['id'], 'subscription-id': vdc_id})
assert 'attached to the host successfully' in '\n'.join(result)
VirtWhoConfig.delete({'name': virtwho_config['name']})
assert not VirtWhoConfig.exists(search=('name', form_data['name']))
def test_positive_deploy_configure_by_script(self, default_org, form_data,
virtwho_config):
"""Verify " hammer virt-who-config fetch"
:id: 6aaffaeb-aaf2-42cf-b0dc-ca41a53d42a6
:expectedresults: Config can be created, fetch and deploy
:CaseLevel: Integration
:CaseImportance: High
"""
assert virtwho_config['status'] == 'No Report Yet'
script = VirtWhoConfig.fetch({'id': virtwho_config['id']},
output_format='base')
hypervisor_name, guest_name = deploy_configure_by_script(
script,
form_data['hypervisor-type'],
debug=True,
org=default_org.label)
virt_who_instance = VirtWhoConfig.info(
{'id': virtwho_config['id']})['general-information']['status']
assert virt_who_instance == 'OK'
hosts = [
(
hypervisor_name,
f'product_id={settings.virtwho.sku.vdc_physical} and type=NORMAL',
),
(
guest_name,
f'product_id={settings.virtwho.sku.vdc_physical} and type=STACK_DERIVED',
),
]
for hostname, sku in hosts:
host = Host.list({'search': hostname})[0]
subscriptions = Subscription.list({
'organization': default_org.name,
'search': sku
})
vdc_id = subscriptions[0]['id']
if 'type=STACK_DERIVED' in sku:
for item in subscriptions:
if hypervisor_name.lower() in item['type']:
vdc_id = item['id']
break
result = Host.subscription_attach({
'host-id': host['id'],
'subscription-id': vdc_id
})
assert result.strip(
) == 'Subscription attached to the host successfully.'
VirtWhoConfig.delete({'name': virtwho_config['name']})
assert not VirtWhoConfig.exists(search=('name', form_data['name']))
def test_positive_deploy_configure_by_script(self):
""" Verify " hammer virt-who-config fetch"
:id: ef0f1e33-7084-4d0e-95f1-d3080dfbb4cc
:expectedresults: Config can be created, fetch and deploy
:CaseLevel: Integration
:CaseImportance: High
"""
name = gen_string('alpha')
args = self._make_virtwho_configure()
args.update({'name': name})
vhd = VirtWhoConfig.create(args)['general-information']
self.assertEqual(vhd['status'], 'No Report Yet')
script = VirtWhoConfig.fetch({'id': vhd['id']}, output_format='plain')
hypervisor_name, guest_name = deploy_configure_by_script(script,
debug=True)
self.assertEqual(
VirtWhoConfig.info({'id':
vhd['id']})['general-information']['status'],
'OK')
hosts = [
(hypervisor_name,
'product_id={} and type=NORMAL'.format(self.vdc_physical)),
(guest_name,
'product_id={} and type=STACK_DERIVED'.format(self.vdc_physical))
]
for hostname, sku in hosts:
host = Host.list({'search': hostname})[0]
subscriptions = Subscription.list({
'organization': DEFAULT_ORG,
'search': sku,
})
vdc_id = subscriptions[0]['id']
if 'type=STACK_DERIVED' in sku:
for item in subscriptions:
if hypervisor_name.lower() in item['type']:
vdc_id = item['id']
break
result = Host.subscription_attach({
'host-id': host['id'],
'subscription-id': vdc_id
})
self.assertTrue(
'attached to the host successfully' in '\n'.join(result))
VirtWhoConfig.delete({'name': name})
self.assertFalse(VirtWhoConfig.exists(search=('name', name)))
def virt_who_hypervisor_config(
self,
config_id,
org_id=None,
lce_id=None,
hypervisor_hostname=None,
configure_ssh=False,
hypervisor_user=None,
subscription_name=None,
exec_one_shot=False,
upload_manifest=True,
extra_repos=None,
):
"""
Configure virtual machine as hypervisor virt-who service
:param int config_id: virt-who config id
:param int org_id: the organization id
:param int lce_id: the lifecycle environment id to use
:param str hypervisor_hostname: the hypervisor hostname
:param str hypervisor_user: hypervisor user that connect with the ssh key
:param bool configure_ssh: configure the ssh key to allow host to connect to hypervisor
:param str subscription_name: the subscription name to assign to virt-who hypervisor guests
:param bool exec_one_shot: whether to run the virt-who one-shot command after startup
:param bool upload_manifest: whether to upload the organization manifest
:param list extra_repos: (Optional) repositories dict options to setup additionally.
"""
from robottelo.cli.org import Org
from robottelo.cli import factory as cli_factory
from robottelo.cli.lifecycleenvironment import LifecycleEnvironment
from robottelo.cli.subscription import Subscription
from robottelo.cli.virt_who_config import VirtWhoConfig
org = cli_factory.make_org() if org_id is None else Org.info(
{'id': org_id})
if lce_id is None:
lce = cli_factory.make_lifecycle_environment(
{'organization-id': org['id']})
else:
lce = LifecycleEnvironment.info({
'id': lce_id,
'organization-id': org['id']
})
extra_repos = extra_repos or []
repos = [
# Red Hat Satellite Tools
{
'product': constants.PRDS['rhel'],
'repository-set': constants.REPOSET['rhst7'],
'repository': constants.REPOS['rhst7']['name'],
'repository-id': constants.REPOS['rhst7']['id'],
'url': settings.sattools_repo['rhel7'],
'cdn': bool(settings.cdn
or not settings.sattools_repo['rhel7']),
}
]
repos.extend(extra_repos)
content_setup_data = cli_factory.setup_cdn_and_custom_repos_content(
org['id'],
lce['id'],
repos,
upload_manifest=upload_manifest,
rh_subscriptions=[constants.DEFAULT_SUBSCRIPTION_NAME],
)
activation_key = content_setup_data['activation_key']
content_view = content_setup_data['content_view']
self.contenthost_setup(
org_label=org['label'],
activation_key=activation_key['name'],
patch_os_release_distro=constants.DISTRO_RHEL7,
rh_repo_ids=[
repo['repository-id'] for repo in repos if repo['cdn']
],
install_katello_agent=False,
)
# configure manually RHEL custom repo url as sync time is very big
# (more than 2 hours for RHEL 7Server) and not critical in this context.
rhel_repo_option_name = (
f'rhel{constants.DISTROS_MAJOR_VERSION[constants.DISTRO_RHEL7]}_repo'
)
rhel_repo_url = getattr(settings.repos, rhel_repo_option_name, None)
if not rhel_repo_url:
raise ValueError(
f'Settings option "{rhel_repo_option_name}" is whether not set or does not exist'
)
self.configure_rhel_repo(rhel_repo_url)
if hypervisor_hostname and configure_ssh:
# configure ssh access of hypervisor from self
hypervisor_ssh_key_name = f'hypervisor-{gen_alpha().lower()}.key'
# upload the ssh key
self.put_ssh_key(settings.server.ssh_key, hypervisor_ssh_key_name)
# setup the ssh config and known_hosts files
self.update_known_hosts(self,
hypervisor_ssh_key_name,
hypervisor_hostname,
user=hypervisor_user)
# upload the virt-who config deployment script
virt_who_deploy_directory = '/root/virt_who_deploy_output'
virt_who_deploy_filename = f'{gen_alpha(length=5)}-virt-who-deploy-{config_id}'
virt_who_deploy_file = f'{virt_who_deploy_directory}/{virt_who_deploy_filename}'
VirtWhoConfig.fetch({'id': config_id, 'output': virt_who_deploy_file})
# remote_copy from satellite to self
satellite = Satellite(settings.server.hostname)
satellite.session.remote_copy(virt_who_deploy_file, self)
# ensure the virt-who config deploy script is executable
result = self.run(f'chmod +x {virt_who_deploy_file}')
if result.status != 0:
raise CLIFactoryError(
f'Failed to set deployment script as executable:\n{result.stderr}'
)
# execute the deployment script
result = self.run(f'{virt_who_deploy_file}')
if result.status != 0:
raise CLIFactoryError(
f'Deployment script failure:\n{result.stderr}')
# after this step, we should have virt-who service installed and started
if exec_one_shot:
# usually to be sure that the virt-who generated the report we need
# to force a one shot report, for this we have to stop the virt-who
# service
result = self.run('service virt-who stop')
if result.status != 0:
raise CLIFactoryError(
f'Failed to stop the virt-who service:\n{result.stderr}')
result = self.run('virt-who --one-shot', timeout=900)
if result.status != 0:
raise CLIFactoryError(
f'Failed when executing virt-who --one-shot:\n{result.stderr}'
)
result = self.run('service virt-who start')
if result.status != 0:
raise CLIFactoryError(
f'Failed to start the virt-who service:\n{result.stderr}')
# after this step the hypervisor as a content host should be created
# do not confuse virt-who host with hypervisor host as they can be
# diffrent hosts and as per this setup we have only registered the virt-who
# host, the hypervisor host should registered after virt-who send the
# first report when started or with one shot command
# the virt-who hypervisor will be registered to satellite with host name
# like "virt-who-{hypervisor_hostname}-{organization_id}"
virt_who_hypervisor_hostname = f'virt-who-{hypervisor_hostname}-{org["id"]}'
# find the registered virt-who hypervisor host
org_hosts = Host.list({
'organization-id': org['id'],
'search': f'name={virt_who_hypervisor_hostname}'
})
# Note: if one shot command was executed the report is immediately
# generated, and the server must have already registered the virt-who
# hypervisor host
if not org_hosts and not exec_one_shot:
# we have to wait until the first report was sent.
# the report is generated after the virt-who service startup, but some
# small delay can occur.
max_time = time.time() + 60
while time.time() <= max_time:
time.sleep(5)
org_hosts = Host.list({
'organization-id':
org['id'],
'search':
f'name={virt_who_hypervisor_hostname}',
})
if org_hosts:
break
if len(org_hosts) == 0:
raise CLIFactoryError(
f'Failed to find hypervisor host:\n{result.stderr}')
virt_who_hypervisor_host = org_hosts[0]
subscription_id = None
if hypervisor_hostname and subscription_name:
subscriptions = Subscription.list({'organization-id': org_id},
per_page=False)
for subscription in subscriptions:
if subscription['name'] == subscription_name:
subscription_id = subscription['id']
Host.subscription_attach({
'host': virt_who_hypervisor_hostname,
'subscription-id': subscription_id
})
break
return {
'subscription_id': subscription_id,
'subscription_name': subscription_name,
'activation_key_id': activation_key['id'],
'organization_id': org['id'],
'content_view_id': content_view['id'],
'lifecycle_environment_id': lce['id'],
'virt_who_hypervisor_host': virt_who_hypervisor_host,
}
