Viewing file: 
cache.py (26.8 KB) -rw-r--r--Select action/file-type:
(
+) |
(
+) |
(
+) |
Code (
+) |
Session (
+) |
(
+) |
SDB (
+) |
(
+) |
(
+) |
(
+) |
(
+) |
(
+) |
#
# Copyright (c) 2004 Conectiva, Inc.
#
# Written by Gustavo Niemeyer <niemeyer@conectiva.com>
#
# This file is part of Smart Package Manager.
#
# Smart Package Manager is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License as published
# by the Free Software Foundation; either version 2 of the License, or (at
# your option) any later version.
#
# Smart Package Manager is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Smart Package Manager; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
#
from smart.util.strtools import globdistance
from smart.const import BLOCKSIZE
from smart import *
import os
class StateVersionError(Error): pass
class Package(object):
def __init__(self, name, version):
self.name = name
self.version = version
self.provides = ()
self.requires = ()
self.upgrades = ()
self.conflicts = ()
self.installed = False
self.essential = False
self.priority = 0
self.loaders = {}
def getInitArgs(self):
return (self.__class__, self.name, self.version)
def equals(self, other):
# These two packages are exactly the same?
fk = dict.fromkeys
if (self.name != other.name or
self.version != other.version or
len(self.upgrades) != len(other.upgrades) or
len(self.conflicts) != len(other.conflicts) or
fk(self.upgrades) != fk(other.upgrades) or
fk(self.conflicts) != fk(other.conflicts) or
fk([x for x in self.provides if x.name[0] != "/"]) !=
fk([x for x in other.provides if x.name[0] != "/"]) or
fk([x for x in self.requires if x.name[0] != "/"]) !=
fk([x for x in other.requires if x.name[0] != "/"])):
return False
return True
def coexists(self, other):
# These two packages with the same name may coexist?
return False
def matches(self, relation, version):
return False
def search(self, searcher):
myname = self.name
myversion = self.version
ratio = 0
ic = searcher.ignorecase
for nameversion, cutoff in searcher.nameversion:
_, ratio1 = globdistance(nameversion, myname, cutoff, ic)
_, ratio2 = globdistance(nameversion,
"%s-%s" % (myname, myversion), cutoff, ic)
ratio = max(ratio, ratio1, ratio2)
if ratio:
searcher.addResult(self, ratio)
def getPriority(self):
priority = pkgconf.getPriority(self)
if priority is not None:
return priority
channelpriority = None
for loader in self.loaders:
priority = loader.getChannel().getPriority()
if channelpriority is None or priority > channelpriority:
channelpriority = priority
return channelpriority+self.priority
def __repr__(self):
return str(self)
def __str__(self):
return "%s-%s" % (self.name, self.version)
def __lt__(self, other):
# This is used for sorting, and should be overloaded.
rc = -1
if isinstance(other, Package):
rc = cmp(self.name, other.name)
if rc == 0:
rc = cmp(self.version, other.version)
return rc == -1
def __getstate__(self):
return (self.name,
self.version,
self.provides,
self.requires,
self.upgrades,
self.conflicts,
self.installed,
self.essential,
self.priority,
self.loaders)
def __setstate__(self, state):
(self.name,
self.version,
self.provides,
self.requires,
self.upgrades,
self.conflicts,
self.installed,
self.essential,
self.priority,
self.loaders) = state
class PackageInfo(object):
def __init__(self, package, order=0):
self._package = package
self._order = order
def getPackage(self):
return self._package
def getDescription(self):
return ""
def getSummary(self):
return ""
def getSource(self):
return ""
def getGroup(self):
return ""
def getLicense(self):
return ""
def getPathList(self):
return []
def getChangeLog(self):
return []
def pathIsDir(self, path):
return None
def pathIsLink(self, path):
return None
def pathIsFile(self, path):
return None
def pathIsSpecial(self, path):
return None
def getBuildTime(self):
return None
def getInstalledSize(self):
return None
def getReferenceURLs(self):
return []
def getURLs(self):
return []
def getSize(self, url):
return None
def getMD5(self, url):
return None
def getSHA(self, url):
return None
def getSHA256(self, url):
return None
def validate(self, url, localpath, withreason=False):
try:
if not os.path.isfile(localpath):
raise Error, _("File not found")
size = self.getSize(url)
if size:
lsize = os.path.getsize(localpath)
if lsize != size:
raise Error, _("Unexpected size (expected %d, got %d)") % \
(size, lsize)
filemd5 = self.getMD5(url)
if filemd5:
try:
from hashlib import md5
except ImportError:
from md5 import md5
digest = md5()
file = open(localpath)
data = file.read(BLOCKSIZE)
while data:
digest.update(data)
data = file.read(BLOCKSIZE)
lfilemd5 = digest.hexdigest()
if lfilemd5 != filemd5:
raise Error, _("Invalid MD5 (expected %s, got %s)") % \
(filemd5, lfilemd5)
filesha256 = self.getSHA256(url)
if filesha256:
try:
from hashlib import sha256
except ImportError:
from smart.util.sha256 import sha256
digest = sha256()
file = open(localpath)
data = file.read(BLOCKSIZE)
while data:
digest.update(data)
data = file.read(BLOCKSIZE)
lfilesha256 = digest.hexdigest()
if lfilesha256 != filesha256:
raise Error, _("Invalid SHA256 (expected %s, got %s)") % \
(filesha256, lfilesha256)
else:
filesha = self.getSHA(url)
if filesha:
try:
from hashlib import sha1 as sha
except ImportError:
from sha import sha
digest = sha()
file = open(localpath)
data = file.read(BLOCKSIZE)
while data:
digest.update(data)
data = file.read(BLOCKSIZE)
lfilesha = digest.hexdigest()
if lfilesha != filesha:
raise Error, _("Invalid SHA (expected %s, got %s)") % \
(filesha, lfilesha)
except Error, reason:
if withreason:
return False, reason
return False
else:
if withreason:
return True, None
return True
def __lt__(self, other):
return self._order < other._order
class Provides(object):
def __init__(self, name, version):
self.name = name
self.version = version
self.packages = []
self.requiredby = ()
self.upgradedby = ()
self.conflictedby = ()
def getInitArgs(self):
return (self.__class__, self.name, self.version)
def search(self, searcher):
myname = self.name
myversion = self.version
ratio = 0
ic = searcher.ignorecase
for provides, cutoff in searcher.provides:
_, ratio1 = globdistance(provides, myname, cutoff, ic)
_, ratio2 = globdistance(provides, "%s-%s" % (myname, myversion),
cutoff, ic)
ratio = max(ratio, ratio1, ratio2)
if ratio:
searcher.addResult(self, ratio)
def __repr__(self):
return str(self)
def __str__(self):
if self.version:
return "%s = %s" % (self.name, self.version)
return self.name
def __cmp__(self, other):
rc = cmp(self.name, other.name)
if rc == 0:
rc = cmp(self.version, other.version)
if rc == 0:
rc = cmp(self.__class__, other.__class__)
return rc
def __reduce__(self):
return (self.__class__, (self.name, self.version))
class Depends(object):
def __init__(self, name, relation, version):
self.name = name
self.relation = relation
self.version = version
self.packages = []
self.providedby = ()
def getInitArgs(self):
return (self.__class__, self.name, self.relation, self.version)
def getMatchNames(self):
return (self.name,)
def matches(self, prv):
return False
def __repr__(self):
return str(self)
def __str__(self):
if self.version:
return "%s %s %s" % (self.name, self.relation, self.version)
else:
return self.name
def __cmp__(self, other):
rc = cmp(self.name, other.name)
if rc == 0:
rc = cmp(self.version, other.version)
if rc == 0:
rc = cmp(self.__class__, other.__class__)
return rc
def __reduce__(self):
return (self.__class__, (self.name, self.relation, self.version))
class PreRequires(Depends): pass
class Requires(Depends): pass
class Upgrades(Depends): pass
class Conflicts(Depends): pass
class Loader(object):
def __init__(self):
self._packages = []
self._channel = None
self._cache = None
self._installed = False
def getPackages(self):
return self._packages
def getChannel(self):
return self._channel
def setChannel(self, channel):
self._channel = channel
def getCache(self):
return self._cache
def setCache(self, cache):
self._cache = cache
def getInstalled(self):
return self._installed
def setInstalled(self, flag):
self._installed = flag
def getLoadSteps(self):
return 0
def getInfo(self, pkg):
return None
def reset(self):
del self._packages[:]
def load(self):
pass
def unload(self):
self.reset()
def loadFileProvides(self, fndict):
pass
def buildPackage(self, pkgargs, prvargs, reqargs, upgargs, cnfargs):
cache = self._cache
pkg = pkgargs[0](*pkgargs[1:])
relpkgs = []
if prvargs:
pkg.provides = []
for args in prvargs:
prv = cache._objmap.get(args)
if not prv:
prv = args[0](*args[1:])
cache._objmap[args] = prv
cache._provides.append(prv)
relpkgs.append(prv.packages)
pkg.provides.append(prv)
if reqargs:
pkg.requires = []
for args in reqargs:
req = cache._objmap.get(args)
if not req:
req = args[0](*args[1:])
cache._objmap[args] = req
cache._requires.append(req)
relpkgs.append(req.packages)
pkg.requires.append(req)
if upgargs:
pkg.upgrades = []
for args in upgargs:
upg = cache._objmap.get(args)
if not upg:
upg = args[0](*args[1:])
cache._objmap[args] = upg
cache._upgrades.append(upg)
relpkgs.append(upg.packages)
pkg.upgrades.append(upg)
if cnfargs:
pkg.conflicts = []
for args in cnfargs:
cnf = cache._objmap.get(args)
if not cnf:
cnf = args[0](*args[1:])
cache._objmap[args] = cnf
cache._conflicts.append(cnf)
relpkgs.append(cnf.packages)
pkg.conflicts.append(cnf)
found = False
lst = cache._objmap.get(pkgargs)
if lst is not None:
for lstpkg in lst:
if pkg.equals(lstpkg):
pkg = lstpkg
found = True
break
else:
lst.append(pkg)
else:
cache._objmap[pkgargs] = [pkg]
if not found:
cache._packages.append(pkg)
for pkgs in relpkgs:
pkgs.append(pkg)
pkg.installed |= self._installed
self._packages.append(pkg)
return pkg
def buildFileProvides(self, pkg, prvargs):
cache = self._cache
prv = cache._objmap.get(prvargs)
if not prv:
prv = prvargs[0](*prvargs[1:])
cache._objmap[prvargs] = prv
cache._provides.append(prv)
elif prv in pkg.provides:
return
prv.packages.append(pkg)
pkg.provides.append(prv)
for req in pkg.requires[:]:
if req.name == prv.name:
pkg.requires.remove(req)
req.packages.remove(pkg)
if not req.packages:
cache._requires.remove(req)
def search(self, searcher):
# Loaders are responsible for searching on PackageInfo. They
# should use the fastest possible method. The one here is
# generic, and should be replaced if possible.
ic = searcher.ignorecase
for pkg in self._packages:
info = self.getInfo(pkg)
ratio = 0
if searcher.url:
for url, cutoff in searcher.url:
for refurl in info.getReferenceURLs():
_, newratio = globdistance(url, refurl, cutoff, ic)
if newratio > ratio:
ratio = newratio
if ratio == 1:
break
else:
continue
break
if ratio == 1:
searcher.addResult(pkg, ratio)
continue
if searcher.path:
for spath, cutoff in searcher.path:
for path in info.getPathList():
_, newratio = globdistance(spath, path, cutoff, ic)
if newratio > ratio:
ratio = newratio
if ratio == 1:
break
else:
continue
break
if ratio == 1:
searcher.addResult(pkg, ratio)
continue
if searcher.group:
for pat in searcher.group:
if pat.search(info.getGroup()):
ratio = 1
break
if ratio == 1:
searcher.addResult(pkg, ratio)
continue
if searcher.summary:
for pat in searcher.summary:
if pat.search(info.getSummary()):
ratio = 1
break
if ratio == 1:
searcher.addResult(pkg, ratio)
continue
if searcher.description:
for pat in searcher.description:
if pat.search(info.getDescription()):
ratio = 1
break
if ratio:
searcher.addResult(pkg, ratio)
__stateversion__ = 1
def __getstate__(self):
state = self.__dict__.copy()
state["__stateversion__"] = self.__stateversion__
return state
def __setstate__(self, state):
if state["__stateversion__"] != self.__stateversion__:
raise StateVersionError
self.__dict__.update(state)
del self.__stateversion__
class Cache(object):
def __init__(self):
self._loaders = []
self._packages = []
self._provides = []
self._requires = []
self._upgrades = []
self._conflicts = []
self._objmap = {}
def reset(self):
for prv in self._provides:
del prv.packages[:]
if prv.requiredby:
del prv.requiredby[:]
if prv.upgradedby:
del prv.upgradedby[:]
if prv.conflictedby:
del prv.conflictedby[:]
for req in self._requires:
del req.packages[:]
if req.providedby:
del req.providedby[:]
for upg in self._upgrades:
del upg.packages[:]
if upg.providedby:
del upg.providedby[:]
for cnf in self._conflicts:
del cnf.packages[:]
if cnf.providedby:
del cnf.providedby[:]
del self._packages[:]
del self._provides[:]
del self._requires[:]
del self._upgrades[:]
del self._conflicts[:]
self._objmap.clear()
def addLoader(self, loader):
if loader:
if loader not in self._loaders:
self._loaders.append(loader)
loader.setCache(self)
def removeLoader(self, loader):
if loader:
if loader in self._loaders:
self._loaders.remove(loader)
loader.setCache(None)
loader.unload()
def _reload(self):
packages = {}
provides = {}
requires = {}
upgrades = {}
conflicts = {}
objmap = self._objmap
loaders = dict.fromkeys(self._loaders, True)
for loader in loaders:
for pkg in loader._packages:
if pkg in packages:
pkg.installed |= loader._installed
else:
pkg.installed = loader._installed
packages[pkg] = True
objmap.setdefault(pkg.getInitArgs(), []).append(pkg)
for pkgloader in pkg.loaders.keys():
if pkgloader not in loaders:
del pkg.loaders[pkgloader]
for prv in pkg.provides:
prv.packages.append(pkg)
if prv not in provides:
provides[prv] = True
objmap[prv.getInitArgs()] = prv
for req in pkg.requires[:]:
req.packages.append(pkg)
if req not in requires:
objmap[req.getInitArgs()] = req
requires[req] = True
for upg in pkg.upgrades:
upg.packages.append(pkg)
if upg not in upgrades:
upgrades[upg] = True
objmap[upg.getInitArgs()] = upg
for cnf in pkg.conflicts:
cnf.packages.append(pkg)
if cnf not in conflicts:
conflicts[cnf] = True
objmap[cnf.getInitArgs()] = cnf
self._packages[:] = packages.keys()
self._provides[:] = provides.keys()
self._requires[:] = requires.keys()
self._upgrades[:] = upgrades.keys()
self._conflicts[:] = conflicts.keys()
def load(self):
self._reload()
prog = iface.getProgress(self)
prog.start()
prog.setTopic(_("Updating cache..."))
prog.set(0, 1)
prog.show()
total = 1
for loader in self._loaders:
if not loader._packages:
total += loader.getLoadSteps()
prog.set(0, total)
prog.show()
for loader in self._loaders:
if not loader._packages:
loader.load()
self.loadFileProvides()
hooks.call("cache-loaded-pre-link", self)
self._objmap.clear()
self.linkDeps()
prog.setDone()
prog.show()
prog.stop()
hooks.call("cache-loaded", self)
def unload(self):
self.reset()
for loader in self._loaders:
loader.unload()
def loadFileProvides(self):
fndict = {}
for req in self._requires:
name = req.name
if name[0] == "/":
fndict[name] = name
for loader in self._loaders:
loader.loadFileProvides(fndict)
def linkDeps(self):
reqnames = {}
for req in self._requires:
for name in req.getMatchNames():
lst = reqnames.get(name)
if lst:
lst.append(req)
else:
reqnames[name] = [req]
upgnames = {}
for upg in self._upgrades:
for name in upg.getMatchNames():
lst = upgnames.get(name)
if lst:
lst.append(upg)
else:
upgnames[name] = [upg]
cnfnames = {}
for cnf in self._conflicts:
for name in cnf.getMatchNames():
lst = cnfnames.get(name)
if lst:
lst.append(cnf)
else:
cnfnames[name] = [cnf]
for prv in self._provides:
lst = reqnames.get(prv.name)
if lst:
for req in lst:
if req.matches(prv):
if req.providedby:
req.providedby.append(prv)
else:
req.providedby = [prv]
if prv.requiredby:
prv.requiredby.append(req)
else:
prv.requiredby = [req]
lst = upgnames.get(prv.name)
if lst:
for upg in lst:
if upg.matches(prv):
if upg.providedby:
upg.providedby.append(prv)
else:
upg.providedby = [prv]
if prv.upgradedby:
prv.upgradedby.append(upg)
else:
prv.upgradedby = [upg]
lst = cnfnames.get(prv.name)
if lst:
for cnf in lst:
if cnf.matches(prv):
if cnf.providedby:
cnf.providedby.append(prv)
else:
cnf.providedby = [prv]
if prv.conflictedby:
prv.conflictedby.append(cnf)
else:
prv.conflictedby = [cnf]
def getPackages(self, name=None):
if not name:
return self._packages
else:
return [x for x in self._packages if x.name == name]
def getProvides(self, name=None):
if not name:
return self._provides
else:
return [x for x in self._provides if x.name == name]
def getRequires(self, name=None):
if not name:
return self._requires
else:
return [x for x in self._requires if x.name == name]
def getUpgrades(self, name=None):
if not name:
return self._upgrades
else:
return [x for x in self._upgrades if x.name == name]
def getConflicts(self, name=None):
if not name:
return self._conflicts
else:
return [x for x in self._conflicts if x.name == name]
def search(self, searcher):
if searcher.nameversion:
for pkg in self._packages:
pkg.search(searcher)
if searcher.provides:
for prv in self._provides:
prv.search(searcher)
if searcher.requires:
for prv in searcher.requires:
prvname = prv.name
for req in self._requires:
if prvname in req.getMatchNames() and req.matches(prv):
searcher.addResult(req)
if searcher.upgrades:
for prv in searcher.upgrades:
prvname = prv.name
for upg in self._upgrades:
if prvname in upg.getMatchNames() and upg.matches(prv):
searcher.addResult(upg)
if searcher.conflicts:
for prv in searcher.conflicts:
prvname = prv.name
for cnf in self._conflicts:
if prvname in cnf.getMatchNames() and cnf.matches(prv):
searcher.addResult(cnf)
if searcher.needsPackageInfo():
for loader in self._loaders:
loader.search(searcher)
__stateversion__ = 1
def __getstate__(self):
state = {}
state["__stateversion__"] = self.__stateversion__
state["_loaders"] = self._loaders
state["_packages"] = self._packages
return state
def __setstate__(self, state):
if state["__stateversion__"] != self.__stateversion__:
raise StateVersionError
self._loaders = state["_loaders"]
self._packages = state["_packages"]
provides = {}
requires = {}
upgrades = {}
conflicts = {}
for pkg in self._packages:
for prv in pkg.provides:
prv.packages.append(pkg)
provides[prv] = True
for req in pkg.requires:
req.packages.append(pkg)
requires[req] = True
for upg in pkg.upgrades:
upg.packages.append(pkg)
upgrades[upg] = True
for cnf in pkg.conflicts:
cnf.packages.append(pkg)
conflicts[cnf] = True
self._provides = provides.keys()
self._requires = requires.keys()
self._upgrades = upgrades.keys()
self._conflicts = conflicts.keys()
self._objmap = {}
from ccache import *
# vim:ts=4:sw=4:et
