def update_product_subscription_in_ak(product, yum_repo, ak, org):
""" Updates given products subscription in given AK
:param str product: products name to calcualte subscription id
:param nailgun.entity.Repository yum_repo: yum repository
:param nailgun.entity.ActivationKey ak: Ak
:param nailgun.entity.Organization org: Organization
"""
cv_from_ak = ak.content_view
cv = cv_from_ak.read()
cv.repository.append(yum_repo)
cv = cv.update(['repository'])
cv.publish()
cv = cv.read() # Published CV with new version
# Promote CV
environment = entities.ActivationKey(organization=org).search(
query={'search': 'name={}'.format(ak.name)}
)[0].environment
cvv = entities.ContentViewVersion(
id=max([cvv.id for cvv in cv.version])
).read()
cvv.promote(
data={
u'environment_id': environment.id,
u'force': False
}
)
subscription = entities.Subscription(organization=org).search(query={
'search': 'name={}'.format(product.name)
})[0]
ak.add_subscriptions(data={
'subscription_id': subscription.id})
def test_post_version_cv_export_import(
self, request, set_importing_org, dependent_scenario_name, default_sat
):
"""After upgrade, content view version import and export works on the existing content
view(that we created before the upgrade).
:id: postupgrade-f19e4928-94db-4df6-8ce8-b5e4afe34258
:parametrized: yes
:steps:
1: Export the existing content-view version.
2: Import the existing content-view version.
3: Delete the imported and exported content-vew, product, repo and organization.
:expectedresults: After upgrade,
1: Content view created before upgrade should be imported and exported successfully.
2: Imported and Exported content view should be deleted successfully
"""
pre_test_name = dependent_scenario_name
export_base = '/var/lib/pulp/katello-export/'
org = entities.Organization().search(query={'search': f'name="{pre_test_name}_org"'})[0]
request.addfinalizer(org.delete)
product = entities.Product(organization=org).search(
query={'search': f'name="{pre_test_name}_prod"'}
)[0]
request.addfinalizer(product.delete)
exporting_cv = entities.ContentView(organization=org).search(
query={'search': f'name="{pre_test_name}_cv"'}
)[0]
request.addfinalizer(exporting_cv.delete)
exporting_cvv_id = max(cvv.id for cvv in exporting_cv.version)
exporting_cvv_version = entities.ContentViewVersion(id=exporting_cvv_id).read().version
ContentView.version_export({'export-dir': f'{export_base}', 'id': exporting_cvv_id})
exported_tar = f'{export_base}/export-{exporting_cv.name}-{exporting_cvv_version}.tar'
result = default_sat.execute(f'[ -f {exported_tar} ]')
assert result.status == 0
exported_packages = Package.list({'content-view-version-id': exporting_cvv_id})
assert len(exported_packages) > 0
importing_cv, importing_org = set_importing_org
ContentView.version_import(
{'export-tar': f'{exported_tar}', 'organization-id': importing_org.id}
)
importing_cvv = importing_cv.read().version
assert len(importing_cvv) == 1
imported_packages = Package.list({'content-view-version-id': importing_cvv[0].id})
assert len(imported_packages) > 0
assert len(exported_packages) == len(imported_packages)
default_sat.execute(f'rm -rf {export_base}/*')
exporting_cv_json = exporting_cv.read_json()
importing_cv_json = importing_cv.read_json()
exporting_cv_env_id = exporting_cv_json['environments'][0]['id']
importing_cv_env_id = importing_cv_json['environments'][0]['id']
assert exporting_cv.delete_from_environment(exporting_cv_env_id)
assert importing_cv.delete_from_environment(importing_cv_env_id)
def test_pre_scenario_preclient_package_installation(self):
"""Create product and repo from which the package will be installed
post upgrade
:id: preupgrade-eedab638-fdc9-41fa-bc81-75dd2790f7be
:steps:
1. Create a content host with existing client ak
2. Create and sync repo from which the package will be
installed on content host
3. Add repo to CV and then in Activation key
:expectedresults:
1. The content host is created
2. The new repo and its product has been added to ak using which
the content host is created
"""
rhel7_client = dockerize(distro='rhel7')
product = entities.Product(
name='preclient_scenario_product',
organization=1,
).create()
yum_repo = entities.Repository(
name='preclient_scenario_repo', product=product
).create()
yum_repo.sync()
self.cv.repository = [yum_repo]
cv = self.cv.update(['repository'])
cv.publish()
cv = cv.read() # Published CV with new version
# Promote CV
environment = entities.ActivationKey().search(
query={'search': 'name={}'.format(self.ak)}
)[0].environment
cvv = entities.ContentViewVersion(
id=max([cvv.id for cvv in cv.version])
).read()
cvv.promote(
data={
u'environment_id': environment.id,
u'force': False
}
)
create_dict(
{self.__class__.__name__: rhel7_client}
)
def test_post_version_cv_export_import(self):
"""Export and Import cv version created before upgrade
:id: postupgrade-f19e4928-94db-4df6-8ce8-b5e4afe34258
:steps: Export and Import the Content Views version created before upgrade
:expectedresults: Content-view created before upgrade should be exported and imported
after upgrade
"""
prescene_dict = get_entity_data(self.__class__.__name__)
exporting_cv = entities.ContentView(
organization=prescene_dict['exporting_orgid']).search(query={
'search':
'name={}'.format(prescene_dict['exporting_cvname'])
})[0]
exporting_cvv_id = max([cvv.id for cvv in exporting_cv.version])
exporting_cvv_version = entities.ContentViewVersion(
id=exporting_cvv_id).read().version
ContentView.version_export({
'export-dir': '{}'.format(self.export_base),
'id': exporting_cvv_id
})
exported_tar = '{0}/export-{1}-{2}.tar'.format(self.export_base,
exporting_cv.name,
exporting_cvv_version)
result = ssh.command("[ -f {0} ]".format(exported_tar))
self.assertEqual(result.return_code, 0)
exported_packages = Package.list(
{'content-view-version-id': exporting_cvv_id})
self.assertTrue(len(exported_packages) > 0)
self.set_importing_org(
prescene_dict['exporting_prodname'],
prescene_dict['exporting_reponame'],
exporting_cv.name,
)
ContentView.version_import({
'export-tar': exported_tar,
'organization-id': self.importing_org.id
})
importing_cvv = self.importing_cv.read().version
self.assertTrue(len(importing_cvv) == 1)
imported_packages = Package.list(
{'content-view-version-id': importing_cvv[0].id})
self.assertTrue(len(imported_packages) > 0)
self.assertEqual(len(exported_packages), len(imported_packages))
self.tearDownScenario()
def test_positive_noapply_api(self):
"""Check if api incremental update can be done without
actually applying it
:id: 481c5ff2-801f-4eff-b1e0-95ea5bb37f95
:Setup: The prerequisites are already covered in the setUpClass() but
for easy debug, get the content view id, Repository id and
Lifecycle environment id using hammer and plug these statements on
the top of the test. For example::
self.rhel_6_partial_cv = ContentView(id=38).read()
self.rhva_6_repo = Repository(id=164).read()
self.qe_lce = LifecycleEnvironment(id=46).read()
:expectedresults: Incremental update completed with no errors and
Content view has a newer version
:CaseLevel: System
"""
# Get the content view versions and use the recent one. API always
# returns the versions in ascending order so it is safe to assume the
# last one in the list is the recent
cv_versions = self.rhel_6_partial_cv.version
# Get the applicable errata
errata_list = self.get_applicable_errata(self.rhva_6_repo)
self.assertGreater(len(errata_list), 0)
# Apply incremental update using the first applicable errata
entities.ContentViewVersion().incremental_update(
data={
'content_view_version_environments': [{
'content_view_version_id':
cv_versions[-1].id,
'environment_ids': [self.qe_lce.id]
}],
'add_content': {
'errata_ids': [errata_list[0].id]
}
})
# Re-read the content view to get the latest versions
self.rhel_6_partial_cv = self.rhel_6_partial_cv.read()
self.assertGreater(len(self.rhel_6_partial_cv.version),
len(cv_versions))
def test_positive_noapply_api(module_manifest_org, module_cv, custom_repo,
host, dev_lce):
"""Check if api incremental update can be done without
actually applying it
:id: 481c5ff2-801f-4eff-b1e0-95ea5bb37f95
:Setup: get the content view id, Repository id and
Lifecycle environment id
:expectedresults: Incremental update completed with no errors and
Content view has a newer version
:parametrized: yes
:CaseLevel: System
"""
# Promote CV to new LCE
versions = sorted(module_cv.read().version, key=lambda ver: ver.id)
cvv = versions[-1].read()
promote(cvv, dev_lce.id)
# Read CV to pick up LCE ID and next_version
module_cv = module_cv.read()
# Get the content view versions and use the recent one. API always
# returns the versions in ascending order (last in the list is most recent)
cv_versions = module_cv.version
# Get the applicable errata
errata_list = get_applicable_errata(custom_repo)
assert len(errata_list) > 0
# Apply incremental update using the first applicable errata
entities.ContentViewVersion().incremental_update(
data={
'content_view_version_environments': [{
'content_view_version_id':
cv_versions[-1].id,
'environment_ids': [dev_lce.id],
}],
'add_content': {
'errata_ids': [errata_list[0].id]
},
})
# Re-read the content view to get the latest versions
module_cv = module_cv.read()
assert len(module_cv.version) > len(cv_versions)
def create_activation_key_for_client_registration(
ak_name, client_os, org, environment, sat_state):
"""Creates Activation key for client registration
:param str ak_name: Activation key name
:param str client_os: rhel6/rhel7
:param nailgun.entity.Organization org: Organization
:param nailgun.entity.Environment environment: Environment
:param str sat_state: pre or post
:return nailgun.entity: Activation key
"""
client_os = client_os.upper()
from_ver = os.environ.get('FROM_VERSION')
rhel_prod_name = 'scenarios_rhel{}_prod'.format(client_os[-1])
rhel_repo_name = '{}_repo'.format(rhel_prod_name)
rhel_url = os.environ.get('{}_CUSTOM_REPO'.format(client_os))
if rhel_url is None:
raise ValueError('The RHEL Repo URL environment variable for OS {} '
'is not provided!'.format(client_os))
rhel_prod = entities.Product(
name=rhel_prod_name, organization=org.id).create()
if sat_state.lower() == 'pre' and from_ver in ['6.1', '6.2']:
rhel_repo = entities.Repository(
name=rhel_repo_name,
product=rhel_prod,
url=rhel_url,
content_type='yum'
).create()
else:
rhel_repo = entities.Repository(
name=rhel_repo_name,
product=rhel_prod,
url=rhel_url,
content_type='yum',
verify_ssl_on_sync=False
).create()
call_entity_method_with_timeout(rhel_repo.sync, timeout=1400)
if sat_state.lower() == 'pre':
product_name = 'Red Hat Enterprise Linux Server'
repo_name = 'Red Hat Satellite Tools {0} for RHEL ' \
'{1} Server RPMs x86_64'.format(from_ver, client_os[-1])
tools_prod = entities.Product(
organization=org.id
).search(
query={
'per_page': 1000,
'search': 'name="{}"'.format(product_name)
}
)[0]
tools_repo = entities.Repository(
organization=org.id, product=tools_prod
).search(
query={
'per_page': 1000,
'search': 'name="{}"'.format(repo_name)
}
)[0]
elif sat_state.lower() == 'post':
product_name = 'scenarios_tools_product'
tools_repo_url = os.environ.get(
'TOOLS_URL_{}'.format(client_os.upper()))
if tools_repo_url is None:
raise ValueError('The Tools Repo URL environment variable for '
'OS {} is not provided!'.format(client_os))
repo_name = '{}_repo'.format(product_name)
tools_prod = entities.Product(
organization=org.id
).search(query={'search': 'name={}'.format(product_name)})
if not tools_prod:
tools_prod = entities.Product(
name=product_name, organization=org.id).create()
tools_repo = entities.Repository(
name=repo_name,
product=tools_prod,
url=tools_repo_url,
content_type='yum'
).create()
tools_repo.sync()
else:
tools_repo = entities.Repository(
organization=org.id, product=tools_prod
).search(query={'search': 'name={}'.format(repo_name)})
tools_cv = entities.ContentView(
name=ak_name + '_cv',
label=ak_name + '_cv',
organization=org.id
).create()
tools_cv.repository = [tools_repo, rhel_repo]
tools_cv = tools_cv.update(['repository'])
tools_cv.publish()
tools_cv = tools_cv.read() # Published CV with new version
# Promote CV
cvv = entities.ContentViewVersion(
id=max([cvv.id for cvv in tools_cv.version])
).read()
cvv.promote(
data={
u'environment_id': environment.id,
u'force': False
}
)
tools_ak = entities.ActivationKey(
name=ak_name,
content_view=tools_cv,
organization=org.id,
environment=environment
).create()
if sat_state == 'pre':
tools_sub = 'Red Hat Satellite Employee Subscription'
tools_content = 'rhel-{0}-server-satellite-tools-{1}-rpms'.format(
client_os[-1], from_ver)
else:
tools_sub = tools_prod.name
tools_subscription = entities.Subscription(organization=org.id).search(
query={
'search': 'name="{}"'.format(tools_sub),
'per_page': 1000
}
)[0]
rhel_subscription = entities.Subscription(organization=org.id).search(
query={
'search': 'name={}'.format(rhel_prod.name),
'per_page': 1000
}
)[0]
tools_ak.add_subscriptions(data={
'subscription_id': tools_subscription.id})
if sat_state == 'pre':
tools_ak.content_override(data={
'content_override':
{
u'content_label': tools_content,
u'value': u'1'
}}
)
tools_ak.add_subscriptions(data={
'subscription_id': rhel_subscription.id})
return tools_ak
def sync_capsule_repos_to_upgrade(capsules):
"""This syncs capsule repo in Satellite server and also attaches
the capsule repo subscription to each capsule
:param list capsules: The list of capsule hostnames to which new capsule
repo subscription will be attached
Following environment variable affects this function:
CAPSULE_URL
The url for capsule repo from latest satellite compose.
If not provided, capsule repo from Red Hat repositories will be enabled
TOOLS_URL_RHEL{}.format(os_ver)
The url for capsuletools repo from latest satellite compose.
If not provided, capsule repo from Red Hat repositories will be enabled
FROM_VERSION
Current Satellite version - to differentiate default organization.
e.g. '6.1', '6.0'
TO_VERSION
Upgradable Satellite version - To enable capsule repo
e.g '6.1', '6.2'
OS
OS version to enable next version capsule repo
e.g 'rhel7', 'rhel6'
Personal Upgrade Env Vars:
CAPSULE_AK
The AK name used in capsule subscription
RHEV upgrade Env Vars:
RHEV_CAPSULE_AK
The AK name used in capsule subscription
"""
to_version = os.environ.get('TO_VERSION')
logger.info('Syncing latest capsule repos in Satellite ...')
os_ver = os.environ.get('OS')[-1]
capsule_repo = os.environ.get('CAPSULE_URL')
capsuletools_url = os.environ.get('TOOLS_URL_RHEL{}'.format(os_ver))
ak_name = os.environ.get('CAPSULE_AK', os.environ.get('RHEV_CAPSULE_AK'))
if ak_name is None:
logger.warning(
'The AK name is not provided for Capsule upgrade! Aborting...')
sys.exit(1)
org = entities.Organization(id=1).read()
ak = entities.ActivationKey(organization=org).search(
query={'search': 'name={}'.format(ak_name)})[0]
cv = ak.content_view.read()
lenv = ak.environment.read()
# Fix dead pulp tasks
if os_ver == '6':
run('for i in pulp_resource_manager pulp_workers pulp_celerybeat; '
'do service $i restart; done')
_sync_capsule_subscription_to_capsule_ak(ak)
if float(to_version) >= 6.3:
_add_additional_subscription_for_capsule(ak, capsuletools_url)
# Publishing and promoting the CV with all newly added capsule, capsuletools, rhscl and
# server repos combine
call_entity_method_with_timeout(cv.read().publish, timeout=2000)
published_ver = entities.ContentViewVersion(
id=max([cv_ver.id for cv_ver in cv.read().version])).read()
published_ver.promote(data={'environment_id': lenv.id, 'force': False})
# Add capsule and tools custom prod subscription to capsules
if capsule_repo:
add_custom_product_subscription_to_hosts(
customcontents['capsule']['prod'], capsules)
if float(to_version) >= 6.3:
if capsuletools_url:
add_custom_product_subscription_to_hosts(
customcontents['capsule_tools']['prod'], capsules)
def sync_tools_repos_to_upgrade(client_os, hosts):
"""This syncs tools repo in Satellite server and also attaches
the new tools repo subscription onto each client
:param string client_os: The client OS of which tools repo to be synced
e.g: rhel6, rhel7
:param list hosts: The list of capsule hostnames to which new capsule
repo subscription will be attached
Following environment variable affects this function:
TOOLS_URL_{client_os}
The url of tools repo from latest satellite compose.
FROM_VERSION
Current Satellite version - to differentiate default organization.
e.g. '6.1', '6.0'
Personal Upgrade Env Vars:
CLIENT_AK
The ak_name attached to subscription of client
Rhevm upgrade Env Vars:
RHEV_CLIENT_AK
The AK name used in client subscription
"""
client_os = client_os.upper()
tools_repo_url = os.environ.get('TOOLS_URL_{}'.format(client_os))
if tools_repo_url is None:
logger.warning('The Tools Repo URL for {} is not provided '
'to perform Client Upgrade !'.format(client_os))
sys.exit(1)
ak_name = os.environ.get(
'CLIENT_AK_{}'.format(client_os),
os.environ.get('RHEV_CLIENT_AK_{}'.format(client_os)))
if ak_name is None:
logger.warning('The AK details are not provided for {0} Client '
'upgrade!'.format(client_os))
sys.exit(1)
org = entities.Organization().search(
query={'search': 'name="{}"'.format("Default Organization")})[0]
ak = entities.ActivationKey(organization=org).search(
query={'search': 'name={}'.format(ak_name)})[0]
cv = ak.content_view.read()
lenv = ak.environment.read()
toolsproduct_name = customcontents['tools']['prod'].format(
client_os=client_os)
toolsrepo_name = customcontents['tools']['repo'].format(
client_os=client_os)
# adding sleeps in between to avoid race conditions
tools_product = entities.Product(name=toolsproduct_name,
organization=org).create()
tools_repo = entities.Repository(name=toolsrepo_name,
product=tools_product,
url=tools_repo_url,
organization=org,
content_type='yum').create()
entities.Repository(id=tools_repo.id).sync()
cv.repository += [tools_repo]
cv.update(['repository'])
call_entity_method_with_timeout(cv.read().publish, timeout=2500)
published_ver = entities.ContentViewVersion(
id=max([cv_ver.id for cv_ver in cv.read().version])).read()
published_ver.promote(data={'environment_id': lenv.id, 'force': False})
tools_sub = entities.Subscription().search(
query={'search': 'name={0}'.format(toolsproduct_name)})[0]
ak.add_subscriptions(data={
'quantity': 1,
'subscription_id': tools_sub.id,
})
# Add this latest tools repo to hosts to upgrade
sub = entities.Subscription().search(
query={'search': 'name={0}'.format(toolsproduct_name)})[0]
for host in hosts:
if float(os.environ.get('FROM_VERSION')) <= 6.1:
# If not User Hosts then, attach sub to dockered clients
if not all([
os.environ.get('CLIENT6_HOSTS'),
os.environ.get('CLIENT7_HOSTS')
]):
docker_vm = os.environ.get('DOCKER_VM')
execute(attach_subscription_to_host_from_content_host,
sub.cp_id,
True,
host,
host=docker_vm)
# Else, Attach subs to user hosts
else:
execute(attach_subscription_to_host_from_content_host,
sub.cp_id,
host=host)
else:
host = entities.Host().search(
query={'search': 'name={}'.format(host)})[0]
entities.HostSubscription(host=host).add_subscriptions(
data={'subscriptions': [{
'id': sub.id,
'quantity': 1
}]})
def test_post_scenario_postclient_package_installation(self):
"""Post-upgrade scenario that creates and installs the package on
post-upgrade client remotely and then verifies if the package installed
:id: postupgrade-1a881c07-595f-425f-aca9-df2337824a8e
:steps:
1. Create a content host with existing client ak
2. Create and sync repo from which the package will be
installed on content host
3. Add repo to CV and then in Activation key
4. Install package on a pre-upgrade client
:expectedresults:
1. The content host is created
2. The new repo and its product has been added to ak using which
the content host is created
3. The package is installed on post-upgrade client
"""
rhel7_client = dockerize(distro='rhel7')
product = entities.Product(
name='postclient_scenario_product',
organization=1,
).create()
yum_repo = entities.Repository(
name='postclient_scenario_repo', product=product
).create()
yum_repo.sync()
self.cv.repository = [yum_repo]
cv = self.cv.update(['repository'])
cv.publish()
cv = cv.read() # Published CV with new version
# Promote CV
environment = entities.ActivationKey().search(
query={'search': 'name={}'.format(self.ak)}
)[0].environment
cvv = entities.ContentViewVersion(
id=max([cvv.id for cvv in cv.version])
).read()
cvv.promote(
data={
u'environment_id': environment.id,
u'force': False
}
)
client_id = entities.Host().search(
query={'search': 'name={}'.format(rhel7_client.keys()[0])}
)[0].id
entities.Host().install_content(data={
'organization_id': 1,
'included': {'ids': [client_id]},
'content_type': 'package',
'content': [self.package_name],
})
# Validate if that package is really installed
installed_package = execute(
docker_execute_command,
rhel7_client.values()[0],
'rpm -q {}'.format(self.package_name),
host=self.docker_vm
)[self.docker_vm]
time.sleep(10)
self.assertIn(self.package_name, installed_package)
