def process_list(self, api_version, data): # pylint: disable=unused-argument
"""
This method returns details for given set of Errata.
:param data: data obtained from api, we're interested in data["errata_list"]
:returns: dictionary containing detailed information for given errata list}
"""
validate(data, JSON_SCHEMA)
modified_since = data.get("modified_since", None)
modified_since_dt = parse_datetime(modified_since)
errata_to_process = data.get("errata_list", None)
page = data.get("page", None)
page_size = data.get("page_size", None)
response = {"errata_list": {}}
if modified_since:
response["modified_since"] = modified_since
if not errata_to_process:
return response
if len(errata_to_process) == 1:
# treat single-label like a regex, get all matching names
errata_to_process = self.find_errata_by_regex(errata_to_process[0])
filters = []
# if we have information about modified/published dates and receive "modified_since" in request,
# compare the dates
if modified_since:
filters.append((self._filter_modified_since, [modified_since_dt]))
errata_list = {}
errata_page_to_process, pagination_response = paginate(errata_to_process, page, page_size, filters=filters)
for errata in errata_page_to_process:
errata_detail = self.cache.errata_detail.get(errata, None)
if not errata_detail:
continue
errata_list[errata] = {
"synopsis": none2empty(errata_detail[ERRATA_SYNOPSIS]),
"summary": none2empty(errata_detail[ERRATA_SUMMARY]),
"type": none2empty(errata_detail[ERRATA_TYPE]),
"severity": none2empty(errata_detail[ERRATA_SEVERITY]),
"description": none2empty(errata_detail[ERRATA_DESCRIPTION]),
"solution": none2empty(errata_detail[ERRATA_SOLUTION]),
"issued": none2empty(format_datetime(errata_detail[ERRATA_ISSUED])),
"updated": none2empty(format_datetime(errata_detail[ERRATA_UPDATED])),
"cve_list": errata_detail[ERRATA_CVE],
"package_list": pkgidlist2packages(self.cache, errata_detail[ERRATA_PKGIDS]),
"bugzilla_list": errata_detail[ERRATA_BUGZILLA],
"reference_list": errata_detail[ERRATA_REFERENCE],
"url": none2empty(errata_detail[ERRATA_URL])
}
response["errata_list"] = errata_list
response.update(pagination_response)
return response
def process_list(self, api_version, data): # pylint: disable=unused-argument
"""
Returns package details.
:param data: json request parsed into data structure
:returns: json response with package details
"""
validate(data, JSON_SCHEMA)
packages = data.get('package_list', None)
packagelist = {}
if not packages:
return packagelist
for pkg in packages:
packagedata = packagelist.setdefault(pkg, {})
name, epoch, ver, rel, arch = utils.split_packagename(pkg)
if name in self.cache.packagename2id \
and (epoch, ver, rel) in self.cache.evr2id \
and arch in self.cache.arch2id:
name_id = self.cache.packagename2id[name]
evr_id = self.cache.evr2id[(epoch, ver, rel)]
arch_id = self.cache.arch2id[arch]
if (name_id, evr_id, arch_id) in self.cache.nevra2pkgid:
pkg_id = self.cache.nevra2pkgid[(name_id, evr_id, arch_id)]
pkg_detail = self.cache.package_details[pkg_id]
packagedata['summary'] = pkg_detail[PKG_SUMMARY]
packagedata['description'] = pkg_detail[PKG_DESC]
packagedata['source_package'] = self._get_source_package(
pkg_detail)
packagedata['repositories'] = []
packagedata[
'package_list'] = self._get_built_binary_packages(
pkg_id)
if pkg_id in self.cache.pkgid2repoids:
for repo_id in self.cache.pkgid2repoids[pkg_id]:
repodetail = self.cache.repo_detail[repo_id]
repodata = {
'label':
repodetail[REPO_LABEL],
'name':
repodetail[REPO_NAME],
'basearch':
utils.none2empty(repodetail[REPO_BASEARCH]),
'releasever':
utils.none2empty(repodetail[REPO_RELEASEVER])
}
packagedata['repositories'].append(repodata)
response = {'package_list': packagelist}
return response
def process_list(self, api_version, data): # pylint: disable=unused-argument
"""
Returns repository details.
:param data: json request parsed into data structure
:returns: json response with repository details
"""
validate(data, JSON_SCHEMA)
repos = data.get('repository_list', None)
page = data.get("page", None)
page_size = data.get("page_size", None)
repolist = {}
if not repos:
return repolist
if len(repos) == 1:
# treat single-label like a regex, get all matching names
repos = self.find_repos_by_regex(repos[0])
repo_page_to_process, pagination_response = paginate(
repos, page, page_size)
for label in repo_page_to_process:
for repo_id in self.cache.repolabel2ids.get(label, []):
repo_detail = self.cache.repo_detail[repo_id]
repolist.setdefault(label, []).append({
"label":
label,
"name":
repo_detail[REPO_NAME],
"url":
repo_detail[REPO_URL],
"basearch":
none2empty(repo_detail[REPO_BASEARCH]),
"releasever":
none2empty(repo_detail[REPO_RELEASEVER]),
"product":
repo_detail[REPO_PRODUCT],
"revision":
repo_detail[REPO_REVISION]
})
response = {
'repository_list': repolist,
}
response.update(pagination_response)
return response
def test_none2empty(self):
"""Test 'None' to "" conversion."""
assert utils.none2empty(None) == ""
def _process_updates(self, packages_to_process, api_version,
available_repo_ids, repo_ids_key, response,
module_ids):
# pylint: disable=too-many-branches
module_filter = module_ids is not None
for pkg, pkg_dict in packages_to_process.items():
name, epoch, ver, rel, arch = pkg_dict['parsed_nevra']
name_id = self.db_cache.packagename2id[name]
evr_id = self.db_cache.evr2id.get((epoch, ver, rel), None)
arch_id = self.db_cache.arch2id.get(arch, None)
current_evr_indexes = self.db_cache.updates_index[name_id].get(
evr_id, [])
# Package with given NEVRA not found in cache/DB
if not current_evr_indexes:
continue
current_nevra_pkg_id = None
for current_evr_index in current_evr_indexes:
pkg_id = self.db_cache.updates[name_id][current_evr_index]
current_nevra_arch_id = self.db_cache.package_details[pkg_id][
2]
if current_nevra_arch_id == arch_id:
current_nevra_pkg_id = pkg_id
break
# Package with given NEVRA not found in cache/DB
if not current_nevra_pkg_id:
continue
if api_version == 1:
response['update_list'][pkg]['summary'] = \
self.db_cache.package_details[current_nevra_pkg_id][3]
response['update_list'][pkg]['description'] = \
self.db_cache.package_details[current_nevra_pkg_id][4]
response['update_list'][pkg]['available_updates'] = []
# No updates found for given NEVRA
last_version_pkg_id = self.db_cache.updates[name_id][-1]
if last_version_pkg_id == current_nevra_pkg_id:
continue
# Get associated product IDs
original_package_repo_ids = set()
original_package_repo_ids.update(
self.db_cache.pkgid2repoids.get(current_nevra_pkg_id, []))
product_ids = self._get_related_products(original_package_repo_ids)
valid_releasevers = self._get_valid_releasevers(
original_package_repo_ids)
# Get candidate package IDs
update_pkg_ids = self.db_cache.updates[name_id][
current_evr_indexes[-1] + 1:]
for update_pkg_id in update_pkg_ids:
# Filter out packages without errata
if update_pkg_id not in self.db_cache.pkgid2errataids:
continue
# Filter arch compatibility
updated_nevra_arch_id = self.db_cache.package_details[
update_pkg_id][2]
if (updated_nevra_arch_id != arch_id and updated_nevra_arch_id
not in self.db_cache.arch_compat[arch_id]):
continue
errata_ids = self.db_cache.pkgid2errataids.get(
update_pkg_id, set())
nevra = self._build_nevra(update_pkg_id)
for errata_id in errata_ids:
if (module_filter and (update_pkg_id, errata_id)
in self.db_cache.pkgerrata2module
and not self.db_cache.pkgerrata2module[
(update_pkg_id,
errata_id)].intersection(module_ids)):
continue
repo_ids = self._get_repositories(product_ids,
update_pkg_id,
[errata_id],
available_repo_ids,
valid_releasevers)
for repo_id in repo_ids:
repo_details = self.db_cache.repo_detail[repo_id]
response['update_list'][pkg][
'available_updates'].append({
'package':
nevra,
'erratum':
self.db_cache.errataid2name[errata_id],
'repository':
repo_details[REPO_LABEL],
'basearch':
none2empty(repo_details[REPO_BASEARCH]),
'releasever':
none2empty(repo_details[REPO_RELEASEVER])
})
if self.use_hot_cache.upper() == "YES":
HOT_CACHE_INSERTS.inc()
self.hot_cache.insert(repo_ids_key + pkg,
response['update_list'][pkg])
def process_list(self, data):
"""
This method returns details for given set of CVEs.
:param data: data obtained from api, we're interested in data["cve_list"]
:returns: list of dictionaries containing detailed information for given cve list}
"""
validate(data, JSON_SCHEMA)
cves_to_process = data.get("cve_list", None)
modified_since = data.get("modified_since", None)
modified_since_dt = parse_datetime(modified_since)
page = data.get("page", None)
page_size = data.get("page_size", None)
answer = {}
if not cves_to_process:
return answer
cves_to_process = list(filter(None, cves_to_process))
if len(cves_to_process) == 1:
# treat single-label like a regex, get all matching names
cves_to_process = self.find_cves_by_regex(cves_to_process[0])
cve_list = {}
cve_page_to_process, pagination_response = paginate(cves_to_process, page, page_size)
for cve in cve_page_to_process:
cve_detail = self.cache.cve_detail.get(cve, None)
if not cve_detail:
continue
# if we have information about modified/published dates and receive "modified_since" in request,
# compare the dates
if modified_since:
if cve_detail[CVE_MODIFIED_DATE] and cve_detail[CVE_MODIFIED_DATE] < modified_since_dt:
continue
elif not cve_detail[CVE_MODIFIED_DATE] and cve_detail[CVE_PUBLISHED_DATE] and \
cve_detail[CVE_PUBLISHED_DATE] < modified_since_dt:
continue
cve_list[cve] = {
"redhat_url": none2empty(cve_detail[CVE_REDHAT_URL]),
"secondary_url": none2empty(cve_detail[CVE_SECONDARY_URL]),
"synopsis": cve,
"impact": none2empty(cve_detail[CVE_IMPACT]),
"public_date": none2empty(format_datetime(cve_detail[CVE_PUBLISHED_DATE])),
"modified_date": none2empty(format_datetime(cve_detail[CVE_MODIFIED_DATE])),
"cwe_list": none2empty(cve_detail[CVE_CWE]),
"cvss3_score": str(none2empty(cve_detail[CVE_CVSS3_SCORE])),
"description": none2empty(cve_detail[CVE_DESCRIPTION]),
"package_list": pkgidlist2packages(self.cache, cve_detail[CVE_PID]),
"errata_list": [self.cache.errataid2name[eid] for eid in cve_detail[CVE_EID]],
}
response = {"cve_list": cve_list}
response.update(pagination_response)
if modified_since:
response["modified_since"] = modified_since
return response
def process_list(self, api_version, data): # pylint: disable=unused-argument
"""
This method returns details for given set of CVEs.
:param data: data obtained from api, we're interested in data["cve_list"]
:returns: list of dictionaries containing detailed information for given cve list}
"""
validate(data, JSON_SCHEMA)
cves_to_process = data.get("cve_list", None)
modified_since = data.get("modified_since", None)
published_since = data.get("published_since", None)
rh_only = data.get('rh_only', False)
modified_since_dt = parse_datetime(modified_since)
published_since_dt = parse_datetime(published_since)
page = data.get("page", None)
page_size = data.get("page_size", None)
answer = {}
if not cves_to_process:
return answer
cves_to_process = list(filter(None, cves_to_process))
if len(cves_to_process) == 1:
# treat single-label like a regex, get all matching names
cves_to_process = self.find_cves_by_regex(cves_to_process[0])
filters = [(filter_item_if_exists, [self.cache.cve_detail])]
if rh_only:
filters.append((self._filter_redhat_only, []))
# if we have information about modified/published dates and receive "modified_since"
# or "published_since" in request,
# compare the dates
if modified_since:
filters.append((self._filter_modified_since, [modified_since_dt]))
if published_since:
filters.append((self._filter_published_since, [published_since_dt]))
cve_list = {}
cve_page_to_process, pagination_response = paginate(cves_to_process, page, page_size, filters=filters)
for cve in cve_page_to_process:
cve_detail = self.cache.cve_detail.get(cve, None)
if not cve_detail:
continue
bin_pkg_list, src_pkg_list = pkgidlist2packages(self.cache, cve_detail[CVE_PID])
cve_list[cve] = {
"redhat_url": none2empty(cve_detail[CVE_REDHAT_URL]),
"secondary_url": none2empty(cve_detail[CVE_SECONDARY_URL]),
"synopsis": cve,
"impact": none2empty(cve_detail[CVE_IMPACT]),
"public_date": none2empty(format_datetime(cve_detail[CVE_PUBLISHED_DATE])),
"modified_date": none2empty(format_datetime(cve_detail[CVE_MODIFIED_DATE])),
"cwe_list": none2empty(cve_detail[CVE_CWE]),
"cvss3_score": str(none2empty(cve_detail[CVE_CVSS3_SCORE])),
"cvss3_metrics": str(none2empty(cve_detail[CVE_CVSS3_METRICS])),
"cvss2_score": str(none2empty(cve_detail[CVE_CVSS2_SCORE])),
"cvss2_metrics": str(none2empty(cve_detail[CVE_CVSS2_METRICS])),
"description": none2empty(cve_detail[CVE_DESCRIPTION]),
"package_list": bin_pkg_list,
"source_package_list": src_pkg_list,
"errata_list": [self.cache.errataid2name[eid] for eid in cve_detail[CVE_EID]],
}
response = {"cve_list": cve_list}
response.update(pagination_response)
if modified_since:
response["modified_since"] = modified_since
if published_since:
response["published_since"] = published_since
return response