def retry_tmpfunc():
# Using develop=True to not authenticate to the server
pdc_session = PDCClient(common.conf["pdc"]["pdc_server"],
ssl_verify=True,
develop=True)
core.print_debug(pdc_session, pdc_query)
return pdc_session(**pdc_query)
def retry_tmpfunc():
# Using develop=True to not authenticate to the server
pdc_session = PDCClient(PDC_SERVER,
ssl_verify=True,
develop=True)
print_debug(pdc_session, pdc_query)
return pdc_session(**pdc_query)
def get_pdc_session(workflow, fallback):
config = get_pdc(workflow, fallback)
from pdc_client import PDCClient
return PDCClient(server=config['api_url'],
ssl_verify=not config.get('insecure', False),
develop=True)
def _query_pdc(self, module_name, stream):
"""
Check if module and stream are built successfully on PDC server
"""
pdc_server = "https://pdc.fedoraproject.org/rest_api/v1/unreleasedvariants"
#Using develop=True to not authenticate to the server
pdc_session = PDCClient(pdc_server, ssl_verify=True, develop=True)
pdc_query = dict(
variant_id = module_name,
variant_version = stream,
#active=True returns only succesful builds
active = True
)
try:
mod_info = pdc_session(**pdc_query)
except Exception as ex:
self.error("Could not query PDC server for %s (stream: %s) - %s" % (
module_name, stream, ex))
if not mod_info or "results" not in mod_info.keys() or not mod_info["results"]:
self.error("%s (stream: %s) is not available on PDC" % (
module_name, stream))
def __getDataFromPdc(self):
"""
Internal method, do not use it
:return: None
"""
# Using develop=True to not authenticate to the server
pdc_session = PDCClient(PDC_SERVER, ssl_verify=True, develop=True)
pdc_query = { 'variant_id' : self.name, 'active': True }
if self.stream:
pdc_query['variant_version'] = self.stream
if self.version:
pdc_query['variant_release'] = self.version
try:
mod_info = pdc_session(**pdc_query)
except Exception as ex:
raise PDCExc("Could not query PDC server", ex)
if not mod_info or "results" not in mod_info.keys() or not mod_info["results"]:
raise PDCExc("QUERY: %s is not available on PDC" % pdc_query)
self.pdcdata = mod_info["results"][-1]
self.modulemd = yaml.load(self.pdcdata["modulemd"])
def get_modulemd(module_name, stream):
"""
Check if module and stream are built successfully on PDC server
"""
pdc_server = "https://pdc.fedoraproject.org/rest_api/v1/unreleasedvariants"
#Using develop=True to not authenticate to the server
pdc_session = PDCClient(pdc_server, ssl_verify=True, develop=True)
pdc_query = dict(
variant_id = module_name,
variant_version = stream,
fields="modulemd",
ordering="variant_release",
#active=True returns only succesful builds
active = True,
)
try:
mod_info = pdc_session(**pdc_query)
except Exception as ex:
raise IOError("Could not query PDC server for %s (stream: %s) - %s" % (
module_name, stream, ex))
if not mod_info or "results" not in mod_info.keys() or not mod_info["results"]:
raise IOError("%s (stream: %s) is not available on PDC" % (
module_name, stream))
return yaml.load(mod_info["results"][-1]["modulemd"], Loader=Loader)
def _resolve_compose(self):
if self.odcs_openidc_secret_path:
token_path = os.path.join(self.odcs_openidc_secret_path, 'token')
with open(token_path, "r") as f:
odcs_token = f.read().strip()
else:
odcs_token = None
odcs_client = ODCSClient(self.odcs_url,
insecure=self.odcs_insecure,
token=odcs_token)
# The effect of develop=True is that requests to the PDC are made without authentication;
# since we our interaction with the PDC is read-only, this is fine for our needs and
# makes things simpler.
pdc_client = PDCClient(server=self.pdc_url,
ssl_verify=not self.pdc_insecure,
develop=True)
fmt = '{n}-{s}' if self.module_version is None else '{n}-{s}-{v}'
source_spec = fmt.format(n=self.module_name,
s=self.module_stream,
v=self.module_version)
if self.compose_id is None:
self.compose_id = odcs_client.start_compose(
source_type='module', source=source_spec)['id']
compose_info = odcs_client.wait_for_compose(self.compose_id)
if compose_info['state_name'] != "done":
raise RuntimeError("Compose cannot be retrieved, state='%s'" %
compose_info['state_name'])
compose_source = compose_info['source']
self.log.info("Resolved list of modules: %s", compose_source)
resolved_modules = {}
for module_spec in compose_source.strip().split():
m = re.match(r'^(.*)-([^-]+)-(\d{14})$', module_spec)
if not m:
raise RuntimeError(
"Cannot parse resolved module in compose: %s" %
module_spec)
module_name = m.group(1)
module_stream = m.group(2)
module_version = m.group(3)
query = {
'variant_id': module_name,
'variant_version': module_stream,
'variant_release': module_version,
'active': True,
}
self.log.info("Looking up module metadata for '%s' in the PDC",
module_spec)
retval = pdc_client['unreleasedvariants/'](
page_size=-1, fields=['modulemd', 'rpms'], **query)
# Error handling
if not retval:
raise RuntimeError("Failed to find module in PDC %r" % query)
if len(retval) != 1:
raise RuntimeError("Multiple modules in the PDC matched %r" %
query)
mmd = ModuleMetadata()
mmd.loads(retval[0]['modulemd'])
rpms = set(retval[0]['rpms'])
resolved_modules[module_name] = ModuleInfo(module_name,
module_stream,
module_version, mmd,
rpms)
base_module = resolved_modules[self.module_name]
assert base_module.stream == self.module_stream
if self.module_version is not None:
assert base_module.version == self.module_version
return ComposeInfo(source_spec=source_spec,
compose_id=self.compose_id,
base_module=base_module,
modules=resolved_modules,
repo_url=compose_info['result_repo'] +
'/$basearch/os/')
compose_id = _find_latest_compose_id_for_release(release)
if not compose_id:
print "The release %s doesn't exist or no compose in it." % release
exit(1)
srpm_name_result = _find_src_rpm_names_for_compose(compose_id)
if srpm_name_result:
_generate_global_components(srpm_name_result)
_generate_release_components(release, srpm_name_result)
if __name__ == '__main__':
parser = argparse.ArgumentParser(
description='Create release components according release id')
parser.add_argument('-s',
'--server',
help='PDC instance url or shortcut.',
required=True)
parser.add_argument("-r",
"--release",
help="release id for a release.",
required=True)
options = parser.parse_args()
try:
client = PDCClient(options.server)
main(options.release)
except BeanBagException as e:
print "%d %s" % (e.response.status_code, e.response.content)
except Exception as e:
print str(e)