def osbs(self):
"""Handler of OSBS object"""
if not self._osbs:
os_conf = Configuration()
build_conf = Configuration()
if self.opts.get('scratch'):
os_conf = Configuration(conf_section='scratch')
build_conf = Configuration(conf_section='scratch')
self._osbs = OSBS(os_conf, build_conf)
assert self._osbs
return self._osbs
def osbs(self):
"""Handler of OSBS object"""
if not self._osbs:
os_conf = Configuration()
build_conf = Configuration()
if self.opts.get('scratch'):
os_conf = Configuration(conf_section='scratch')
build_conf = Configuration(conf_section='scratch')
self._osbs = OSBS(os_conf, build_conf)
if not self._osbs:
msg = 'Could not successfully instantiate `osbs`'
raise ContainerError(msg)
self.setup_osbs_logging()
return self._osbs
def get_sample_build_conf(conf_args=None):
conf_params = {
'build_from': 'image:buildroot:latest',
}
if conf_args:
conf_params.update(conf_args)
return Configuration(conf_file=None, **conf_params)
def run(self):
try:
build_json = json.loads(os.environ["BUILD"])
except KeyError:
self.log.error("No $BUILD env variable. "
"Probably not running in build container.")
raise
osbs_conf = Configuration(conf_file=None,
openshift_uri=self.url,
use_auth=self.use_auth,
verify_ssl=self.verify_ssl)
osbs = OSBS(osbs_conf, osbs_conf)
metadata = build_json.get("metadata", {})
kwargs = {}
if 'namespace' in metadata:
kwargs['namespace'] = metadata['namespace']
labels = metadata.get("labels", {})
try:
imagestream = labels["imagestream"]
except KeyError:
self.log.error("No imagestream label set for this Build")
raise
self.log.info("Importing tags for %s", imagestream)
osbs.import_image(imagestream, **kwargs)
def get_cluster_info(self, cluster, platform):
kwargs = deepcopy(self.config_kwargs)
kwargs['conf_section'] = cluster.name
if self.osbs_client_config:
kwargs['conf_file'] = os.path.join(self.osbs_client_config,
'osbs.conf')
conf = Configuration(**kwargs)
osbs = OSBS(conf, conf)
try:
current_builds = self.get_current_builds(osbs)
except OsbsException as e:
# If the build is canceled reraise the error
if isinstance(e.cause, BuildCanceledException):
raise e
self.log.exception("Error occurred while listing builds on %s",
cluster.name)
return ClusterInfo(cluster, platform, osbs,
self.UNREACHABLE_CLUSTER_LOAD)
load = current_builds / cluster.max_concurrent_builds
self.log.debug(
'enabled cluster %s for platform %s has load %s and active builds %s/%s',
cluster.name, platform, load, current_builds,
cluster.max_concurrent_builds)
return ClusterInfo(cluster, platform, osbs, load)
def get_openshift_session(workflow, fallback):
config = get_openshift(workflow, fallback)
namespace = get_build_json().get('metadata', {}).get('namespace', None)
from osbs.api import OSBS
from osbs.conf import Configuration
config_kwargs = {
'verify_ssl': not config.get('insecure', False),
'namespace': namespace,
'use_auth': False,
'conf_file': None,
'openshift_url': config['url'],
'build_json_dir': config.get('build_json_dir')
}
if config.get('auth'):
krb_keytab_path = config['auth'].get('krb_keytab_path')
if krb_keytab_path:
config_kwargs['kerberos_keytab'] = krb_keytab_path
krb_principal = config['auth'].get('krb_principal')
if krb_principal:
config_kwargs['kerberos_principal'] = krb_principal
krb_cache_path = config['auth'].get('krb_cache_path')
if krb_cache_path:
config_kwargs['kerberos_ccache'] = krb_cache_path
ssl_certs_dir = config['auth'].get('ssl_certs_dir')
if ssl_certs_dir:
config_kwargs['client_cert'] = os.path.join(ssl_certs_dir, 'cert')
config_kwargs['client_key'] = os.path.join(ssl_certs_dir, 'key')
config_kwargs['use_auth'] = config['auth'].get('enable', False)
osbs_conf = Configuration(**config_kwargs)
return OSBS(osbs_conf, osbs_conf)
def osbs(request, openshift):
kwargs = request.param['kwargs'] or {}
kwargs.setdefault('build_json_dir', 'inputs')
kwargs.setdefault('additional_general', '')
with NamedTemporaryFile(mode="wt") as fp:
config = dedent("""\
[general]
build_json_dir = {build_json_dir}
{additional_general}
[default]
openshift_url = /
flatpak_base_image = registry.fedoraproject.org/fedora:latest
can_orchestrate = true
use_auth = false
build_from = image:buildroot:latest
""")
if request.param['additional_config'] is not None:
config += request.param['additional_config']
config += '\n'
fp.write(config.format(**kwargs))
fp.flush()
dummy_config = Configuration(fp.name)
osbs = OSBS(dummy_config, dummy_config)
osbs.os = openshift
return osbs
def test_scratch_param_to_create_build(self):
config = Configuration()
osbs = OSBS(config, config)
class MockParser(object):
labels = {'Name': 'fedora23/something'}
baseimage = 'fedora23/python'
kwargs = {
'git_uri': TEST_GIT_URI,
'git_ref': TEST_GIT_REF,
'git_branch': TEST_GIT_BRANCH,
'user': TEST_USER,
'component': TEST_COMPONENT,
'target': TEST_TARGET,
'architecture': TEST_ARCH,
'yum_repourls': None,
'koji_task_id': None,
'scratch': True,
}
(flexmock(utils).should_receive('get_df_parser').with_args(
TEST_GIT_URI, TEST_GIT_REF,
git_branch=TEST_GIT_BRANCH).and_return(MockParser()))
(flexmock(osbs).should_receive(
'_create_scratch_build').once().and_return(
flexmock(json=lambda: {'spam': 'maps'})))
(flexmock(osbs.os).should_receive('create_build_config').never())
(flexmock(osbs.os).should_receive('update_build_config').never())
build_response = osbs.create_build(**kwargs)
assert build_response.json() == {'spam': 'maps'}
def get_openshift_session(config, namespace):
from osbs.api import OSBS
from osbs.conf import Configuration
config_kwargs = {
'verify_ssl': not config.openshift.get('insecure', False),
'namespace': namespace,
'use_auth': False,
'conf_file': None,
'openshift_url': config.openshift['url'],
}
if config.openshift.get('auth'):
krb_keytab_path = config.openshift['auth'].get('krb_keytab_path')
if krb_keytab_path:
config_kwargs['kerberos_keytab'] = krb_keytab_path
krb_principal = config.openshift['auth'].get('krb_principal')
if krb_principal:
config_kwargs['kerberos_principal'] = krb_principal
krb_cache_path = config.openshift['auth'].get('krb_cache_path')
if krb_cache_path:
config_kwargs['kerberos_ccache'] = krb_cache_path
ssl_certs_dir = config.openshift['auth'].get('ssl_certs_dir')
if ssl_certs_dir:
config_kwargs['client_cert'] = os.path.join(ssl_certs_dir, 'cert')
config_kwargs['client_key'] = os.path.join(ssl_certs_dir, 'key')
config_kwargs['use_auth'] = config.openshift['auth'].get(
'enable', False)
osbs_conf = Configuration(**config_kwargs)
return OSBS(osbs_conf)
def test_create_build_config_already_running(self):
config = Configuration()
osbs = OSBS(config, config)
build_json = {
'apiVersion': osbs.os_conf.get_openshift_api_version(),
'metadata': {
'name': 'build',
'labels': {
'git-repo-name': 'reponame',
'git-branch': 'branch',
},
},
}
existing_build_json = copy.deepcopy(build_json)
existing_build_json['metadata']['name'] = 'existing-build'
build_request = flexmock(render=lambda: build_json,
is_auto_instantiated=lambda: False)
(flexmock(osbs).should_receive('_get_existing_build_config').once().
and_return(existing_build_json))
(flexmock(osbs).should_receive(
'_get_running_builds_for_build_config').once().and_return([
flexmock(status='Running', get_build_name=lambda: 'build-1'),
]))
with pytest.raises(OsbsException):
osbs._create_build_config_and_build(build_request)
def cmd_build_source_container(args):
if args.instance is None:
conf_section = DEFAULT_CONF_SOURCE_SECTION
else:
conf_section = args.instance
os_conf = Configuration(conf_file=args.config,
conf_section=conf_section,
cli_args=args)
osbs = OSBS(os_conf)
build_kwargs = {
'user': osbs.os_conf.get_user(),
'target': osbs.os_conf.get_koji_target(),
'scratch': args.scratch,
'signing_intent': args.signing_intent,
'sources_for_koji_build_nvr': args.sources_for_koji_build_nvr,
'sources_for_koji_build_id': args.sources_for_koji_build_id,
'component': args.component,
}
if args.userdata:
build_kwargs['userdata'] = json.loads(args.userdata)
pipeline_run = osbs.create_source_container_pipeline_run(**build_kwargs)
print_output(pipeline_run, export_metadata_file=args.export_metadata_file)
return_val = -1
if pipeline_run.has_succeeded():
return_val = 0
return return_val
def osbs106(openshift):
with NamedTemporaryFile(mode="wt") as fp:
fp.write("""
[general]
build_json_dir = {build_json_dir}
openshift_required_version = 1.0.6
[default]
openshift_url = /
registry_uri = registry.example.com
sources_command = fedpkg sources
vendor = Example, Inc.
build_host = localhost
authoritative_registry = registry.example.com
distribution_scope = authoritative-source-only
koji_root = http://koji.example.com/kojiroot
koji_hub = http://koji.example.com/kojihub
use_auth = false
build_from = image:buildroot:latest
""".format(build_json_dir="inputs"))
fp.flush()
dummy_config = Configuration(fp.name)
osbs = OSBS(dummy_config, dummy_config)
osbs.os = openshift
return osbs
def osbs_for_capture(tmpdir):
kwargs = {
'build_json_dir': 'inputs',
'openshift_url': OPENSHIFT_URL,
'namespace': TEST_OCP_NAMESPACE
}
with NamedTemporaryFile(mode="wt") as fp:
config = dedent("""\
[general]
build_json_dir = {build_json_dir}
[default]
openshift_url = {openshift_url}
use_auth = false
namespace = {namespace}
""")
fp.write(config.format(**kwargs))
fp.flush()
dummy_config = Configuration(fp.name, conf_section='default')
osbs = OSBS(dummy_config)
setup_json_capture(osbs, osbs.os_conf, str(tmpdir))
return osbs
def get_build_request(
self,
build_type,
osbs, # noqa:F811
additional_params=None):
base_image = additional_params.pop('base_image', None)
self.mock_env(base_image=base_image,
additional_tags=additional_params.get('additional_tags'),
flatpak=additional_params.get('flatpak'))
params = self.COMMON_PARAMS.copy()
assert build_type in ('orchestrator', 'worker', 'source_container')
if build_type == 'orchestrator':
params.update(self.ORCHESTRATOR_ADD_PARAMS)
fn = osbs.create_orchestrator_build
elif build_type == 'worker':
params.update(self.WORKER_ADD_PARAMS)
fn = osbs.create_worker_build
elif build_type == 'source_container':
params.update(self.ORCHESTRATOR_ADD_PARAMS)
fn = osbs.create_source_container_build
params.update(additional_params or {})
params['arrangement_version'] = self.ARRANGEMENT_VERSION
osbs.build_conf = osbs.build_conf or Configuration(params)
return params, fn(**params).json
def test_create_build_config_label_mismatch(self):
config = Configuration()
osbs = OSBS(config, config)
build_json = {
'apiVersion': osbs.os_conf.get_openshift_api_version(),
'metadata': {
'name': 'build',
'labels': {
'git-repo-name': 'reponame',
'git-branch': 'branch',
},
},
}
existing_build_json = copy.deepcopy(build_json)
existing_build_json['metadata']['name'] = 'build'
existing_build_json['metadata']['labels'][
'git-repo-name'] = 'reponame2'
existing_build_json['metadata']['labels']['git-branch'] = 'branch2'
build_request = flexmock(render=lambda: build_json,
is_auto_instantiated=lambda: False)
(flexmock(osbs).should_receive('_get_existing_build_config').once().
and_return(existing_build_json))
with pytest.raises(OsbsValidationException) as exc:
osbs._create_build_config_and_build(build_request)
assert 'Git labels collide' in str(exc.value)
def run(self):
"""
run the plugin
"""
try:
build_json = json.loads(os.environ["BUILD"])
except KeyError:
self.log.error("No $BUILD env variable. Probably not running in build container")
raise
metadata = build_json.get("metadata", {})
labels = metadata.get("labels", {})
buildconfig = labels["buildconfig"]
is_rebuild = labels.get(self.label_key) == self.label_value
self.log.info("This is a rebuild? %s", is_rebuild)
if not is_rebuild:
# Update the BuildConfig metadata so the next Build
# instantiated from it is detected as being an automated
# rebuild
kwargs = {}
if 'namespace' in metadata:
kwargs['namespace'] = metadata['namespace']
# FIXME: remove `openshift_uri` once osbs-client is released
osbs_conf = Configuration(conf_file=None, openshift_uri=self.url,
openshift_url=self.url,
use_auth=self.use_auth,
verify_ssl=self.verify_ssl)
osbs = OSBS(osbs_conf, osbs_conf)
labels = {self.label_key: self.label_value}
osbs.set_labels_on_build_config(buildconfig, labels, **kwargs)
return is_rebuild
def test_get_existing_build_config_by_name(self):
build_config = {
'metadata': {
'name': 'name',
'labels': {
'git-repo-name': 'reponame',
'git-branch': 'branch',
}
},
}
existing_build_config = copy.deepcopy(build_config)
existing_build_config['_from'] = 'from-name'
config = Configuration()
osbs = OSBS(config, config)
(flexmock(
osbs.os).should_receive('get_build_config_by_labels').with_args([
('git-repo-name', 'reponame'), ('git-branch', 'branch')
]).once().and_raise(OsbsException))
(flexmock(osbs.os).should_receive('get_build_config').with_args(
'name').once().and_return(existing_build_config))
actual_build_config = osbs._get_existing_build_config(build_config)
assert actual_build_config == existing_build_config
assert actual_build_config['_from'] == 'from-name'
def test_create_build_config_create(self):
config = Configuration()
osbs = OSBS(config, config)
build_json = {
'apiVersion': osbs.os_conf.get_openshift_api_version(),
'metadata': {
'name': 'build',
'labels': {
'git-repo-name': 'reponame',
'git-branch': 'branch',
},
},
}
build_request = flexmock(render=lambda: build_json,
is_auto_instantiated=lambda: False)
(flexmock(osbs).should_receive(
'_get_existing_build_config').once().and_return(None))
(flexmock(osbs.os).should_receive('create_build_config').with_args(
json.dumps(build_json)).once().and_return(
flexmock(json=lambda: {'spam': 'maps'})))
(flexmock(osbs.os).should_receive(
'start_build').with_args('build').once().and_return(
flexmock(json=lambda: {'spam': 'maps'})))
build_response = osbs._create_build_config_and_build(build_request)
assert build_response.json == {'spam': 'maps'}
def test_verify_no_running_builds_zero(self):
config = Configuration()
osbs = OSBS(config, config)
(flexmock(osbs).should_receive('_get_running_builds_for_build_config').
with_args('build_config_name').once().and_return([]))
osbs._verify_no_running_builds('build_config_name')
def test_get_platform_descriptors(self, config, expected, valid):
with self.config_file(config) as config_file:
conf = Configuration(conf_file=config_file)
if valid:
assert conf.get_platform_descriptors() == expected
else:
with pytest.raises(OsbsValidationException):
conf.get_platform_descriptors()
def test_param_retrieval(self, config, kwargs, cli_args, expected):
with self.build_cli_args(cli_args) as args:
with self.config_file(config) as config_file:
conf = Configuration(conf_file=config_file, cli_args=args,
**kwargs)
for fn, value in expected.items():
assert getattr(conf, fn)() == value
def test_render_orchestrate_build(self, tmpdir, platforms,
build_from, worker_build_image,
is_flatpak, koji_parent_build, valid, image_only):
phase = 'buildstep_plugins'
plugin = 'orchestrate_build'
conf_args = {
'build_from': build_from,
'reactor_config_map': 'reactor-config-map',
}
extra_args = {
'base_image': 'fedora:latest',
'flatpak': is_flatpak,
'name_label': 'fedora/resultingimage',
'platforms': platforms,
'reactor_config_override': 'reactor-config-override',
'user': "******",
}
if koji_parent_build:
extra_args['koji_parent_build'] = koji_parent_build
if valid:
user_params = get_sample_user_params(conf_args=conf_args, extra_args=extra_args)
build_json = PluginsConfiguration(user_params).render()
else:
with pytest.raises(OsbsValidationException):
user_params = get_sample_user_params(conf_args=conf_args, extra_args=extra_args)
build_json = PluginsConfiguration(user_params).render()
return
plugins = get_plugins_from_build_json(build_json)
if platforms is None:
platforms = {}
assert plugin_value_get(plugins, phase, plugin, 'args', 'platforms') == platforms or {}
build_kwargs = plugin_value_get(plugins, phase, plugin, 'args', 'build_kwargs')
assert build_kwargs['arrangement_version'] == REACTOR_CONFIG_ARRANGEMENT_VERSION
assert build_kwargs.get('koji_parent_build') == koji_parent_build
assert build_kwargs.get('reactor_config_map') == 'reactor-config-map'
assert build_kwargs.get('reactor_config_override') == 'reactor-config-override'
worker_config_kwargs = plugin_value_get(plugins, phase, plugin, 'args',
'config_kwargs')
worker_config = Configuration(conf_file=None, **worker_config_kwargs)
if worker_build_image is KeyError:
assert not worker_config.get_build_from()
else:
if image_only:
assert worker_config_kwargs['build_from'] == worker_build_image
assert worker_config.get_build_from() == worker_build_image
else:
assert 'build_from' not in worker_config_kwargs
assert not worker_config.get_build_from()
if is_flatpak:
assert user_params.flatpak
def test_arrangement_version(self, config, expected):
with self.config_file(config) as config_file:
conf = Configuration(conf_file=config_file)
if isinstance(expected, type):
with pytest.raises(expected):
conf.get_arrangement_version()
else:
assert conf.get_arrangement_version() == expected
def setup_osbs_api(self):
metadata = get_build_json().get("metadata", {})
osbs_conf = Configuration(conf_file=None,
openshift_url=self.url,
use_auth=self.use_auth,
verify_ssl=self.verify_ssl,
build_json_dir=self.build_json_dir,
namespace=metadata.get('namespace', None))
self.osbs = OSBS(osbs_conf, osbs_conf)
def test_get_token_secrets(self, config, expected):
with self.config_file(config) as config_file:
conf = Configuration(conf_file=config_file)
if expected is not OsbsValidationException:
assert conf.get_token_secrets() == expected
else:
with pytest.raises(OsbsValidationException):
conf.get_token_secrets()
def test_create_build_config_bad_version(self):
config = Configuration()
osbs = OSBS(config, config)
build_json = {'apiVersion': 'spam'}
build_request = flexmock(render=lambda: build_json,
is_auto_instantiated=lambda: False)
with pytest.raises(OsbsValidationException):
osbs._create_build_config_and_build(build_request)
def test_get_equal_labels(self, config, expected):
with self.config_file(config) as config_file:
conf = Configuration(conf_file=config_file)
if expected is OsbsValidationException:
with pytest.raises(OsbsValidationException):
conf.get_equal_labels()
else:
assert conf.get_equal_labels() == expected
def test_get_registry_api_versions(self, platform, config, expected,
valid):
with self.config_file(config) as config_file:
conf = Configuration(conf_file=config_file)
if valid:
assert conf.get_registry_api_versions(platform) == expected
else:
with pytest.raises(OsbsValidationException):
conf.get_registry_api_versions(platform)
def get_minimal_kwargs(self, origin_nvr, conf_args=None):
if not conf_args:
conf_args = {'build_from': 'image:buildroot:latest'}
return {
# Params needed to avoid exceptions.
'build_conf': Configuration(**conf_args),
'user': TEST_USER,
'sources_for_koji_build_nvr': origin_nvr,
}
def __init__(self,
tasker,
workflow,
kojihub,
url,
verify_ssl=True,
use_auth=True,
koji_ssl_certs=None,
koji_proxy_user=None,
koji_principal=None,
koji_keytab=None,
metadata_only=False,
blocksize=None,
target=None,
poll_interval=5):
"""
constructor
:param tasker: DockerTasker instance
:param workflow: DockerBuildWorkflow instance
:param kojihub: string, koji hub (xmlrpc)
:param url: string, URL for OSv3 instance
:param verify_ssl: bool, verify OSv3 SSL certificate?
:param use_auth: bool, initiate authentication with OSv3?
:param koji_ssl_certs: str, path to 'cert', 'ca', 'serverca'
:param koji_proxy_user: str, user to log in as (requires hub config)
:param koji_principal: str, Kerberos principal (must specify keytab)
:param koji_keytab: str, keytab name (must specify principal)
:param metadata_only: bool, whether to omit the 'docker save' image
:param blocksize: int, blocksize to use for uploading files
:param target: str, koji target
:param poll_interval: int, seconds between Koji task status requests
"""
super(KojiPromotePlugin, self).__init__(tasker, workflow)
self.kojihub = kojihub
self.koji_ssl_certs = koji_ssl_certs
self.koji_proxy_user = koji_proxy_user
self.koji_principal = koji_principal
self.koji_keytab = koji_keytab
self.metadata_only = metadata_only
self.blocksize = blocksize
self.target = target
self.poll_interval = poll_interval
self.namespace = get_build_json().get('metadata',
{}).get('namespace', None)
osbs_conf = Configuration(conf_file=None,
openshift_uri=url,
use_auth=use_auth,
verify_ssl=verify_ssl,
namespace=self.namespace)
self.osbs = OSBS(osbs_conf, osbs_conf)
self.build_id = None
self.pullspec_image = None
