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'] = self.cache.strings.get( pkg_detail[PKG_SUMMARY_ID], None) packagedata['description'] = self.cache.strings.get( pkg_detail[PKG_DESC_ID], None) 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 _update_errata(self, api_version: int, pkg_id: int, opts: dict, third_party: bool) -> tuple: """Add errata-related data, skip based on modified_since if needed""" data = dict() if opts["return_errata"] or opts["modified_since"] is not None: errata, modified = self._get_erratas(api_version, pkg_id, opts["modified_since"], third_party) if self._exclude_not_modified(modified, opts["modified_since"], len(errata)): return None, True if opts["return_errata"]: data["errata"] = none2empty(errata) first_published = self._get_first_published_from_erratas(errata) data["first_published"] = none2empty(first_published) return data, False
def _get_pkg_item(self, pkg_id: int) -> dict: pkg_nevra = self._build_nevra(pkg_id) errata = self._get_erratas(pkg_id) repositories = self._get_repositories(pkg_id) # Skip content with no repos and no erratas (Should skip third party content) first_published = self._get_first_published_from_erratas(errata) pkg_item = { "nevra": pkg_nevra, "first_published": none2empty(first_published), "repositories": none2empty(repositories), "errata": none2empty(errata), } return pkg_item
def _get_repositories(self, pkg_id): # FIXME Add support for modules and streams. repos = [] if pkg_id in self.cache.pkgid2repoids: for repo_id in self.cache.pkgid2repoids[pkg_id]: detail = self.cache.repo_detail[repo_id] repos.append({ 'label': detail[REPO_LABEL], 'name': detail[REPO_NAME], 'basearch': none2empty(detail[REPO_BASEARCH]), 'releasever': none2empty(detail[REPO_RELEASEVER]), 'revision': format_datetime(detail[REPO_REVISION]) }) return natsorted(repos, key=lambda repo_dict: repo_dict['label'])
def process_list(self, api_version, data): # pylint: disable=unused-argument """ Returns list of NEVRAs for given packge name. :param data: json request parsed into data structure :returns: json response with list of NEVRAs """ # Date and time of last data change in the VMaaS DB last_change = format_datetime(self.cache.dbchange['last_change']) names = data.get('package_name_list', None) pkgnamelist = {} if not names: return pkgnamelist for name in names: pkgtree_list = pkgnamelist.setdefault(name, []) if name in self.cache.packagename2id: name_id = self.cache.packagename2id[name] pkg_ids = self._get_packages(name_id) for pkg_id in pkg_ids: pkg_nevra = self._build_nevra(pkg_id) errata = self._get_erratas(pkg_id) repositories = self._get_repositories(pkg_id) first_published = self._get_first_published_from_erratas( errata) pkgtree_list.append({ "nevra": pkg_nevra, "first_published": none2empty(first_published), "repositories": none2empty(repositories), "errata": none2empty(errata), }) pkgnamelist[name] = natsorted( pkgtree_list, key=lambda nevra_list: nevra_list['nevra']) response = { 'package_name_list': pkgnamelist, 'last_change': last_change, } return response
def _get_pkg_errata_updates(self, update_pkg_id: int, errata_id: int, module_ids: set, available_repo_ids: set, valid_releasevers: set, nevra: str, security_only: bool, third_party: bool) -> list: errata_name = self.db_cache.errataid2name[errata_id] errata_detail = self.db_cache.errata_detail[errata_name] # Filter out non-security updates if filter_non_security(errata_detail, security_only): return [] # If we don't want third party content, and current advisory is third party, skip it if not third_party and errata_detail[ERRATA_THIRD_PARTY]: return [] if ((update_pkg_id, errata_id) in self.db_cache.pkgerrata2module and not \ self.db_cache.pkgerrata2module[(update_pkg_id, errata_id)].intersection(module_ids)): return [] repo_ids = self._get_repositories(update_pkg_id, [errata_id], available_repo_ids, valid_releasevers) pkg_errata_updates = [] for repo_id in repo_ids: repo_details = self.db_cache.repo_detail[repo_id] pkg_errata_updates.append({ 'package': nevra, 'erratum': errata_name, 'repository': repo_details[REPO_LABEL], 'basearch': none2empty(repo_details[REPO_BASEARCH]), 'releasever': none2empty(repo_details[REPO_RELEASEVER]) }) return pkg_errata_updates
def _get_erratas(self, api_version: int, pkg_id: int, modified_since: datetime.datetime, third_party: bool) -> tuple: erratas = [] modified_found = False if pkg_id in self.cache.pkgid2errataids: errata_ids = self.cache.pkgid2errataids[pkg_id] for err_id in errata_ids: name = self.cache.errataid2name[err_id] detail = self.cache.errata_detail[name] if detail[ERRATA_THIRD_PARTY] and not third_party: continue issued = detail[ERRATA_ISSUED] errata = {'name': name, 'issued': none2empty(format_datetime(issued))} if api_version >= 3: updated_ts = detail[ERRATA_UPDATED] errata['updated'] = none2empty(format_datetime(updated_ts)) modified_found = self._update_modified_found(modified_found, modified_since, updated_ts) cves = detail[ERRATA_CVE] if cves: errata['cve_list'] = natsorted(cves) erratas.append(errata) erratas = natsorted(erratas, key=lambda err_dict: err_dict['name']) return erratas, modified_found
def _get_erratas(self, pkg_id): erratas = [] if pkg_id in self.cache.pkgid2errataids: errata_ids = self.cache.pkgid2errataids[pkg_id] for err_id in errata_ids: name = self.cache.errataid2name[err_id] issued = self.cache.errata_detail[name][ERRATA_ISSUED] cves = self.cache.errata_detail[name][ERRATA_CVE] errata = { 'name': name, 'issued': none2empty(format_datetime(issued)) } if cves: errata['cve_list'] = natsorted(cves) erratas.append(errata) return natsorted(erratas, key=lambda err_dict: err_dict['name'])
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
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 = [(filter_item_if_exists, [self.cache.errata_detail])] # 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 bin_pkg_list, src_pkg_list = pkgidlist2packages(self.cache, errata_detail[ERRATA_PKGIDS]) if errata_detail[ERRATA_MODULE]: for index, module_update in enumerate(errata_detail[ERRATA_MODULE]): if all(str(elem).isdigit() for elem in errata_detail[ERRATA_MODULE][index]["package_list"]): module_pkg_list, module_src_pkg_list = pkgidlist2packages( self.cache, module_update["package_list"]) errata_detail[ERRATA_MODULE][index]["package_list"] = module_pkg_list errata_detail[ERRATA_MODULE][index]["source_package_list"] = module_src_pkg_list 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": bin_pkg_list, "source_package_list": src_pkg_list, "bugzilla_list": errata_detail[ERRATA_BUGZILLA], "reference_list": errata_detail[ERRATA_REFERENCE], "modules_list": errata_detail[ERRATA_MODULE], "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 """ packages = data.get('package_list', None) # By default, don't include third party data want_third_party = data.get('third_party', False) packagelist = {} if not packages: return packagelist for pkg in packages: packagedata = packagelist.setdefault(pkg, {}) is_third_party = False name, epoch, ver, rel, arch = parse_rpm_name(pkg, default_epoch='0') 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] pkg_id = self.cache.nevra2pkgid.get((name_id, evr_id, arch_id), None) if pkg_id: pkg_detail = self.cache.package_details[pkg_id] packagedata['summary'] = self.cache.strings.get( pkg_detail[PKG_SUMMARY_ID], None) packagedata['description'] = self.cache.strings.get( pkg_detail[PKG_DESC_ID], None) 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] is_third_party = is_third_party or bool( repodetail[REPO_THIRD_PARTY]) 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) # If the package is third party, then remove it from result if not want_third_party and is_third_party: del packagelist[pkg] response = {'package_list': packagelist} return response
def _update_repositories(self, pkg_id: int, opts: dict) -> dict: if opts["return_repositories"]: repositories = self._get_repositories(pkg_id) return dict(repositories=none2empty(repositories)) return dict()
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 """ repos = data.get('repository_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) # By default, don't include third party data want_third_party = data.get('third_party', False) repolist = {} if not repos: return repolist filters = [] if modified_since: filters.append((self._filter_modified_since, [modified_since_dt])) filters.append((self._filter_third_party, [want_third_party])) repos = self.try_expand_by_regex(repos) repos = list(set(repos)) repo_details = {} for label in repos: for repo_id in self.cache.repolabel2ids.get(label, []): repo_details[label] = self.cache.repo_detail[repo_id] filters.append((filter_item_if_exists, [repo_details])) actual_page_size = 0 repo_page_to_process, pagination_response = paginate(repos, page, page_size, filters=filters) for label in repo_page_to_process: cs_id = self.cache.label2content_set_id[label] for repo_id in self.cache.repolabel2ids.get(label, []): repo_detail = self.cache.repo_detail[repo_id] if not modified_since_dt or self._modified_since( repo_detail, modified_since_dt): 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], "cpes": [ self.cache.cpe_id2label[cpe_id] for cpe_id in self.cache.content_set_id2cpe_ids.get(cs_id, []) ], "third_party": repo_detail[REPO_THIRD_PARTY] }) actual_page_size += len(repolist[label]) response = { 'repository_list': repolist, } pagination_response['page_size'] = actual_page_size 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 Errata. :param data: data obtained from api, we're interested in data["errata_list"] :returns: dictionary containing detailed information for given errata list} """ modified_since = data.get("modified_since", None) modified_since_dt = parse_datetime(modified_since) third_party = data.get("third_party", False) errata_to_process = data.get("errata_list", None) page = data.get("page", None) page_size = data.get("page_size", None) errata_type = data.get("type", None) severity = data.get("severity", []) response = {"errata_list": {}} filters = [(filter_item_if_exists, [self.cache.errata_detail]), (self._filter_third_party, [third_party])] if modified_since: response["modified_since"] = modified_since # if we have information about modified/published dates and receive "modified_since" in request, # compare the dates filters.append((self._filter_modified_since, [modified_since_dt])) if errata_type: errata_type = [t.lower() for t in set(errata_type)] \ if isinstance(errata_type, list) else [errata_type.lower()] response["type"] = errata_type filters.append((self._filter_errata_by_prop, ["type", errata_type])) if severity is None or len(severity) != 0: severity = self._prepare_severity(severity) response["severity"] = severity filters.append( (self._filter_errata_by_prop, ["severity", severity])) if not errata_to_process: return response errata_to_process = self.try_expand_by_regex(errata_to_process) 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 bin_pkg_list, src_pkg_list = pkgidlist2packages( self.cache, errata_detail[ERRATA_PKGIDS]) if errata_detail[ERRATA_MODULE]: for index, module_update in enumerate( errata_detail[ERRATA_MODULE]): if all( str(elem).isdigit() for elem in errata_detail[ERRATA_MODULE][index] ["package_list"]): module_pkg_list, module_src_pkg_list = pkgidlist2packages( self.cache, module_update["package_list"]) errata_detail[ERRATA_MODULE][index][ "package_list"] = module_pkg_list errata_detail[ERRATA_MODULE][index][ "source_package_list"] = module_src_pkg_list errata_list[errata] = { "synopsis": none2empty(errata_detail[ERRATA_SYNOPSIS]), "summary": none2empty(errata_detail[ERRATA_SUMMARY]), "type": none2empty(errata_detail[ERRATA_TYPE]), "severity": 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": bin_pkg_list, "source_package_list": src_pkg_list, "bugzilla_list": errata_detail[ERRATA_BUGZILLA], "reference_list": errata_detail[ERRATA_REFERENCE], "modules_list": errata_detail[ERRATA_MODULE], "url": none2empty(errata_detail[ERRATA_URL]), "third_party": errata_detail[ERRATA_THIRD_PARTY] } response["errata_list"] = errata_list response.update(pagination_response) return response
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: sum_id = self.db_cache.package_details[current_nevra_pkg_id][ PKG_SUMMARY_ID] response['update_list'][pkg][ 'summary'] = self.db_cache.strings.get(sum_id, None) desc_id = self.db_cache.package_details[current_nevra_pkg_id][ PKG_DESC_ID] response['update_list'][pkg][ 'description'] = self.db_cache.strings.get(desc_id, None) 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, api_version, data): # pylint: disable=unused-argument """ Returns repository details. :param data: json request parsed into data structure :returns: json response with repository details """ repos = data.get('repository_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) repolist = {} if not repos: return repolist filters = [] if modified_since: filters.append((self._filter_modified_since, [modified_since_dt])) if len(repos) == 1: # treat single-label like a regex, get all matching names repos = self.find_repos_by_regex(repos[0]) repos = list(set(repos)) repo_details = {} for label in repos: for repo_id in self.cache.repolabel2ids.get(label, []): repo_details[label] = self.cache.repo_detail[repo_id] filters.append((filter_item_if_exists, [repo_details])) actual_page_size = 0 repo_page_to_process, pagination_response = paginate(repos, page, page_size, filters=filters) for label in repo_page_to_process: for repo_id in self.cache.repolabel2ids.get(label, []): repo_detail = self.cache.repo_detail[repo_id] if not modified_since_dt or self._modified_since( repo_detail, modified_since_dt): 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] }) actual_page_size += len(repolist[label]) response = { 'repository_list': repolist, } pagination_response['page_size'] = actual_page_size response.update(pagination_response) if modified_since: response["modified_since"] = modified_since return response
def test_none2empty(self): """Test 'None' to "" conversion.""" assert utils.none2empty(None) == ""