def test_optparse_value(self):
rel = koji.grab_session_options(optparse.Values(NORMAL_VAL))
self.assertEqual(rel, NORMAL_VAL)
rel = koji.grab_session_options(optparse.Values(EMPTY_VAL))
self.assertEqual(rel, EMPTY_VAL)
rel = koji.grab_session_options(optparse.Values(NONE_VAL))
self.assertEqual(rel, {})
rel = koji.grab_session_options(optparse.Values(MEANINGLESS_VAL))
self.assertEqual(rel, {})
rel = koji.grab_session_options(optparse.Values(MIXED_VAL))
self.assertEqual(rel, MIXED_REL)
def test_dict(self):
rel = koji.grab_session_options(NORMAL_VAL)
self.assertEqual(rel, NORMAL_VAL)
rel = koji.grab_session_options(EMPTY_VAL)
self.assertEqual(rel, EMPTY_VAL)
rel = koji.grab_session_options(NONE_VAL)
self.assertEqual(rel, {})
rel = koji.grab_session_options(MEANINGLESS_VAL)
self.assertEqual(rel, {})
rel = koji.grab_session_options(MIXED_VAL)
self.assertEqual(rel, MIXED_REL)
def tag_build(nvr, dest_tags):
"""Tag build with specific tags
Calling Koji API to tag build might fail, however successful tagged tag will
be returned and to log the failed tag operation.
:param str nvr: build NVR.
:param dest_tags: tag names.
:type dest_tags: list[str]
:return: tag names which are tagged to build successfully.
:rtype: list[str]
"""
tagged_tags = []
koji_config = koji.read_config(conf.koji_profile)
session_opts = koji.grab_session_options(koji_config)
koji_session = koji.ClientSession(koji_config['server'], opts=session_opts)
login_koji(koji_session, koji_config)
for tag in dest_tags:
try:
if conf.dry_run:
logger.info("DRY-RUN: koji_session.tagBuild('%s', '%s')", tag, nvr)
else:
koji_session.tagBuild(tag, nvr)
except Exception:
logger.exception('Failed to tag %s to build %s', tag, nvr)
else:
tagged_tags.append(tag)
koji_session.logout()
return tagged_tags
def make_koji_session():
koji_config = koji.read_config(conf.koji_profile)
session_opts = koji.grab_session_options(koji_config)
koji_session = koji.ClientSession(koji_config['server'], opts=session_opts)
login_koji(koji_session, koji_config)
yield koji_session
koji_session.logout()
def main():
module = build()
config = {'server': module.params['server']}
if 'ssl_auth' in module.params:
config.update(**ssl_config(module))
else:
module.fail_json(changed=False,
skipped=False,
failed=True,
error='Missing authentication config')
options = Values(config)
session_opts = koji.grab_session_options(options)
session = koji.ClientSession(options.server, session_opts)
try:
session.ssl_login(options.cert, None, options.serverca)
except Exception as e:
module.fail_json(changed=False,
skipped=False,
failed=True,
error=str(e))
username = module.params['username']
perms = module.params['permissions']
user = session.getUser(username)
if not user:
try:
user = session.createUser(username)
except Exception as e:
module.fail_json(changed=False,
skipped=False,
failed=True,
error=str(e))
for perm in perms:
try:
session.grantPermission(user, perm, True)
except Exception as e:
if not 'already has permission' in str(e):
module.fail_json(changed=False,
skipped=False,
failed=True,
msg=str(e))
module.exit_json(changed=True,
skipped=False,
failed=False,
result={
'username': username,
'perms': session.getUserPerms(user['id'])
})
def load_anon_kojisession(self):
"""Initiate a koji session."""
logger = logging.getLogger("load_anon_kojisession")
koji_config = koji.read_config(self.kojiprofile)
logger.debug('Initiating a brew session to %s',
os.path.basename(koji_config['server']))
# Build session options used to create instance of ClientSession
session_opts = koji.grab_session_options(koji_config)
try:
session = koji.ClientSession(koji_config['server'], session_opts)
except Exception:
raise Exception('Could not initiate brew session')
else:
return session
def __init__(self, output, base):
self.output = output
self.base = base
self.base_update_info = {}
self.update_info = {}
self.build_id_to_nvr = {}
self.module_nvr_short_to_nvr = {}
self.image_packages = set()
if self.base:
self._load_build_ids(self.base)
self._load_update_info(self.base)
koji_config_file = os.path.join(os.path.dirname(__file__),
'../koji.conf')
options = koji.read_config(profile_name='fedora',
user_config=koji_config_file)
session_opts = koji.grab_session_options(options)
self.koji_session = koji.ClientSession(options['server'], session_opts)
def load_kojisession(self, anon=False):
"""Initiate a koji session.
The koji session can be logged in or anonymous
"""
koji_config = self.read_koji_config()
# Expand out the directory options
for name in ('cert', 'ca', 'serverca'):
path = koji_config[name]
if path:
koji_config[name] = os.path.expanduser(path)
# save the weburl and topurl for later use as well
self._kojiweburl = koji_config['weburl']
self._topurl = koji_config['topurl']
self.log.debug('Initiating a %s session to %s',
os.path.basename(self.build_client), koji_config['server'])
# Build session options used to create instance of ClientSession
session_opts = koji.grab_session_options(koji_config)
try:
session = koji.ClientSession(koji_config['server'], session_opts)
except Exception:
raise rpkgError('Could not initiate %s session' % os.path.basename(self.build_client))
else:
if anon:
self._anon_kojisession = session
else:
self._kojisession = session
if not anon:
try:
self.login_koji_session(koji_config, self._kojisession)
except pyrpkg.rpkgAuthError:
self.log.info("You might want to run rpmfusion-packager-setup to "
"regenerate SSL certificate. For more info see "
"https://fedoraproject.org/wiki/Using_the_Koji_build"
"_system#Fedora_Account_System_.28FAS2.29_Setup")
raise
def main():
"""
Main funtion that runs the module.
"""
module = build()
config = {'server': module.params['server']}
archs = module.params['archs']
channels = module.params['channels']
host_name = module.params['host']
if 'ssl_auth' in module.params:
config.update(**ssl_config(module))
else:
module.fail_json(changed=False,
skipped=False,
failed=True,
error='Missing authentication config')
options = Values(config)
session_opts = koji.grab_session_options(options)
session = koji.ClientSession(options.server, session_opts)
try:
session.ssl_login(options.cert, None, options.serverca)
except Exception as e:
module.fail_json(changed=False,
skipped=False,
failed=True,
error=str(e))
if not session.getHost(host_name):
try:
session.addHost(host_name, archs)
except Exception as e:
module.fail_json(changed=False,
skipped=False,
failed=True,
msg=str(e))
channel_errs = []
added_channels = []
for channel in channels:
try:
session.addHostToChannel(host_name, channel, create=True)
added_channels.append(channel)
except Exception as e:
if not str(e).endswith(
'is already subscribed to the %s channel' % channel):
channel_errs.append(str(e))
if len(channel_errs) > 0:
module.fail_json(changed=False,
skipped=False,
failed=True,
msg=dir(channel_errs[0]),
error='Add Channel Error: ' + str(channel_errs))
module.exit_json(changed=True,
skipped=False,
failed=False,
result={
'name': host_name,
'archs': archs,
'channels': added_channels
})
def koji_session() -> koji.ClientSession:
module = koji.get_profile_module("koji")
session_opts = koji.grab_session_options(module.config)
session = koji.ClientSession(module.config.server, session_opts)
return session