def _sync_capsule_subscription_to_capsule_ak(ak):
"""Syncs to_version capsule contents, adds to the CV and attaches contents to the AK through
which Capsule is registered
:param ak: ```nailgun.entities.ActivationKey``` used for capsule subscription
"""
cv = ak.content_view.read()
org = ak.organization
capsule_repo = os.environ.get('CAPSULE_URL')
to_version = os.environ.get('TO_VERSION')
os_ver = os.environ.get('OS')[-1]
# If custom capsule repo is not given then
# enable capsule repo from Redhat Repositories
if capsule_repo:
cap_product = entities.Product(
name=customcontents['capsule']['prod'], organization=org).create()
cap_repo = entities.Repository(
name=customcontents['capsule']['repo'], product=cap_product, url=capsule_repo,
organization=org, content_type='yum').create()
else:
cap_product = entities.Product(
name=rhelcontents['capsule']['prod'],
organization=org
).search(query={'per_page': 100})[0]
cap_reposet = entities.RepositorySet(
name=rhelcontents['capsule']['repo'].format(cap_ver=to_version, os_ver=os_ver),
product=cap_product
).search()[0]
try:
cap_reposet.enable(
data={'basearch': 'x86_64', 'releasever': '7Server', 'organization_id': org.id})
except requests.exceptions.HTTPError as exp:
logger.warn(exp)
cap_repo = entities.Repository(
name=rhelcontents['capsule']['repofull'].format(
cap_ver=to_version, os_ver=os_ver, arch='x86_64')
).search(query={'organization_id': org.id, 'per_page': 100})[0]
call_entity_method_with_timeout(entities.Repository(id=cap_repo.id).sync, timeout=2500)
# Add repos to CV
cv.repository += [cap_repo]
cv.update(['repository'])
ak = ak.read()
if capsule_repo:
cap_sub = entities.Subscription().search(
query={'search': 'name={0}'.format(customcontents['capsule']['prod'])})[0]
ak.add_subscriptions(data={
'quantity': 1,
'subscription_id': cap_sub.id,
})
else:
ak.content_override(
data={
'content_override': {
'content_label': rhelcontents['capsule']['label'].format(
cap_ver=to_version, os_ver=os_ver),
'value': '1'}
}
)
def satellite_capsule_setup(satellite_host,
capsule_hosts,
os_version,
upgradable_capsule=True):
"""
Setup all pre-requisites for user provided capsule
:param satellite_host: Satellite hostname to which the capsule registered
:param capsule_hosts: List of capsule which mapped with satellite host
:param os_version: The OS version onto which the capsule installed e.g: rhel6, rhel7
:param upgradable_capsule:Whether to setup capsule to be able to upgrade in future
:return: capsule_hosts
"""
if os_version == 'rhel6':
baseurl = settings.repos.rhel6_os
elif os_version == 'rhel7':
baseurl = settings.repos.rhel7_os
else:
logger.highlight('No OS Specified. Aborting...')
sys.exit(1)
non_responsive_host = []
for cap_host in capsule_hosts:
if not host_pings(cap_host):
non_responsive_host.append(cap_host)
else:
execute(host_ssh_availability_check, cap_host)
# Update the template once 1829115 gets fixed.
execute(workaround_1829115, host=cap_host)
if not bz_bug_is_open(1829115):
logger.warn(
"Please update the capsule template for fixed capsule version")
execute(foreman_service_restart, host=cap_host)
if non_responsive_host:
logger.highlight(
str(non_responsive_host) + ' these are non-responsive hosts. '
'Aborting...')
sys.exit(1)
copy_ssh_key(satellite_host, capsule_hosts)
if upgradable_capsule:
if settings.upgrade.distribution == "cdn":
settings.repos.capsule_repo = None
settings.repos.sattools_repo[settings.upgrade.os] = None
settings.repos.satmaintenance_repo = None
execute(update_capsules_to_satellite,
capsule_hosts,
host=satellite_host)
if settings.upgrade.upgrade_with_http_proxy:
http_proxy_config(capsule_hosts)
execute(sync_capsule_repos_to_satellite,
capsule_hosts,
host=satellite_host)
for cap_host in capsule_hosts:
settings.upgrade.capsule_hostname = cap_host
execute(add_baseOS_repo, baseurl, host=cap_host)
execute(yum_repos_cleanup, host=cap_host)
logger.info(f'Capsule {cap_host} is ready for Upgrade')
return capsule_hosts
def _sync_sattools_repos_to_satellite_for_capsule(capsuletools_url, org):
"""Creates custom / Enables RH Tools repo on satellite and syncs for capsule upgrade
:param str capsuletools_url: The capsule tools repo url
:param org: ```nailgun.entities.Organization``` entity of capsule
:returns: ```nailgun.entities.repository``` entity for capsule
"""
to_ver = os.environ.get('TO_VERSION')
rhelver = '7'
arch = 'x86_64'
if capsuletools_url:
captools_product = entities.Product(
name=customcontents['capsule_tools']['prod'],
organization=org).create()
captools_repo = entities.Repository(
name=customcontents['capsule_tools']['repo'],
product=captools_product,
url=capsuletools_url,
organization=org,
content_type='yum').create()
else:
captools_product = entities.Product(
name=rhelcontents['tools']['prod'],
organization=org).search(query={'per_page': 100})[0]
cap_reposet = entities.RepositorySet(
name=rhelcontents['tools']['repo'].format(sat_ver=to_ver,
os_ver=rhelver),
product=captools_product).search()[0]
try:
cap_reposet.enable(data={
'basearch': arch,
'organization_id': org.id
})
except requests.exceptions.HTTPError as exp:
logger.warn(exp)
time.sleep(5)
captools_repo = entities.Repository(
name=rhelcontents['tools']['repofull'].format(
sat_ver=to_ver, os_ver=rhelver, arch=arch)).search(
query={
'organization_id': org.id,
'per_page': 100
})[0]
call_entity_method_with_timeout(
entities.Repository(id=captools_repo.id).sync, timeout=2500)
captools_repo.repo_id = rhelcontents['tools']['label'].format(
os_ver=rhelver, sat_ver=to_ver)
return captools_repo
def _sync_rh_repos_to_satellite(org):
"""Task to sync Redhat Repositories to latest required during upgrade
:param org: ```nailgun.entities.Organization``` entity of capsule
:returns tuple: RHSCL and Redhat 7 Server repo name, label name and
product name
"""
rhelver = '7'
arch = 'x86_64'
# Enable rhscl repository
scl_product = entities.Product(
name=rhelcontents['rhscl_sat64']['prod'], organization=org
).search(query={'per_page': 100})[0]
scl_reposet = entities.RepositorySet(
name=rhelcontents['rhscl']['repo'].format(os_ver=rhelver), product=scl_product
).search()[0]
try:
scl_reposet.enable(
data={'basearch': arch, 'releasever': '7Server', 'organization_id': org.id})
except requests.exceptions.HTTPError as exp:
logger.warn(exp)
time.sleep(20)
# Sync enabled Repo from cdn
scl_repo = entities.Repository(
name=rhelcontents['rhscl']['repofull'].format(os_ver=rhelver, arch=arch)
).search(query={'organization_id': org.id, 'per_page': 100})[0]
call_entity_method_with_timeout(entities.Repository(id=scl_repo.id).sync, timeout=2500)
# Enable RHEL 7 Server repository
server_product = entities.Product(
name=rhelcontents['server']['prod'], organization=org).search(query={'per_page': 100})[0]
server_reposet = entities.RepositorySet(
name=rhelcontents['server']['repo'].format(os_ver=rhelver), product=server_product
).search()[0]
try:
server_reposet.enable(
data={'basearch': arch, 'releasever': '7Server', 'organization_id': org.id})
except requests.exceptions.HTTPError as exp:
logger.warn(exp)
time.sleep(20)
# Sync enabled Repo from cdn
server_repo = entities.Repository(
name=rhelcontents['server']['repofull'].format(os_ver=rhelver, arch=arch)
).search(query={'organization_id': org.id, 'per_page': 100})[0]
call_entity_method_with_timeout(entities.Repository(id=server_repo.id).sync, timeout=3600)
scl_repo.repo_id = rhelcontents['rhscl']['label'].format(os_ver=rhelver)
server_repo.repo_id = rhelcontents['server']['label'].format(os_ver=rhelver)
return scl_repo, server_repo
def docker_clients_agent_version(clients, agent):
"""Determines and returns the katello or puppet agent version on docker
clients
:param dict clients: The dictionary containing client_name as key and
container_id as value
:param string agent: puppet/ puppet-agent / katello-agent
:returns dict: The dict of docker clients hostname as key and
its katello or puppet agent version as value
"""
clients_dict = {}
for hostname, container in tuple(clients.items()):
try:
command_output = docker_execute_command(container, f'rpm -q {agent}')
pst = version_filter(command_output)
clients_dict[hostname] = pst
except Exception as ex:
logger.warn(ex)
clients_dict[hostname] = f"{agent} package not updated"
return clients_dict
def docker_client_missing_package_installation(clients, agent):
"""
Use to install the missing packages of puppet agent and katello-agent
:param dict clients: The dictionary containing client_name as key and
container_id as value
:param string agent: puppet-agent / katello-agent
"""
for hostname, container in tuple(clients.items()):
logger.info(f'Installing client {hostname} on docker container: {container}')
try:
for _ in range(1, 15):
yum_status = docker_execute_command(container, 'pgrep yum', True)
if yum_status == '':
break
logger.info("yum command is running wait fot 60 seconds...")
time.sleep(60)
command_output = docker_execute_command(container, f'rpm -q {agent}', True)
if re.search(f'package {agent} is not installed', command_output):
logger.warn(f"base version of {agent} package missed(because of timeout) on "
f"{container} so installing it separately")
docker_execute_command(container, f'yum install -y {agent}', True)
command_output = docker_execute_command(container, f'rpm -q {agent}', True)
if re.search(f'package {agent} is not installed', command_output):
logger.warn(f"failed to install package {agent} on {container}")
else:
logger.info(f"base version of {agent} package {command_output} installed "
f"successfully on {container}")
else:
logger.info(f"{agent} package {command_output} is available before "
f"upgrade on {container}")
except Exception as ex:
logger.warn(ex)