Esempio n. 1
0
 def _build_nevra(self, update_pkg_id: int) -> str:
     name_id, evr_id, arch_id, _, _, _ = self.db_cache.package_details[
         update_pkg_id]
     name = self.db_cache.id2packagename[name_id]
     epoch, ver, rel = self.db_cache.id2evr[evr_id]
     arch = self.db_cache.id2arch[arch_id]
     nevra = join_rpm_name(name, epoch, ver, rel, arch)
     return nevra
Esempio n. 2
0
    def process_list(self, data):
        """ Processes whole package_list and returns info. """
        packages = data.get("package_list")
        response = {"package_list": {}}

        db_connection = self.db_pool.get_connection()
        with db_connection.get_cursor() as cursor:
            for package in packages:
                name, epoch, version, release, arch = parse_rpm_name(package, default_epoch='0')
                cursor.execute("""select distinct p.summary, p.description,
                                  pn2.name, evr2.epoch, evr2.version, evr2.release, a2.name,
                                  cs.label, cs.name, a.name, r.releasever,
                                  pn3.name
                                  from package p
                                  left join package_name pn on pn.id = p.name_id 
                                  left join arch ap on p.arch_id = ap.id 
                                  left join evr on p.evr_id = evr.id 
                                  left join package p2 on p2.id = p.source_package_id 
                                  left join package_name pn2 on p2.name_id = pn2.id
                                  left join evr evr2 on p2.evr_id = evr2.id 
                                  left join arch a2 on p2.arch_id = a2.id
                                  left join pkg_repo pr on pr.pkg_id = p.id 
                                  left join repo r on r.id = pr.repo_id 
                                  left join content_set cs on cs.id = r.content_set_id 
                                  left join arch a on a.id = r.basearch_id
                                  left join package p3 on p3.source_package_id = p.id
                                  left join package_name pn3 on p3.name_id = pn3.id
                                  where pn.name = '%s' 
                                  and ap.name = '%s' 
                                  and evr.epoch = '%s' 
                                  and evr.version = '%s' 
                                  and evr.release = '%s'
                               """ % (name, arch, epoch, version, release))
                query = cursor.fetchall()
                pkgs = {}
                pkgs[package] = {}
                for item in query:
                    pkgs[package] = {"summary": item[PACKAGE_SUMMARY],
                                     "description": item[PACKAGE_DESCRIPTION],
                                     "source_package": join_rpm_name(item[SOURCE_PACKAGE_NAME],
                                                                     item[SOURCE_PACKAGE_EPOCH],
                                                                     item[SOURCE_PACKAGE_VERSION],
                                                                     item[SOURCE_PACKAGE_RELEASE],
                                                                     item[SOURCE_PACKAGE_ARCH]),
                                     "repositories": self._build_repositories(query),
                                     "binary_package_list": self._build_binary_packages(query)
                                    }
                response["package_list"].update(pkgs)
        self.db_pool.return_connection(db_connection)
        return response
Esempio n. 3
0
 def _add_package_entry(self, pkg_id, name_id, evr_id, arch_id):
     """Add package to the ultimate response"""
     if name_id not in self.pkgnameid2pkgname:
         LOGGER.error(
             "INCONSISTENT DATA: pkg id %s - package name id %s not found",
             pkg_id, name_id)
     if evr_id not in self.evrid2evr:
         LOGGER.error("INCONSISTEN DATA: pkg id %s - evr id %s not found",
                      pkg_id, evr_id)
     if arch_id not in self.archid2arch:
         LOGGER.error("INCONSISTENT DATA: pkg id %s - arch id %s not found",
                      pkg_id, arch_id)
     (epoch, ver, rel) = self.evrid2evr[evr_id]
     package_nevra = join_rpm_name(self.pkgnameid2pkgname[name_id], epoch,
                                   ver, rel, self.archid2arch[arch_id])
     self.packagedata[pkg_id] = {
         'data': {
             'nevra': package_nevra,
             'repositories': []
         }
     }
     self.datadict[name_id].append(self.packagedata[pkg_id]['data'])
Esempio n. 4
0
 def _build_nevra(self, pkg_detail: tuple):
     name_id, evr_id, arch_id, _, _, _ = pkg_detail
     name = self.cache.id2packagename[name_id]
     epoch, ver, rel = self.cache.id2evr[evr_id]
     arch = self.cache.id2arch[arch_id]
     return join_rpm_name(name, epoch, ver, rel, arch)
Esempio n. 5
0
 def test_join_pkgname(self):
     """Test joining package name"""
     pkg_name = rpm.join_rpm_name("test", "2", "1.2", "4.el7", "x86_64")
     assert pkg_name == "test-2:1.2-4.el7.x86_64"