Ejemplo n.º 1
0
 def init(self):
     repo = FakeRepository(self._fileName)
     header = rpmutils.readRpmHeader(self._fileName)
     if not header:
         return False
     RpmHeaderPackage.__init__(self, header, repo)
     return True
Ejemplo n.º 2
0
    def __init__(self, root):
        self.root = root
        self.ts = None
        self._prcoCache = {
            'provides': {},
            'requires': {},
            'conflicts': {},
            'obsoletes': {}
        }
        self._provideCache = {}
        self._requireCache = {}
        self._conflictCache = {}
        self._idx2PkgDict = {}
        self._name2PkgDict = {}
        self._tuple2PkgDict = {}
        self._completelyLoaded = False

        self._repo = FakeRepository('/', installed=True)
        self._repo.setPackageSack(self)
Ejemplo n.º 3
0
    def __init__(self, root):
        self.root = root
        self.ts = None
        self._prcoCache = {
            'provides': {}, 
            'requires': {},
            'conflicts': {}, 
            'obsoletes': {}
            }
        self._provideCache = {}
        self._requireCache = {}
        self._conflictCache = {}
        self._idx2PkgDict = {}
        self._name2PkgDict = {}
        self._tuple2PkgDict = {}
        self._completelyLoaded = False

        self._repo = FakeRepository('/', installed=True)
        self._repo.setPackageSack(self)
Ejemplo n.º 4
0
 def buildInstalledPkgSack(self):
     sack = PackageSack()
     ainstRoot = AinstRoot(self._installRoot)
     if not ainstRoot.isValidAinstRoot():
         Log.cout(Log.DEBUG, '%s is invalid ainst root' % self._installRoot)
         return None
     reader = AinstRootReader(ainstRoot)
     installPkgMetas = reader.getInstallPkgMetas()
     if installPkgMetas is None:
         Log.cout(Log.DEBUG,
                  'Get install meta of %s failed' % self._installRoot)
         return None
     for pkgVer, rpmPath in installPkgMetas:
         header = rpmutils.readRpmHeader(rpmPath)
         if header:
             repo = FakeRepository(self._installRoot, True)
             pkg = AinstRpmPackage(header, repo)
             sack.addPackageObject(pkg)
     return sack
Ejemplo n.º 5
0
 def buildActivePkgSack(self):
     sack = PackageSack()
     ainstRoot = AinstRoot(self._installRoot)
     if not ainstRoot.isValidAinstRoot():
         Log.cout(Log.DEBUG, '%s is invalid ainst root' % self._installRoot)
         return None
     reader = AinstRootReader(ainstRoot)
     activePkgMetas = reader.getActivePkgMetas()
     if activePkgMetas is None:
         Log.cout(Log.DEBUG,
                  'Get active meta of %s failed' % self._installRoot)
         return None
     for pkgName, rpmPath, aicfPath in activePkgMetas:
         aicfInfo = None
         if file_util.isFile(aicfPath):
             aicfInfo = AicfParser().parse(aicfPath)
         header = rpmutils.readRpmHeader(rpmPath)
         if header:
             repo = FakeRepository(self._installRoot, True)
             pkg = AinstRpmPackage(header, repo, aicfInfo)
             sack.addPackageObject(pkg)
     return sack
Ejemplo n.º 6
0
class RPMDBPackageSack(PackageSackBase):
    '''
    Represent rpmdb as a packagesack
    '''
    DEP_TABLE = { 
            'requires'  : (rpm.RPMTAG_REQUIRENAME,
                           rpm.RPMTAG_REQUIREVERSION,
                           rpm.RPMTAG_REQUIREFLAGS),
            'provides'  : (rpm.RPMTAG_PROVIDENAME,
                           rpm.RPMTAG_PROVIDEVERSION,
                           rpm.RPMTAG_PROVIDEFLAGS),
            'conflicts' : (rpm.RPMTAG_CONFLICTNAME,
                           rpm.RPMTAG_CONFLICTVERSION,
                           rpm.RPMTAG_CONFLICTFLAGS),
            'obsoletes' : (rpm.RPMTAG_OBSOLETENAME,
                           rpm.RPMTAG_OBSOLETEVERSION,
                           rpm.RPMTAG_OBSOLETEFLAGS)
            }

    def __init__(self, root):
        self.root = root
        self.ts = None
        self._prcoCache = {
            'provides': {}, 
            'requires': {},
            'conflicts': {}, 
            'obsoletes': {}
            }
        self._provideCache = {}
        self._requireCache = {}
        self._conflictCache = {}
        self._idx2PkgDict = {}
        self._name2PkgDict = {}
        self._tuple2PkgDict = {}
        self._completelyLoaded = False

        self._repo = FakeRepository('/', installed=True)
        self._repo.setPackageSack(self)

    def addPackageObject(self, pkg):
        pass

    def deletePackageObject(self, pkg):
        pass

    def returnPackages(self):
        pass

    def getRequires(self, require):
        name, version  = require.name, require.version
        if require in self._requireCache:
            return self._requireCache[require]

        pkgs = self.searchPkgByRequire(name)
        result = {}
        for pkgObj in pkgs:
            if name[0] == '/' and version is None:
                result[pkgObj] = [Require(name, None, None, None, None)]
                continue
            requires = PackageUtil.matchingRequire(pkgObj, require)
            if requires:
                result[pkgObj] = requires
        self._requireCache[require] = result
        return result

    def getProvides(self, provide):
        name, version = provide.name, provide.version
        if provide in self._provideCache:
            return self._provideCache[provide]

        pkgs = self.searchPkgByProvide(name)
        result = {}
        for pkgObj in pkgs:
            if name[0] == '/' and version is None:
                result[pkgObj] = [Provide(name, None, None, None, None)]
            provides = PackageUtil.matchingProvide(pkgObj, provide)
            if provides:
                result[pkgObj] = provides
        self._provideCache[provide] = result
        return result

    def getConflicts(self, conflict):
        name, version = conflict.name, conflict.version
        if conflict in self._conflictCache:
            return self._conflictCache[conflict]

        pkgs = self.searchPkgByConflict(name)
        result = {}
        for pkgObj in pkgs:
            conflicts = PackageUtil.matchingProvide(pkgObj, conflict)
            if conflicts:
                result[pkgObj] = conflicts
        self._conflictCache[conflict] = result
        return result

    def getPkgs(self):
        return self.searchPkg()

    def searchPkg(self, name=None, epoch=None, version=None,
                  release=None, arch=None):
        pkgTuple = (name, arch, epoch, version, release)
        if self._tuple2PkgDict.has_key(pkgTuple):
            return self._tuple2PkgDict[pkgTuple]
        
        loc = locals()
        ret = []

        if self._completelyLoaded:
            if name is not None:
                pkgs = self._name2PkgDict.get(name, [])
            else:
                return self._name2PkgDict.values()
            for po in pkgs:
                for tag in ('name', 'epoch', 'version', 'release', 'arch'):
                    if loc[tag] is not None and loc[tag] != getattr(po, tag):
                        break
                else:
                    ret.append(po)
            return ret

        ts = self._getTs()
        if name is not None:
            mi = ts.dbMatch('name', name)
        elif arch is not None:
            mi = ts.dbMatch('arch', arch)
        else:
            mi = ts.dbMatch()
            self._completelyLoaded = True

        for hdr in mi:
            po = self._makePackageObject(hdr, mi.instance())
            for tag in ('name', 'epoch', 'version', 'release', 'arch'):
                if loc[tag] is not None and loc[tag] != getattr(po, tag):
                    break
            else:
                ret.append(po)
        return ret

    def searchPkgByName(self, name):
        return self.searchPkg(name)

    def searchPkgByProvide(self, name):
        return self.searchPrco(name, 'provides')

    def searchPkgByRequire(self, name):
        return self.searchPrco(name, 'requires')

    def searchPkgByConflict(self, name):
        return self.searchPrco(name, 'conflicts')

    def searchPkgByObsolete(self, name):
        return self.searchPrco(name, 'obsoletes')

    def searchPkgByFile(self, name):
        ts = self._getTs()
        result = {}
        mi = ts.dbMatch('basenames', name)
        for hdr in mi:
            pkg = self._makePackageObject(hdr, mi.instance())
            if not result.has_key(pkg.pkgid):
                result[pkg.pkgid] = pkg
        del mi

        result = result.values()
        return result

    def searchPrco(self, name, prcotype):
        result = self._prcoCache[prcotype].get(name)
        if result is not None:
            return result
        ts = self._getTs()
        result = {}
        tag = self.DEP_TABLE[prcotype][0]
        mi = ts.dbMatch(tag, name)
        for hdr in mi:
            po = self._makePackageObject(hdr, mi.instance())
            result[po.pkgid] = po
        del mi

        if prcotype == 'provides' and name[0] == '/':
            fileResults = self.searchPkgByFile(name)
            for pkg in fileResults:
                result[pkg.pkgid] = pkg
        result = result.values()
        self._prcoCache[prcotype][name] = result
        return result

    def _getTs(self):
        if self.ts:
            return self.ts
        self.ts = rpm.TransactionSet()
        self.ts.setVSFlags((rpm._RPMVSF_NOSIGNATURES|rpm._RPMVSF_NODIGESTS))
        return self.ts

    def _makePackageObject(self, hdr, index):
        if self._idx2PkgDict.has_key(index):
            return self._idx2PkgDict[index]
        po = InstalledRpmPackage(hdr, self._repo)
        self._idx2PkgDict[index] = po
        self._name2PkgDict.setdefault(po.name, []).append(po)
        self._tuple2PkgDict[po.getTuple()] = po
        return po
Ejemplo n.º 7
0
class RPMDBPackageSack(PackageSackBase):
    '''
    Represent rpmdb as a packagesack
    '''
    DEP_TABLE = {
        'requires': (rpm.RPMTAG_REQUIRENAME, rpm.RPMTAG_REQUIREVERSION,
                     rpm.RPMTAG_REQUIREFLAGS),
        'provides': (rpm.RPMTAG_PROVIDENAME, rpm.RPMTAG_PROVIDEVERSION,
                     rpm.RPMTAG_PROVIDEFLAGS),
        'conflicts': (rpm.RPMTAG_CONFLICTNAME, rpm.RPMTAG_CONFLICTVERSION,
                      rpm.RPMTAG_CONFLICTFLAGS),
        'obsoletes': (rpm.RPMTAG_OBSOLETENAME, rpm.RPMTAG_OBSOLETEVERSION,
                      rpm.RPMTAG_OBSOLETEFLAGS)
    }

    def __init__(self, root):
        self.root = root
        self.ts = None
        self._prcoCache = {
            'provides': {},
            'requires': {},
            'conflicts': {},
            'obsoletes': {}
        }
        self._provideCache = {}
        self._requireCache = {}
        self._conflictCache = {}
        self._idx2PkgDict = {}
        self._name2PkgDict = {}
        self._tuple2PkgDict = {}
        self._completelyLoaded = False

        self._repo = FakeRepository('/', installed=True)
        self._repo.setPackageSack(self)

    def addPackageObject(self, pkg):
        pass

    def deletePackageObject(self, pkg):
        pass

    def returnPackages(self):
        pass

    def getRequires(self, require):
        name, version = require.name, require.version
        if require in self._requireCache:
            return self._requireCache[require]

        pkgs = self.searchPkgByRequire(name)
        result = {}
        for pkgObj in pkgs:
            if name[0] == '/' and version is None:
                result[pkgObj] = [Require(name, None, None, None, None)]
                continue
            requires = PackageUtil.matchingRequire(pkgObj, require)
            if requires:
                result[pkgObj] = requires
        self._requireCache[require] = result
        return result

    def getProvides(self, provide):
        name, version = provide.name, provide.version
        if provide in self._provideCache:
            return self._provideCache[provide]

        pkgs = self.searchPkgByProvide(name)
        result = {}
        for pkgObj in pkgs:
            if name[0] == '/' and version is None:
                result[pkgObj] = [Provide(name, None, None, None, None)]
            provides = PackageUtil.matchingProvide(pkgObj, provide)
            if provides:
                result[pkgObj] = provides
        self._provideCache[provide] = result
        return result

    def getConflicts(self, conflict):
        name, version = conflict.name, conflict.version
        if conflict in self._conflictCache:
            return self._conflictCache[conflict]

        pkgs = self.searchPkgByConflict(name)
        result = {}
        for pkgObj in pkgs:
            conflicts = PackageUtil.matchingProvide(pkgObj, conflict)
            if conflicts:
                result[pkgObj] = conflicts
        self._conflictCache[conflict] = result
        return result

    def getPkgs(self):
        return self.searchPkg()

    def searchPkg(self,
                  name=None,
                  epoch=None,
                  version=None,
                  release=None,
                  arch=None):
        pkgTuple = (name, arch, epoch, version, release)
        if self._tuple2PkgDict.has_key(pkgTuple):
            return self._tuple2PkgDict[pkgTuple]

        loc = locals()
        ret = []

        if self._completelyLoaded:
            if name is not None:
                pkgs = self._name2PkgDict.get(name, [])
            else:
                return self._name2PkgDict.values()
            for po in pkgs:
                for tag in ('name', 'epoch', 'version', 'release', 'arch'):
                    if loc[tag] is not None and loc[tag] != getattr(po, tag):
                        break
                else:
                    ret.append(po)
            return ret

        ts = self._getTs()
        if name is not None:
            mi = ts.dbMatch('name', name)
        elif arch is not None:
            mi = ts.dbMatch('arch', arch)
        else:
            mi = ts.dbMatch()
            self._completelyLoaded = True

        for hdr in mi:
            po = self._makePackageObject(hdr, mi.instance())
            for tag in ('name', 'epoch', 'version', 'release', 'arch'):
                if loc[tag] is not None and loc[tag] != getattr(po, tag):
                    break
            else:
                ret.append(po)
        return ret

    def searchPkgByName(self, name):
        return self.searchPkg(name)

    def searchPkgByProvide(self, name):
        return self.searchPrco(name, 'provides')

    def searchPkgByRequire(self, name):
        return self.searchPrco(name, 'requires')

    def searchPkgByConflict(self, name):
        return self.searchPrco(name, 'conflicts')

    def searchPkgByObsolete(self, name):
        return self.searchPrco(name, 'obsoletes')

    def searchPkgByFile(self, name):
        ts = self._getTs()
        result = {}
        mi = ts.dbMatch('basenames', name)
        for hdr in mi:
            pkg = self._makePackageObject(hdr, mi.instance())
            if not result.has_key(pkg.pkgid):
                result[pkg.pkgid] = pkg
        del mi

        result = result.values()
        return result

    def searchPrco(self, name, prcotype):
        result = self._prcoCache[prcotype].get(name)
        if result is not None:
            return result
        ts = self._getTs()
        result = {}
        tag = self.DEP_TABLE[prcotype][0]
        mi = ts.dbMatch(tag, name)
        for hdr in mi:
            po = self._makePackageObject(hdr, mi.instance())
            result[po.pkgid] = po
        del mi

        if prcotype == 'provides' and name[0] == '/':
            fileResults = self.searchPkgByFile(name)
            for pkg in fileResults:
                result[pkg.pkgid] = pkg
        result = result.values()
        self._prcoCache[prcotype][name] = result
        return result

    def _getTs(self):
        if self.ts:
            return self.ts
        self.ts = rpm.TransactionSet()
        self.ts.setVSFlags((rpm._RPMVSF_NOSIGNATURES | rpm._RPMVSF_NODIGESTS))
        return self.ts

    def _makePackageObject(self, hdr, index):
        if self._idx2PkgDict.has_key(index):
            return self._idx2PkgDict[index]
        po = InstalledRpmPackage(hdr, self._repo)
        self._idx2PkgDict[index] = po
        self._name2PkgDict.setdefault(po.name, []).append(po)
        self._tuple2PkgDict[po.getTuple()] = po
        return po