home *** CD-ROM | disk | FTP | other *** search
/ PC Welt 2006 November (DVD) / PCWELT_11_2006.ISO / casper / filesystem.squashfs / usr / share / pycentral / python-apt / site-packages / apt / cache.py < prev    next >
Encoding:
Python Source  |  2006-07-27  |  11.8 KB  |  372 lines
  1. # cache.py - apt cache abstraction
  2. #  
  3. #  Copyright (c) 2005 Canonical
  4. #  
  5. #  Author: Michael Vogt <michael.vogt@ubuntu.com>
  6. # 
  7. #  This program is free software; you can redistribute it and/or 
  8. #  modify it under the terms of the GNU General Public License as 
  9. #  published by the Free Software Foundation; either version 2 of the
  10. #  License, or (at your option) any later version.
  11. # 
  12. #  This program is distributed in the hope that it will be useful,
  13. #  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14. #  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15. #  GNU General Public License for more details.
  16. # 
  17. #  You should have received a copy of the GNU General Public License
  18. #  along with this program; if not, write to the Free Software
  19. #  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  20. #  USA
  21.  
  22. import apt_pkg
  23. from apt import Package
  24. import apt.progress
  25. import os
  26. import sys
  27.  
  28. class Cache(object):
  29.     """ Dictionary-like package cache 
  30.         This class has all the packages that are available in it's
  31.         dictionary
  32.     """
  33.  
  34.     def __init__(self, progress=None, rootdir=None):
  35.         self._callbacks = {}
  36.         self.open(progress)
  37.  
  38.         if rootdir:
  39.             apt_pkg.Config.Set("Dir", rootdir)
  40.             apt_pkg.Config.Set("Dir::State::status", rootdir + "/var/lib/dpkg/status")
  41.  
  42.     def _runCallbacks(self, name):
  43.         """ internal helper to run a callback """
  44.         if self._callbacks.has_key(name):
  45.             for callback in self._callbacks[name]:
  46.                 callback()
  47.         
  48.     def open(self, progress):
  49.         """ Open the package cache, after that it can be used like
  50.             a dictionary
  51.         """
  52.         self._runCallbacks("cache_pre_open")
  53.         self._cache = apt_pkg.GetCache(progress)
  54.         self._depcache = apt_pkg.GetDepCache(self._cache)
  55.         self._records = apt_pkg.GetPkgRecords(self._cache)
  56.         self._list = apt_pkg.GetPkgSourceList()
  57.         self._list.ReadMainList()
  58.         self._dict = {}
  59.  
  60.         # build the packages dict
  61.         if progress != None:
  62.             progress.Op = "Building data structures"
  63.         i=last=0
  64.         size=len(self._cache.Packages)
  65.         for pkg in self._cache.Packages:
  66.             if progress != None and last+100 < i:
  67.                 progress.update(i/float(size)*100)
  68.                 last=i
  69.             # drop stuff with no versions (cruft)
  70.             if len(pkg.VersionList) > 0:
  71.                 self._dict[pkg.Name] = Package(self._cache, self._depcache,
  72.                                                self._records, self._list,
  73.                                                self, pkg)
  74.                 
  75.             i += 1
  76.         if progress != None:
  77.             progress.done()
  78.         self._runCallbacks("cache_post_open")
  79.         
  80.     def __getitem__(self, key):
  81.         """ look like a dictionary (get key) """
  82.         return self._dict[key]
  83.  
  84.     def __iter__(self):
  85.         for pkgname in self._dict.keys():
  86.             yield self._dict[pkgname]
  87.         raise StopIteration
  88.  
  89.     def has_key(self, key):
  90.         return self._dict.has_key(key)
  91.  
  92.     def __len__(self):
  93.         return len(self._dict)
  94.  
  95.     def keys(self):
  96.         return self._dict.keys()
  97.  
  98.     def getChanges(self):
  99.         """ Get the marked changes """
  100.         changes = [] 
  101.         for name in self._dict.keys():
  102.             p = self._dict[name]
  103.             if p.markedUpgrade or p.markedInstall or p.markedDelete or \
  104.                p.markedDowngrade or p.markedReinstall:
  105.                 changes.append(p)
  106.         return changes
  107.  
  108.     def upgrade(self, distUpgrade=False):
  109.         """ Upgrade the all package, DistUpgrade will also install
  110.             new dependencies
  111.         """
  112.         self.cachePreChange()
  113.         self._depcache.Upgrade(distUpgrade)
  114.         self.cachePostChange()
  115.  
  116.     def _runFetcher(self, fetcher):
  117.         # do the actual fetching
  118.         res = fetcher.Run()
  119.         
  120.         # now check the result (this is the code from apt-get.cc)
  121.         failed = False
  122.         transient = False
  123.         errMsg = ""
  124.         for item in fetcher.Items:
  125.             if item.Status == item.StatDone:
  126.                 continue
  127.             if item.StatIdle:
  128.                 transient = True
  129.                 continue
  130.             errMsg += "Failed to fetch %s %s\n" % (item.DescURI,item.ErrorText)
  131.             failed = True
  132.  
  133.         # we raise a exception if the download failed
  134.         if failed:
  135.             raise IOError, errMsg
  136.         return res
  137.  
  138.     def _fetchArchives(self, fetcher, pm):
  139.         """ fetch the needed archives """
  140.  
  141.         # get lock
  142.         lockfile = apt_pkg.Config.FindDir("Dir::Cache::Archives") + "lock"
  143.         lock = apt_pkg.GetLock(lockfile)
  144.         if lock < 0:
  145.             raise IOError, "Failed to lock %s" % lockfile
  146.  
  147.         try:
  148.             # this may as well throw a SystemError exception
  149.             if not pm.GetArchives(fetcher, self._list, self._records):
  150.                 return False
  151.             # now run the fetcher, throw exception if something fails to be
  152.             # fetched
  153.             return self._runFetcher(fetcher)
  154.         finally:
  155.             os.close(lock)
  156.  
  157.     def update(self, fetchProgress=None):
  158.         lockfile = apt_pkg.Config.FindDir("Dir::State::Lists") + "lock"
  159.         lock = apt_pkg.GetLock(lockfile)
  160.         if lock < 0:
  161.             raise IOError, "Failed to lock %s" % lockfile
  162.  
  163.         try:
  164.             if fetchProgress == None:
  165.                 fetchProgress = apt.progress.FetchProgress()
  166.             fetcher = apt_pkg.GetAcquire(fetchProgress)
  167.             # this can throw a exception
  168.             self._list.GetIndexes(fetcher)
  169.             # now run the fetcher, throw exception if something fails to be
  170.             # fetched
  171.             if self._runFetcher(fetcher) == fetcher.ResultContinue:
  172.                 return True
  173.             return False
  174.         finally:
  175.             os.close(lock)
  176.         
  177.     def installArchives(self, pm, installProgress):
  178.         installProgress.startUpdate()
  179.         res = installProgress.run(pm)
  180.         installProgress.finishUpdate()
  181.         return res
  182.     
  183.     def commit(self, fetchProgress=None, installProgress=None):
  184.         """ Apply the marked changes to the cache """
  185.         # FIXME:
  186.         # use the new acquire/pkgmanager interface here,
  187.         # raise exceptions when a download or install fails
  188.         # and send proper error strings to the application.
  189.         # Current a failed download will just display "error"
  190.         # which is less than optimal!
  191.  
  192.         if fetchProgress == None:
  193.             fetchProgress = apt.progress.FetchProgress()
  194.         if installProgress == None:
  195.             installProgress = apt.progress.InstallProgress()
  196.  
  197.         pm = apt_pkg.GetPackageManager(self._depcache)
  198.         fetcher = apt_pkg.GetAcquire(fetchProgress)
  199.         while True:
  200.             # fetch archives first
  201.             res = self._fetchArchives(fetcher, pm)
  202.  
  203.             # then install
  204.             res = self.installArchives(pm, installProgress)
  205.             if res == pm.ResultCompleted:
  206.                 break
  207.             if res == pm.ResultFailed:
  208.                 raise SystemError, "installArchives() failed"
  209.             # reload the fetcher for media swaping
  210.             fetcher.Shutdown()
  211.         return (res == pm.ResultCompleted)
  212.  
  213.     # cache changes
  214.     def cachePostChange(self):
  215.         " called internally if the cache has changed, emit a signal then "
  216.         self._runCallbacks("cache_post_change")
  217.  
  218.     def cachePreChange(self):
  219.         """ called internally if the cache is about to change, emit
  220.             a signal then """
  221.         self._runCallbacks("cache_pre_change")
  222.  
  223.     def connect(self, name, callback):
  224.         """ connect to a signal, currently only used for
  225.             cache_{post,pre}_{changed,open} """
  226.         if not self._callbacks.has_key(name):
  227.             self._callbacks[name] = []
  228.         self._callbacks[name].append(callback)
  229.  
  230. # ----------------------------- experimental interface
  231. class Filter(object):
  232.     """ Filter base class """
  233.     def apply(self, pkg):
  234.         """ Filter function, return True if the package matchs a
  235.             filter criteria and False otherwise
  236.         """
  237.         return True
  238.  
  239. class MarkedChangesFilter(Filter):
  240.     """ Filter that returns all marked changes """
  241.     def apply(self, pkg):
  242.         if pkg.markedInstall or pkg.markedDelete or pkg.markedUpgrade:
  243.             return True
  244.         else:
  245.             return False
  246.  
  247. class FilteredCache(object):
  248.     """ A package cache that is filtered.
  249.  
  250.         Can work on a existing cache or create a new one
  251.     """
  252.     def __init__(self, cache=None, progress=None):
  253.         if cache == None:
  254.             self.cache = Cache(progress)
  255.         else:
  256.             self.cache = cache
  257.         self.cache.connect("cache_post_change", self.filterCachePostChange)
  258.         self.cache.connect("cache_post_open", self.filterCachePostChange)
  259.         self._filtered = {}
  260.         self._filters = []
  261.     def __len__(self):
  262.         return len(self._filtered)
  263.     
  264.     def __getitem__(self, key):
  265.         return self.cache._dict[key]
  266.  
  267.     def keys(self):
  268.         return self._filtered.keys()
  269.  
  270.     def has_key(self, key):
  271.         return self._filtered.has_key(key)
  272.  
  273.     def _reapplyFilter(self):
  274.         " internal helper to refilter "
  275.         self._filtered = {}
  276.         for pkg in self.cache._dict.keys():
  277.             for f in self._filters:
  278.                 if f.apply(self.cache._dict[pkg]):
  279.                     self._filtered[pkg] = 1
  280.                     break
  281.     
  282.     def setFilter(self, filter):
  283.         " set the current active filter "
  284.         self._filters = []
  285.         self._filters.append(filter)
  286.         #self._reapplyFilter()
  287.         # force a cache-change event that will result in a refiltering
  288.         self.cache.cachePostChange()
  289.  
  290.     def filterCachePostChange(self):
  291.         " called internally if the cache changes, emit a signal then "
  292.         #print "filterCachePostChange()"
  293.         self._reapplyFilter()
  294.  
  295. #    def connect(self, name, callback):
  296. #        self.cache.connect(name, callback)
  297.  
  298.     def __getattr__(self, key):
  299.         " we try to look exactly like a real cache "
  300.         #print "getattr: %s " % key
  301.         if self.__dict__.has_key(key):
  302.             return self.__dict__[key]
  303.         else:
  304.             return getattr(self.cache, key)
  305.             
  306.  
  307. def cache_pre_changed():
  308.     print "cache pre changed"
  309.  
  310. def cache_post_changed():
  311.     print "cache post changed"
  312.  
  313.  
  314. # internal test code
  315. if __name__ == "__main__":
  316.     print "Cache self test"
  317.     apt_pkg.init()
  318.     c = Cache(apt.progress.OpTextProgress())
  319.     c.connect("cache_pre_change", cache_pre_changed)
  320.     c.connect("cache_post_change", cache_post_changed)
  321.     print c.has_key("aptitude")
  322.     p = c["aptitude"]
  323.     print p.name
  324.     print len(c)
  325.  
  326.     for pkg in c.keys():
  327.         x= c[pkg].name
  328.  
  329.     c.upgrade()
  330.     changes = c.getChanges()
  331.     print len(changes)
  332.     for p in changes:
  333.         #print p.name
  334.         x = p.name
  335.  
  336.  
  337.     # see if fetching works
  338.     for d in ["/tmp/pytest", "/tmp/pytest/partial"]:
  339.         if not os.path.exists(d):
  340.             os.mkdir(d)
  341.     apt_pkg.Config.Set("Dir::Cache::Archives","/tmp/pytest")
  342.     pm = apt_pkg.GetPackageManager(c._depcache)
  343.     fetcher = apt_pkg.GetAcquire(apt.progress.TextFetchProgress())
  344.     c._fetchArchives(fetcher, pm)
  345.     #sys.exit(1)
  346.  
  347.     print "Testing filtered cache (argument is old cache)"
  348.     f = FilteredCache(c)
  349.     f.cache.connect("cache_pre_change", cache_pre_changed)
  350.     f.cache.connect("cache_post_change", cache_post_changed)
  351.     f.cache.upgrade()
  352.     f.setFilter(MarkedChangesFilter())
  353.     print len(f)
  354.     for pkg in f.keys():
  355.         #print c[pkg].name
  356.         x = f[pkg].name
  357.     
  358.     print len(f)
  359.  
  360.     print "Testing filtered cache (no argument)"
  361.     f = FilteredCache(progress=OpTextProgress())
  362.     f.cache.connect("cache_pre_change", cache_pre_changed)
  363.     f.cache.connect("cache_post_change", cache_post_changed)
  364.     f.cache.upgrade()
  365.     f.setFilter(MarkedChangesFilter())
  366.     print len(f)
  367.     for pkg in f.keys():
  368.         #print c[pkg].name
  369.         x = f[pkg].name
  370.     
  371.     print len(f)
  372.