def test_get_koji_session(self, fallback, config, raise_error):
tasker, workflow = self.prepare()
workflow.plugin_workspace[ReactorConfigPlugin.key] = {}
if raise_error:
with pytest.raises(Exception):
read_yaml(config, 'schemas/config.json')
return
config_json = read_yaml(config, 'schemas/config.json')
auth_info = {
"proxyuser": config_json['koji']['auth'].get('proxyuser'),
"ssl_certs_dir": config_json['koji']['auth'].get('ssl_certs_dir'),
"krb_principal": config_json['koji']['auth'].get('krb_principal'),
"krb_keytab": config_json['koji']['auth'].get('krb_keytab_path')
}
fallback_map = {}
if fallback:
fallback_map = {'auth': deepcopy(auth_info), 'hub_url': config_json['koji']['hub_url']}
fallback_map['auth']['krb_keytab_path'] = fallback_map['auth'].pop('krb_keytab')
else:
workflow.plugin_workspace[ReactorConfigPlugin.key][WORKSPACE_CONF_KEY] = \
ReactorConfig(config_json)
(flexmock(atomic_reactor.koji_util)
.should_receive('create_koji_session')
.with_args(config_json['koji']['hub_url'], auth_info)
.once()
.and_return(True))
get_koji_session(workflow, fallback_map)
def test_get_koji_session(self, fallback, config, raise_error):
tasker, workflow = self.prepare()
workflow.plugin_workspace[ReactorConfigPlugin.key] = {}
if raise_error:
with pytest.raises(Exception):
read_yaml(config, 'schemas/config.json')
return
config_json = read_yaml(config, 'schemas/config.json')
auth_info = {
"proxyuser": config_json['koji']['auth'].get('proxyuser'),
"ssl_certs_dir": config_json['koji']['auth'].get('ssl_certs_dir'),
"krb_principal": config_json['koji']['auth'].get('krb_principal'),
"krb_keytab": config_json['koji']['auth'].get('krb_keytab_path')
}
fallback_map = {}
if fallback:
fallback_map = {
'auth': deepcopy(auth_info),
'hub_url': config_json['koji']['hub_url']
}
fallback_map['auth']['krb_keytab_path'] = fallback_map['auth'].pop(
'krb_keytab')
else:
workflow.plugin_workspace[ReactorConfigPlugin.key][WORKSPACE_CONF_KEY] = \
ReactorConfig(config_json)
(flexmock(atomic_reactor.koji_util).should_receive(
'create_koji_session').with_args(
config_json['koji']['hub_url'],
auth_info).once().and_return(True))
get_koji_session(workflow, fallback_map)
def run(self):
"""
Run the plugin.
"""
self.session = get_koji_session(self.workflow)
nvr_requests = [
NvrRequest(**nvr_request) for nvr_request in
util.read_fetch_artifacts_koji(self.workflow) or []
]
pnc_requests = util.read_fetch_artifacts_pnc(self.workflow) or {}
url_requests = util.read_fetch_artifacts_url(self.workflow) or []
components = self.get_nvr_components(nvr_requests)
pnc_build_metadata = self.get_pnc_build_metadata(pnc_requests)
download_queue = self.process_url_requests(url_requests)
remote_source_files = self.download_sources(download_queue)
return {
'components': components,
'no_source': self.no_source_artifacts,
'pnc_build_metadata': pnc_build_metadata,
'remote_source_files': remote_source_files
}
def run(self):
"""
Run the plugin.
"""
if self.workflow.build_process_failed:
self.log.info('Build failed, skipping koji tagging')
return
if is_scratch_build(self.workflow):
self.log.info('scratch build, skipping plugin')
return
if not self.target:
self.log.info('no koji target provided, skipping plugin')
return
build_id = self.workflow.exit_results.get(KojiImportPlugin.key)
if not build_id:
self.log.info('No koji build from %s', KojiImportPlugin.key)
return
session = get_koji_session(self.workflow)
build_tag = tag_koji_build(session, build_id, self.target,
poll_interval=self.poll_interval)
return build_tag
def __init__(self,
tasker,
workflow,
koji_hub=None,
koji_ssl_certs_dir=None,
poll_interval=DEFAULT_POLL_INTERVAL,
poll_timeout=DEFAULT_POLL_TIMEOUT):
"""
:param tasker: DockerTasker instance
:param workflow: DockerBuildWorkflow instance
:param koji_hub: str, koji hub (xmlrpc)
:param koji_ssl_certs_dir: str, path to "cert", "ca", and "serverca"
used when Koji's identity certificate is not trusted
:param poll_interval: int, seconds between polling for Koji build
:param poll_timeout: int, max amount of seconds to wait for Koji build
"""
super(KojiParentPlugin, self).__init__(tasker, workflow)
self.koji_fallback = {
'hub_url': koji_hub,
'auth': {
'ssl_certs_dir': koji_ssl_certs_dir
}
}
self.koji_session = get_koji_session(self.workflow, self.koji_fallback)
self.poll_interval = poll_interval
self.poll_timeout = poll_timeout
self._base_image_nvr = None
self._base_image_build = None
self._parent_builds = {}
self._poll_start = None
def __init__(
self, tasker, workflow, koji_build_id=None, koji_build_nvr=None, signing_intent=None,
):
"""
:param tasker: ContainerTasker instance
:param workflow: DockerBuildWorkflow instance
:param koji_build_id: int, container image koji build id
:param koji_build_nvr: str, container image koji build NVR
:param signing_intent: str, ODCS signing intent name
"""
if not koji_build_id and not koji_build_nvr:
err_msg = ('{} expects either koji_build_id or koji_build_nvr to be defined'
.format(self.__class__.__name__))
raise TypeError(err_msg)
type_errors = []
if koji_build_id is not None and not isinstance(koji_build_id, int):
type_errors.append('koji_build_id must be an int. Got {}'.format(type(koji_build_id)))
if koji_build_nvr is not None and not isinstance(koji_build_nvr, string_types):
type_errors.append('koji_build_nvr must be a str. Got {}'
.format(type(koji_build_nvr)))
if type_errors:
raise TypeError(type_errors)
super(FetchSourcesPlugin, self).__init__(tasker, workflow)
self.koji_build = None
self.koji_build_id = koji_build_id
self.koji_build_nvr = koji_build_nvr
self.signing_intent = signing_intent
self.session = get_koji_session(self.workflow, NO_FALLBACK)
self.pathinfo = get_koji_path_info(self.workflow, NO_FALLBACK)
def _resolve_modules(self, modules):
koji_session = get_koji_session(self.workflow, fallback=NO_FALLBACK)
resolved_modules = {}
for module_spec in modules:
build, rpm_list = get_koji_module_build(koji_session, module_spec)
# The returned RPM list contains source RPMs and RPMs for all
# architectures.
rpms = [
'{name}-{epochnum}:{version}-{release}.{arch}.rpm'.format(
epochnum=rpm['epoch'] or 0, **rpm) for rpm in rpm_list
]
# strict=False - don't break if new fields are added
mmd = Modulemd.ModuleStream.read_string(
build['extra']['typeinfo']['module']['modulemd_str'],
strict=False)
# Make sure we have a version 2 modulemd file
mmd = mmd.upgrade(Modulemd.ModuleStreamVersionEnum.TWO)
resolved_modules[module_spec.name] = ModuleInfo(
module_spec.name, module_spec.stream, module_spec.version, mmd,
rpms)
return resolved_modules
def __init__(self, tasker, workflow, koji_parent_build, koji_hub=None, koji_ssl_certs_dir=None):
"""
:param tasker: DockerTasker instance
:param workflow: DockerBuildWorkflow instance
:param koji_parent_build: str, either Koji build ID or Koji build NVR
:param koji_hub: str, koji hub (xmlrpc)
:param koji_ssl_certs_dir: str, path to "cert", "ca", and "serverca"
used when Koji's identity certificate is not trusted
"""
super(InjectParentImage, self).__init__(tasker, workflow)
self.koji_fallback = {
'hub_url': koji_hub,
'auth': {
'ssl_certs_dir': koji_ssl_certs_dir,
}
}
self.koji_session = get_koji_session(self.workflow, self.koji_fallback)
try:
self.koji_parent_build = int(koji_parent_build)
except ValueError:
self.koji_parent_build = koji_parent_build
self._koji_parent_build_info = None
self._repositories = None
self._new_parent_image = None
def __init__(self, tasker, workflow, koji_parent_build, koji_hub=None, koji_ssl_certs_dir=None):
"""
:param tasker: ContainerTasker instance
:param workflow: DockerBuildWorkflow instance
:param koji_parent_build: str, either Koji build ID or Koji build NVR
:param koji_hub: str, koji hub (xmlrpc)
:param koji_ssl_certs_dir: str, path to "cert", "ca", and "serverca"
used when Koji's identity certificate is not trusted
"""
super(InjectParentImage, self).__init__(tasker, workflow)
self.koji_fallback = {
'hub_url': koji_hub,
'auth': {
'ssl_certs_dir': koji_ssl_certs_dir,
}
}
self.koji_session = get_koji_session(self.workflow, self.koji_fallback)
try:
self.koji_parent_build = int(koji_parent_build)
except ValueError:
self.koji_parent_build = koji_parent_build
self._koji_parent_build_info = None
self._repositories = None
self._new_parent_image = None
def source_get_unique_image(self):
source_result = self.workflow.prebuild_results[
PLUGIN_FETCH_SOURCES_KEY]
koji_build_id = source_result['sources_for_koji_build_id']
kojisession = get_koji_session(self.workflow, NO_FALLBACK)
timestamp = osbs.utils.utcnow().strftime('%Y%m%d%H%M%S')
random.seed()
current_platform = platform.processor() or 'x86_64'
tag_segments = [
self.koji_target or 'none',
str(random.randrange(10**(RAND_DIGITS - 1), 10**RAND_DIGITS)),
timestamp, current_platform
]
tag = '-'.join(tag_segments)
get_build_meta = kojisession.getBuild(koji_build_id)
pull_specs = get_build_meta['extra']['image']['index']['pull']
source_image_spec = ImageName.parse(pull_specs[0])
source_image_spec.tag = tag
organization = get_registries_organization(self.workflow)
if organization:
source_image_spec.enclose(organization)
source_image_spec.registry = None
return source_image_spec
def __init__(self, tasker, workflow, hub=None, target=None, koji_ssl_certs_dir=None,
append=False):
"""
constructor
:param tasker: DockerTasker instance
:param workflow: DockerBuildWorkflow instance
:param hub: string, koji hub (xmlrpc)
:param target: unused - backwards compatibility
:param koji_ssl_certs_dir: str, path to "cert", "ca", and "serverca"
Note that this plugin requires koji_ssl_certs_dir set if Koji
certificate is not trusted by CA bundle.
:param append: if True, the release will be obtained by appending a
'.' and a unique integer to the release label in the dockerfile.
"""
# call parent constructor
super(BumpReleasePlugin, self).__init__(tasker, workflow)
self.koji_fallback = {
'hub_url': hub,
'auth': {
'ssl_certs_dir': koji_ssl_certs_dir,
}
}
self.append = append
self.xmlrpc = get_koji_session(self.workflow, self.koji_fallback)
def __init__(self, tasker, workflow, koji_hub=None, koji_ssl_certs_dir=None,
poll_interval=DEFAULT_POLL_INTERVAL, poll_timeout=DEFAULT_POLL_TIMEOUT):
"""
:param tasker: DockerTasker instance
:param workflow: DockerBuildWorkflow instance
:param koji_hub: str, koji hub (xmlrpc)
:param koji_ssl_certs_dir: str, path to "cert", "ca", and "serverca"
used when Koji's identity certificate is not trusted
:param poll_interval: int, seconds between polling for Koji build
:param poll_timeout: int, max amount of seconds to wait for Koji build
"""
super(KojiParentPlugin, self).__init__(tasker, workflow)
self.koji_fallback = {
'hub_url': koji_hub,
'auth': {'ssl_certs_dir': koji_ssl_certs_dir}
}
self.koji_session = get_koji_session(self.workflow, self.koji_fallback)
self.poll_interval = poll_interval
self.poll_timeout = poll_timeout
self._base_image_nvr = None
self._base_image_build = None
self._parent_builds = {}
self._poll_start = None
def __init__(self,
tasker,
workflow,
poll_interval=DEFAULT_POLL_INTERVAL,
poll_timeout=DEFAULT_POLL_TIMEOUT):
"""
:param tasker: ContainerTasker instance
:param workflow: DockerBuildWorkflow instance
:param poll_interval: int, seconds between polling for Koji build
:param poll_timeout: int, max amount of seconds to wait for Koji build
"""
super(KojiParentPlugin, self).__init__(tasker, workflow)
self.koji_session = get_koji_session(self.workflow)
self.poll_interval = poll_interval
self.poll_timeout = poll_timeout
self._base_image_nvr = None
self._base_image_build = None
self._parent_builds = {}
self._poll_start = None
self.platforms = get_platforms(self.workflow)
# RegistryClient instances cached by registry name
self.registry_clients = {}
self._deep_manifest_list_inspection = get_deep_manifest_list_inspection(
self.workflow, fallback=True)
def __init__(self,
tasker,
workflow,
hub=None,
target=None,
koji_ssl_certs_dir=None,
append=False):
"""
constructor
:param tasker: DockerTasker instance
:param workflow: DockerBuildWorkflow instance
:param hub: string, koji hub (xmlrpc)
:param target: unused - backwards compatibility
:param koji_ssl_certs_dir: str, path to "cert", "ca", and "serverca"
Note that this plugin requires koji_ssl_certs_dir set if Koji
certificate is not trusted by CA bundle.
:param append: if True, the release will be obtained by appending a
'.' and a unique integer to the release label in the dockerfile.
"""
# call parent constructor
super(BumpReleasePlugin, self).__init__(tasker, workflow)
self.koji_fallback = {
'hub_url': hub,
'auth': {
'ssl_certs_dir': koji_ssl_certs_dir,
}
}
self.append = append
self.xmlrpc = get_koji_session(self.workflow, self.koji_fallback)
def _resolve_modules(self, compose_source):
koji_session = get_koji_session(self.workflow, fallback=NO_FALLBACK)
resolved_modules = {}
for module in compose_source.strip().split():
module_spec = ModuleSpec.from_str(module)
build, rpm_list = get_koji_module_build(koji_session, module_spec)
# The returned RPM list contains source RPMs and RPMs for all
# architectures.
rpms = ['{name}-{epochnum}:{version}-{release}.{arch}.rpm'
.format(epochnum=rpm['epoch'] or 0, **rpm)
for rpm in rpm_list]
objects = Modulemd.objects_from_string(
build['extra']['typeinfo']['module']['modulemd_str'])
assert len(objects) == 1
mmd = objects[0]
assert isinstance(mmd, Modulemd.Module)
# Make sure we have a version 2 modulemd file
mmd.upgrade()
resolved_modules[module_spec.name] = ModuleInfo(module_spec.name,
module_spec.stream,
module_spec.version,
mmd, rpms)
return resolved_modules
def __init__(self, tasker, workflow, target, hub=None, root=None, proxy=None,
koji_ssl_certs_dir=None):
"""
constructor
:param tasker: DockerTasker instance
:param workflow: DockerBuildWorkflow instance
:param target: string, koji target to use as a source
:param hub: string, koji hub (xmlrpc)
:param root: string, koji root (storage)
:param koji_ssl_certs_dir: str, path to "cert", "ca", and "serverca"
Note that this plugin requires koji_ssl_certs_dir set if Koji
certificate is not trusted by CA bundle.
"""
# call parent constructor
super(KojiPlugin, self).__init__(tasker, workflow)
self.target = target
self.koji_fallback = {
'hub_url': hub,
'root_url': root,
'auth': {
'ssl_certs_dir': koji_ssl_certs_dir
}
}
self.xmlrpc = get_koji_session(self.workflow, self.koji_fallback)
self.pathinfo = get_koji_path_info(self.workflow, self.koji_fallback)
self.proxy = get_yum_proxy(self.workflow, proxy)
def __init__(self, tasker, workflow, target, hub=None, root=None, proxy=None,
koji_ssl_certs_dir=None):
"""
constructor
:param tasker: DockerTasker instance
:param workflow: DockerBuildWorkflow instance
:param target: string, koji target to use as a source
:param hub: string, koji hub (xmlrpc)
:param root: string, koji root (storage)
:param koji_ssl_certs_dir: str, path to "cert", "ca", and "serverca"
Note that this plugin requires koji_ssl_certs_dir set if Koji
certificate is not trusted by CA bundle.
"""
# call parent constructor
super(KojiPlugin, self).__init__(tasker, workflow)
self.target = target
self.koji_fallback = {
'hub_url': hub,
'root_url': root,
'auth': {
'ssl_certs_dir': koji_ssl_certs_dir
}
}
self.xmlrpc = get_koji_session(self.workflow, self.koji_fallback)
self.pathinfo = get_koji_path_info(self.workflow, self.koji_fallback)
self.proxy = get_yum_proxy(self.workflow, proxy)
def _resolve_modules(self, compose_source):
koji_session = get_koji_session(self.workflow, fallback=NO_FALLBACK)
resolved_modules = {}
for module in compose_source.strip().split():
module_spec = split_module_spec(module)
build, rpm_list = get_koji_module_build(koji_session, module_spec)
# The returned RPM list contains source RPMs and RPMs for all
# architectures.
rpms = [
'{name}-{epochnum}:{version}-{release}.{arch}.rpm'.format(
epochnum=rpm['epoch'] or 0, **rpm) for rpm in rpm_list
]
objects = Modulemd.objects_from_string(
build['extra']['typeinfo']['module']['modulemd_str'])
assert len(objects) == 1
mmd = objects[0]
assert isinstance(mmd, Modulemd.Module)
# Make sure we have a version 2 modulemd file
mmd.upgrade()
resolved_modules[module_spec.name] = ModuleInfo(
module_spec.name, module_spec.stream, module_spec.version, mmd,
rpms)
return resolved_modules
def run(self):
"""
run the plugin
"""
if self.koji_target:
koji_session = get_koji_session(self.workflow, NO_FALLBACK)
self.log.info("Checking koji target for platforms")
event_id = koji_session.getLastEvent()['id']
target_info = koji_session.getBuildTarget(self.koji_target,
event=event_id)
build_tag = target_info['build_tag']
koji_build_conf = koji_session.getBuildConfig(build_tag,
event=event_id)
koji_platforms = koji_build_conf['arches']
if not koji_platforms:
self.log.info("No platforms found in koji target")
return None
platforms = koji_platforms.split()
self.log.info("Koji platforms are %s", sorted(platforms))
if is_scratch_build() or is_isolated_build():
override_platforms = get_orchestrator_platforms(self.workflow)
if override_platforms and set(override_platforms) != set(
platforms):
sort_platforms = sorted(override_platforms)
self.log.info("Received user specified platforms %s",
sort_platforms)
self.log.info("Using them instead of koji platforms")
# platforms from user params do not match platforms from koji target
# that almost certainly means they were overridden and should be used
return set(override_platforms)
else:
platforms = get_orchestrator_platforms(self.workflow)
self.log.info("No koji platforms. User specified platforms are %s",
sorted(platforms))
if not platforms:
raise RuntimeError(
"Cannot determine platforms; no koji target or platform list")
# Filter platforms based on clusters
enabled_platforms = []
for p in platforms:
if self.reactor_config.get_enabled_clusters_for_platform(p):
enabled_platforms.append(p)
else:
self.log.warning(
"No cluster found for platform '%s' in reactor config map, skipping",
p)
final_platforms = get_platforms_in_limits(self.workflow,
enabled_platforms)
self.log.info("platforms in limits : %s", final_platforms)
return final_platforms
def run(self):
self.session = get_koji_session(self.workflow, self.koji_fallback)
nvr_requests = self.read_nvr_requests()
url_requests = self.read_url_requests()
download_queue = (self.process_by_nvr(nvr_requests) +
self.process_by_url(url_requests))
self.download_files(download_queue)
# TODO: Return a list of files for koji metadata
return download_queue
def run(self):
self.session = get_koji_session(self.workflow, self.koji_fallback)
nvr_requests = self.read_nvr_requests()
url_requests = self.read_url_requests()
download_queue = (self.process_by_nvr(nvr_requests) +
self.process_by_url(url_requests))
self.download_files(download_queue)
# TODO: Return a list of files for koji metadata
return download_queue
def run(self):
self.session = get_koji_session(self.workflow)
nvr_requests = [
NvrRequest(**nvr_request) for nvr_request in
util.read_fetch_artifacts_koji(self.workflow) or []
]
url_requests = util.read_fetch_artifacts_url(self.workflow) or []
download_queue = (self.process_by_nvr(nvr_requests) +
self.process_by_url(url_requests))
self.download_files(download_queue)
return download_queue
def __init__(self, tasker, workflow, target=None, proxy=None):
"""
constructor
:param tasker: ContainerTasker instance
:param workflow: DockerBuildWorkflow instance
:param target: string, koji target to use as a source
"""
# call parent constructor
super(KojiPlugin, self).__init__(tasker, workflow)
self.target = target
self.xmlrpc = get_koji_session(self.workflow)
self.pathinfo = get_koji_path_info(self.workflow)
self.proxy = get_yum_proxy(self.workflow, proxy)
def run(self):
"""
run the plugin
"""
if self.koji_target:
koji_session = get_koji_session(self.workflow, NO_FALLBACK)
self.log.info("Checking koji target for platforms")
event_id = koji_session.getLastEvent()['id']
target_info = koji_session.getBuildTarget(self.koji_target, event=event_id)
build_tag = target_info['build_tag']
koji_build_conf = koji_session.getBuildConfig(build_tag, event=event_id)
koji_platforms = koji_build_conf['arches']
if not koji_platforms:
self.log.info("No platforms found in koji target")
return None
platforms = koji_platforms.split()
self.log.info("Koji platforms are %s", sorted(platforms))
if is_scratch_build() or is_isolated_build():
override_platforms = get_orchestrator_platforms(self.workflow)
if override_platforms and set(override_platforms) != set(platforms):
sort_platforms = sorted(override_platforms)
self.log.info("Received user specified platforms %s", sort_platforms)
self.log.info("Using them instead of koji platforms")
# platforms from user params do not match platforms from koji target
# that almost certainly means they were overridden and should be used
return set(override_platforms)
else:
platforms = get_orchestrator_platforms(self.workflow)
self.log.info("No koji platforms. User specified platforms are %s", sorted(platforms))
if not platforms:
raise RuntimeError("Cannot determine platforms; no koji target or platform list")
# Filter platforms based on clusters
enabled_platforms = []
for p in platforms:
if self.reactor_config.get_enabled_clusters_for_platform(p):
enabled_platforms.append(p)
else:
self.log.warning(
"No cluster found for platform '%s' in reactor config map, skipping", p)
final_platforms = get_platforms_in_limits(self.workflow, enabled_platforms)
self.log.info("platforms in limits : %s", final_platforms)
return final_platforms
def get_koji_user(self):
try:
metadata = get_build_json()['metadata']
except KeyError:
msg = 'Unable to get koji user: No build metadata'
self.log.exception('Unable to get koji user: No build metadata')
raise ValueError(msg)
try:
koji_task_id = int(metadata.get('labels').get('koji-task-id'))
except (ValueError, TypeError, AttributeError):
msg = 'Unable to get koji user: Invalid Koji task ID'
self.log.exception(msg)
raise ValueError(msg)
koji_session = get_koji_session(self.workflow, NO_FALLBACK)
return get_koji_task_owner(koji_session, koji_task_id).get('name')
def __init__(self, tasker, workflow, koji_parent_build=None):
"""
:param tasker: ContainerTasker instance
:param workflow: DockerBuildWorkflow instance
:param koji_parent_build: str, either Koji build ID or Koji build NVR
"""
super(InjectParentImage, self).__init__(tasker, workflow)
self.koji_session = get_koji_session(self.workflow)
try:
self.koji_parent_build = int(koji_parent_build)
except (ValueError, TypeError):
self.koji_parent_build = koji_parent_build
self._koji_parent_build_info = None
self._repositories = None
self._new_parent_image = None
def __init__(self, tasker, workflow, target=None, append=False):
"""
constructor
:param tasker: ContainerTasker instance
:param workflow: DockerBuildWorkflow instance
:param target: unused - backwards compatibility
:param append: if True, the release will be obtained by appending a
'.' and a unique integer to the release label in the dockerfile.
"""
# call parent constructor
super(BumpReleasePlugin, self).__init__(tasker, workflow)
self.append = append
self.xmlrpc = get_koji_session(self.workflow)
koji_setting = get_koji(self.workflow)
self.reserve_build = koji_setting.get('reserve_build', False)
def run(self):
"""
Run the plugin.
"""
# Only run if the build was successful
if self.workflow.build_process_failed:
self.log.info("Not promoting failed build to koji")
return
self.koji_session = get_koji_session(self.workflow, self.koji_fallback)
koji_metadata, output_files = self.get_metadata()
try:
server_dir = self.get_upload_server_dir()
for output in output_files:
if output.file:
self.upload_file(self.koji_session, output, server_dir)
finally:
for output in output_files:
if output.file:
output.file.close()
try:
build_info = self.koji_session.CGImport(koji_metadata, server_dir)
except Exception:
self.log.debug("metadata: %r", koji_metadata)
raise
# Older versions of CGImport do not return a value.
build_id = build_info.get("id") if build_info else None
self.log.debug("Build information: %s",
json.dumps(build_info, sort_keys=True, indent=4))
# If configured, koji_tag_build plugin will perform build tagging
tag_later = are_plugins_in_order(self.workflow.exit_plugins_conf,
PLUGIN_KOJI_PROMOTE_PLUGIN_KEY,
PLUGIN_KOJI_TAG_BUILD_KEY)
if not tag_later and build_id is not None and self.target is not None:
tag_koji_build(self.koji_session,
build_id,
self.target,
poll_interval=self.poll_interval)
return build_id
def run(self):
if not self.workflow.builder.custom_parent_image:
self.log.info('Nothing to do for non-custom base images')
return
image_build_conf = self.get_image_build_conf()
self.session = get_koji_session(self.workflow, self.koji_fallback)
task_id, filesystem_regex = self.run_image_task(image_build_conf)
new_base_image = None
if not self.is_orchestrator:
new_base_image = self.stream_filesystem(task_id, filesystem_regex)
return {
'base-image-id': new_base_image,
'filesystem-koji-task-id': task_id,
}
def __init__(self, tasker, workflow, triggered_after_koji_task=None):
"""
constructor
:param tasker: ContainerTasker instance
:param workflow: DockerBuildWorkflow instance
:param triggered_after_koji_task: int, original koji task for autorebuild,
provided only when this plugin creates new koji task for autorebuild
"""
# call parent constructor
super(KojiDelegatePlugin, self).__init__(tasker, workflow)
koji_setting = get_koji(self.workflow, NO_FALLBACK)
self.delegate_enabled = koji_setting.get('delegate_task', True)
self.task_priority = koji_setting.get('delegated_task_priority', None)
self.triggered_after_koji_task = triggered_after_koji_task
self.metadata = get_build_json().get("metadata", {})
self.kojisession = get_koji_session(self.workflow, NO_FALLBACK)
self.osbs = None
def run(self):
"""
Run the plugin.
"""
# Only run if the build was successful
if self.workflow.build_process_failed:
self.log.info("Not promoting failed build to koji")
return
self.koji_session = get_koji_session(self.workflow, self.koji_fallback)
koji_metadata, output_files = self.get_metadata()
try:
server_dir = self.get_upload_server_dir()
for output in output_files:
if output.file:
self.upload_file(self.koji_session, output, server_dir)
finally:
for output in output_files:
if output.file:
output.file.close()
try:
build_info = self.koji_session.CGImport(koji_metadata, server_dir)
except Exception:
self.log.debug("metadata: %r", koji_metadata)
raise
# Older versions of CGImport do not return a value.
build_id = build_info.get("id") if build_info else None
self.log.debug("Build information: %s",
json.dumps(build_info, sort_keys=True, indent=4))
# If configured, koji_tag_build plugin will perform build tagging
tag_later = are_plugins_in_order(self.workflow.exit_plugins_conf,
PLUGIN_KOJI_PROMOTE_PLUGIN_KEY,
PLUGIN_KOJI_TAG_BUILD_KEY)
if not tag_later and build_id is not None and self.target is not None:
tag_koji_build(self.koji_session, build_id, self.target,
poll_interval=self.poll_interval)
return build_id
def run(self):
if not self.workflow.builder.custom_parent_image:
self.log.info('Nothing to do for non-custom base images')
return
image_build_conf = self.get_image_build_conf()
self.session = get_koji_session(self.workflow, self.koji_fallback)
task_id, filesystem_regex = self.run_image_task(image_build_conf)
new_base_image = None
if not self.is_orchestrator:
new_base_image = self.stream_filesystem(task_id, filesystem_regex)
return {
'base-image-id': new_base_image,
'filesystem-koji-task-id': task_id,
}
def run(self):
"""
run the plugin
"""
koji_session = get_koji_session(self.workflow, NO_FALLBACK)
self.log.info("Checking koji target for platforms")
event_id = koji_session.getLastEvent()['id']
target_info = koji_session.getBuildTarget(self.koji_target,
event=event_id)
build_tag = target_info['build_tag']
koji_build_conf = koji_session.getBuildConfig(build_tag,
event=event_id)
koji_platforms = koji_build_conf['arches']
if not koji_platforms:
self.log.info("No platforms found in koji target")
return None
platforms = koji_platforms.split()
return get_platforms_in_limits(self.workflow, platforms)
def get_koji_user(self):
unknown_user = get_cachito(self.workflow).get('unknown_user',
'unknown_user')
try:
metadata = get_build_json()['metadata']
except KeyError:
msg = 'Unable to get koji user: No build metadata'
self.log.warning(msg)
return unknown_user
try:
koji_task_id = int(metadata.get('labels').get('koji-task-id'))
except (ValueError, TypeError, AttributeError):
msg = 'Unable to get koji user: Invalid Koji task ID'
self.log.warning(msg)
return unknown_user
koji_session = get_koji_session(self.workflow)
return get_koji_task_owner(koji_session,
koji_task_id).get('name', unknown_user)
def run(self):
"""
Run the plugin.
"""
# Only run if the build was successful
if self.workflow.build_process_failed:
self.log.info("Not importing failed build to koji")
return
self.session = get_koji_session(self.workflow, self.koji_fallback)
server_dir = get_koji_upload_dir(self.workflow)
koji_metadata, output_files = self.combine_metadata_fragments()
if is_scratch_build():
self.upload_scratch_metadata(koji_metadata, server_dir, self.session)
return
try:
for output in output_files:
if output.file:
self.upload_file(self.session, output, server_dir)
finally:
for output in output_files:
if output.file:
output.file.close()
try:
build_info = self.session.CGImport(koji_metadata, server_dir)
except Exception:
self.log.debug("metadata: %r", koji_metadata)
raise
# Older versions of CGImport do not return a value.
build_id = build_info.get("id") if build_info else None
self.log.debug("Build information: %s",
json.dumps(build_info, sort_keys=True, indent=4))
return build_id
def run(self):
"""
Run the plugin.
"""
if self.workflow.build_process_failed:
self.log.info('Build failed, skipping koji tagging')
return
build_id = self.workflow.exit_results.get(KojiImportPlugin.key)
if not build_id:
build_id = self.workflow.exit_results.get(KojiPromotePlugin.key)
if not build_id:
self.log.info('No koji build from %s or %s', KojiImportPlugin.key,
KojiPromotePlugin.key)
return
session = get_koji_session(self.workflow, self.koji_fallback)
build_tag = tag_koji_build(session, build_id, self.target,
poll_interval=self.poll_interval)
return build_tag
def run(self):
if not self.workflow.builder.dockerfile_images.custom_parent_image:
self.log.info('Nothing to do for non-custom base images')
return
self.update_repos_from_composes()
image_build_conf = self.get_image_build_conf()
self.session = get_koji_session(self.workflow)
task_id, filesystem_regex = self.run_image_task(image_build_conf)
new_base_image = None
if not self.is_in_orchestrator():
new_base_image = self.stream_filesystem(task_id, filesystem_regex)
return {
'base-image-id': new_base_image,
'filesystem-koji-task-id': task_id,
}
def run(self):
base_image = self.workflow.builder.base_image
if base_image.namespace != 'koji' or base_image.repo != 'image-build':
self.log.info('Base image not supported: %s', base_image)
return
image_build_conf = base_image.tag
if not image_build_conf or image_build_conf == 'latest':
image_build_conf = 'image-build.conf'
self.session = get_koji_session(self.workflow, self.koji_fallback)
task_id, filesystem_regex = self.run_image_task(image_build_conf)
new_base_image = None
if not self.is_orchestrator:
new_base_image = self.stream_filesystem(task_id, filesystem_regex)
return {
'base-image-id': new_base_image,
'filesystem-koji-task-id': task_id,
}
def run(self):
"""
Run the plugin.
"""
# Only run if the build was successful
if self.workflow.build_process_failed:
self.log.info("Not promoting failed build to koji")
return
koji_metadata, output_files = self.get_metadata()
if not is_scratch_build():
try:
session = get_koji_session(self.workflow, self.koji_fallback)
for output in output_files:
if output.file:
self.upload_file(session, output, self.koji_upload_dir)
finally:
for output in output_files:
if output.file:
output.file.close()
md_fragment = "{}-md".format(get_build_json()['metadata']['name'])
md_fragment_key = 'metadata.json'
cm_data = {md_fragment_key: koji_metadata}
annotations = {
"metadata_fragment": "configmap/" + md_fragment,
"metadata_fragment_key": md_fragment_key
}
try:
self.osbs.create_config_map(md_fragment, cm_data)
except OsbsException:
self.log.debug("metadata: %r", koji_metadata)
self.log.debug("annotations: %r", annotations)
raise
return annotations
def run(self):
"""
Run the plugin.
"""
# Only run if the build was successful
if self.workflow.build_process_failed:
self.log.info("Not promoting failed build to koji")
return
koji_metadata, output_files = self.get_metadata()
if not is_scratch_build():
try:
session = get_koji_session(self.workflow, self.koji_fallback)
for output in output_files:
if output.file:
self.upload_file(session, output, self.koji_upload_dir)
finally:
for output in output_files:
if output.file:
output.file.close()
md_fragment = "{}-md".format(get_build_json()['metadata']['name'])
md_fragment_key = 'metadata.json'
cm_data = {md_fragment_key: koji_metadata}
annotations = {
"metadata_fragment": "configmap/" + md_fragment,
"metadata_fragment_key": md_fragment_key
}
try:
self.osbs.create_config_map(md_fragment, cm_data)
except OsbsException:
self.log.debug("metadata: %r", koji_metadata)
self.log.debug("annotations: %r", annotations)
raise
return annotations
def run(self):
"""
Run the plugin.
"""
if self.workflow.build_process_failed:
self.log.info('Build failed, skipping koji tagging')
return
build_id = self.workflow.exit_results.get(KojiImportPlugin.key)
if not build_id:
build_id = self.workflow.exit_results.get(KojiPromotePlugin.key)
if not build_id:
self.log.info('No koji build from %s or %s',
KojiImportPlugin.key, KojiPromotePlugin.key)
return
session = get_koji_session(self.workflow, self.koji_fallback)
build_tag = tag_koji_build(session,
build_id,
self.target,
poll_interval=self.poll_interval)
return build_tag
def run(self):
"""
Run the plugin.
"""
# Only run if the build was successful
if self.workflow.build_process_failed:
self.log.info("Not importing failed build to koji")
return
self.session = get_koji_session(self.workflow, self.koji_fallback)
server_dir = get_koji_upload_dir(self.workflow)
koji_metadata, output_files = self.combine_metadata_fragments()
try:
for output in output_files:
if output.file:
self.upload_file(self.session, output, server_dir)
finally:
for output in output_files:
if output.file:
output.file.close()
try:
build_info = self.session.CGImport(koji_metadata, server_dir)
except Exception:
self.log.debug("metadata: %r", koji_metadata)
raise
# Older versions of CGImport do not return a value.
build_id = build_info.get("id") if build_info else None
self.log.debug("Build information: %s",
json.dumps(build_info, sort_keys=True, indent=4))
return build_id
def run(self):
"""
run the plugin
"""
koji_session = get_koji_session(self.workflow, NO_FALLBACK)
self.log.info("Checking koji target for platforms")
event_id = koji_session.getLastEvent()['id']
target_info = koji_session.getBuildTarget(self.koji_target, event=event_id)
build_tag = target_info['build_tag']
koji_build_conf = koji_session.getBuildConfig(build_tag, event=event_id)
koji_platforms = koji_build_conf['arches']
if not koji_platforms:
self.log.info("No platforms found in koji target")
return None
platforms = koji_platforms.split()
if is_scratch_build() or is_isolated_build():
override_platforms = get_orchestrator_platforms(self.workflow)
if override_platforms and set(override_platforms) != koji_platforms:
# platforms from user params do not match platforms from koji target
# that almost certainly means they were overridden and should be used
return set(override_platforms)
return get_platforms_in_limits(self.workflow, platforms)
def __init__(self, tasker, workflow,
smtp_host=None, from_address=None,
send_on=(AUTO_CANCELED, AUTO_FAIL, MANUAL_SUCCESS, MANUAL_FAIL),
url=None,
error_addresses=(),
additional_addresses=(),
email_domain=None,
koji_hub=None,
koji_root=None,
koji_proxyuser=None,
koji_ssl_certs_dir=None,
koji_krb_principal=None,
koji_krb_keytab=None,
to_koji_submitter=False,
to_koji_pkgowner=False,
use_auth=None,
verify_ssl=None):
"""
constructor
:param tasker: DockerTasker instance
:param workflow: DockerBuildWorkflow instance
:param send_on: list of str, list of build states when a notification should be sent
see 'allowed_states' constant and rules in '_should_send' function
:param url: str, URL to OSv3 instance where the build logs are stored
:param smtp_host: str, URL of SMTP server to use to send the message (e.g. "foo.com:25")
:param from_address: str, the "From" of the notification email
:param error_addresses: list of str, list of email addresses where to send an email
if an error occurred (e.g. if we can't find out who to notify about the failed build)
:param additional_addresses: list of str, always send a message to these email addresses
:param email_domain: str, email domain used when email addresses cannot be fetched via
kerberos principal
:param koji_hub: str, koji hub (xmlrpc)
:param koji_root: str, koji root (storage)
:param koji_proxyuser: str, proxy user
:param koji_ssl_certs_dir: str, path to "cert", "ca", and "serverca"
:param koji_krb_principal: str, name of Kerberos principal
:param koji_krb_keytab: str, Kerberos keytab
:param to_koji_submitter: bool, send a message to the koji submitter
:param to_koji_pkgowner: bool, send messages to koji package owners
"""
super(SendMailPlugin, self).__init__(tasker, workflow)
self.submitter = self.DEFAULT_SUBMITTER
self.send_on = set(send_on)
self.smtp_fallback = {
'host': smtp_host,
'from_address': from_address,
'additional_addresses': list(additional_addresses),
'error_addresses': list(error_addresses),
'domain': email_domain,
'send_to_submitter': to_koji_submitter,
'send_to_pkg_owner': to_koji_pkgowner
}
smtp = get_smtp(self.workflow, self.smtp_fallback)
self.additional_addresses = smtp.get('additional_addresses', ())
self.from_address = smtp['from_address']
self.error_addresses = smtp.get('error_addresses', ())
self.email_domain = smtp.get('domain')
self.to_koji_submitter = smtp.get('send_to_submitter', False)
self.to_koji_pkgowner = smtp.get('send_to_pkg_owner', False)
self.koji_fallback = {
'hub_url': koji_hub,
'root_url': koji_root,
'auth': {
'proxyuser': koji_proxyuser,
'ssl_certs_dir': koji_ssl_certs_dir,
'krb_principal': str(koji_krb_principal),
'krb_keytab_path': str(koji_krb_keytab)
}
}
self.openshift_fallback = {
'url': url,
'insecure': not verify_ssl,
'auth': {'enable': use_auth}
}
self.url = get_openshift(self.workflow, self.openshift_fallback)['url']
try:
metadata = get_build_json().get("metadata", {})
self.koji_task_id = int(metadata['labels']['koji-task-id'])
except Exception:
self.log.exception("Failed to fetch koji task ID")
self.koji_task_id = None
else:
self.log.info("Koji task ID: %s", self.koji_task_id)
self.koji_build_id = self.workflow.exit_results.get(KojiImportPlugin.key)
if not self.koji_build_id:
self.koji_build_id = self.workflow.exit_results.get(KojiPromotePlugin.key)
if not self.koji_build_id:
self.log.info("Failed to fetch koji build ID")
else:
self.log.info("Koji build ID: %s", self.koji_build_id)
else:
self.log.info("Koji build ID: %s", self.koji_build_id)
self.session = None
if get_koji(self.workflow, self.koji_fallback)['hub_url']:
try:
self.session = get_koji_session(self.workflow, self.koji_fallback)
except Exception:
self.log.exception("Failed to connect to koji")
self.session = None
else:
self.log.info("Koji connection established")
def koji_session(self):
if not self._koji_session:
self._koji_session = get_koji_session(self.workflow, self.koji_fallback)
return self._koji_session
