home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / share / pyshared / UpdateManager / Core / MyCache.py < prev    next >
Encoding:
Python Source  |  2009-04-27  |  10.1 KB  |  247 lines
  1. # MyCache.py 
  2. #  
  3. #  Copyright (c) 2004-2008 Canonical
  4. #  
  5. #  Author: Michael Vogt <mvo@debian.org>
  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 warnings
  23. warnings.filterwarnings("ignore", "apt API not stable yet", FutureWarning)
  24. import apt
  25. import apt_pkg
  26. import os
  27. import string
  28. import urllib2
  29. import httplib
  30. import socket
  31. import re
  32. import DistUpgrade.DistUpgradeCache
  33. from DistUpgrade.DistUpgradeCache import NotEnoughFreeSpaceError
  34. from gettext import gettext as _
  35.  
  36. SYNAPTIC_PINFILE = "/var/lib/synaptic/preferences"
  37. CHANGELOGS_URI="http://changelogs.ubuntu.com/changelogs/pool/%s/%s/%s/%s_%s/%s"
  38.  
  39.  
  40. class MyCache(DistUpgrade.DistUpgradeCache.MyCache):
  41.     def __init__(self, progress, rootdir=None):
  42.         apt.Cache.__init__(self, progress, rootdir)
  43.         # raise if we have packages in reqreinst state
  44.         # and let the caller deal with that (runs partial upgrade)
  45.         assert len(self.reqReinstallPkgs) == 0
  46.         # init the regular cache
  47.         self._initDepCache()
  48.         self.all_changes = {}
  49.         self.all_news = {}
  50.         # on broken packages, try to fix via saveDistUpgrade()
  51.         if self._depcache.BrokenCount > 0:
  52.             self.saveDistUpgrade()
  53.         assert (self._depcache.BrokenCount == 0 and 
  54.                 self._depcache.DelCount == 0)
  55.  
  56.     def _initDepCache(self):
  57.         #apt_pkg.Config.Set("Debug::pkgPolicy","1")
  58.         #self.depcache = apt_pkg.GetDepCache(self.cache)
  59.         #self._depcache = apt_pkg.GetDepCache(self._cache)
  60.         self._depcache.ReadPinFile()
  61.         if os.path.exists(SYNAPTIC_PINFILE):
  62.             self._depcache.ReadPinFile(SYNAPTIC_PINFILE)
  63.         self._depcache.Init()
  64.     def clear(self):
  65.         self._initDepCache()
  66.     @property
  67.     def requiredDownload(self):
  68.         """ get the size of the packages that are required to download """
  69.         pm = apt_pkg.GetPackageManager(self._depcache)
  70.         fetcher = apt_pkg.GetAcquire()
  71.         pm.GetArchives(fetcher, self._list, self._records)
  72.         return fetcher.FetchNeeded
  73.     @property
  74.     def installCount(self):
  75.         return self._depcache.InstCount
  76.     def saveDistUpgrade(self):
  77.         """ this functions mimics a upgrade but will never remove anything """
  78.         self._depcache.Upgrade(True)
  79.         wouldDelete = self._depcache.DelCount
  80.         if self._depcache.DelCount > 0:
  81.             self.clear()
  82.         assert self._depcache.BrokenCount == 0 and self._depcache.DelCount == 0
  83.         self._depcache.Upgrade()
  84.         return wouldDelete
  85.     def matchPackageOrigin(self, pkg, matcher):
  86.         """ match 'pkg' origin against 'matcher', take versions between
  87.             installedVersion and candidateVersion into account too
  88.             Useful if installed pkg A v1.0 is available in both
  89.             -updates (as v1.2) and -security (v1.1). we want to display
  90.             it as a security update then
  91.         """
  92.         inst_ver = pkg._pkg.CurrentVer
  93.         cand_ver = self._depcache.GetCandidateVer(pkg._pkg)
  94.         # init matcher with candidateVer
  95.         update_origin = matcher[(None,None)]
  96.         for(verFileIter,index) in cand_ver.FileList:
  97.             if matcher.has_key((verFileIter.Archive, verFileIter.Origin)):
  98.                 indexfile = pkg._pcache._list.FindIndex(verFileIter)
  99.                 if indexfile: # and indexfile.IsTrusted:
  100.                     match = matcher[verFileIter.Archive, verFileIter.Origin]
  101.                     update_origin = match
  102.         # if the candidate comes from a unknown source (e.g. a PPA) skip
  103.         # skip the shadow logic below as it would put e.g. a PPA package
  104.         # in "Recommended updates" when the version in the PPA 
  105.         # is higher than the one in %s-updates
  106.         if update_origin.importance < 0:
  107.             return update_origin
  108.         # for known packages, check if we have higher versions that
  109.         # "shadow" this one
  110.         for ver in pkg._pkg.VersionList:
  111.             # discard is < than installed ver
  112.             if (inst_ver and
  113.                 apt_pkg.VersionCompare(ver.VerStr, inst_ver.VerStr) <= 0):
  114.                 #print "skipping '%s' " % ver.VerStr
  115.                 continue
  116.             # check if we have a match
  117.             for(verFileIter,index) in ver.FileList:
  118.                 if matcher.has_key((verFileIter.Archive, verFileIter.Origin)):
  119.                     indexfile = pkg._pcache._list.FindIndex(verFileIter)
  120.                     if indexfile: # and indexfile.IsTrusted:
  121.                         match = matcher[verFileIter.Archive, verFileIter.Origin]
  122.                         if match.importance > update_origin.importance:
  123.                             update_origin = match
  124.         return update_origin
  125.  
  126.     def _strip_epoch(self, verstr):
  127.         " strip of the epoch "
  128.         l = string.split(verstr,":")
  129.         if len(l) > 1:
  130.             verstr = "".join(l[1:])
  131.         return verstr
  132.         
  133.     def _get_changelog_or_news(self, name, fname, strict_versioning=False):
  134.         " helper that fetches the file in question "
  135.         # don't touch the gui in this function, it needs to be thread-safe
  136.         pkg = self[name]
  137.  
  138.         # get the src package name
  139.         srcpkg = pkg.sourcePackageName
  140.  
  141.         # assume "main" section 
  142.         src_section = "main"
  143.         # use the section of the candidate as a starting point
  144.         section = pkg._pcache._depcache.GetCandidateVer(pkg._pkg).Section
  145.  
  146.         # get the source version, start with the binaries version
  147.         binver = pkg.candidateVersion
  148.         srcver_epoch = pkg.candidateVersion
  149.         srcver = self._strip_epoch(srcver_epoch)
  150.         #print "bin: %s" % binver
  151.  
  152.         l = section.split("/")
  153.         if len(l) > 1:
  154.             src_section = l[0]
  155.  
  156.         # lib is handled special
  157.         prefix = srcpkg[0]
  158.         if srcpkg.startswith("lib"):
  159.             prefix = "lib" + srcpkg[3]
  160.  
  161.         uri = CHANGELOGS_URI % (src_section,prefix,srcpkg,srcpkg, srcver, fname)
  162.         # print "Trying: %s " % uri
  163.         changelog = urllib2.urlopen(uri)
  164.         #print changelog.read()
  165.         # do only get the lines that are new
  166.         alllines = ""
  167.         regexp = "^%s \((.*)\)(.*)$" % (re.escape(srcpkg))
  168.         
  169.         i=0
  170.         while True:
  171.             line = changelog.readline()
  172.             if line == "":
  173.                 break
  174.             match = re.match(regexp,line)
  175.             if match:
  176.                 # strip epoch from installed version
  177.                 # and from changelog too
  178.                 installed = pkg.installedVersion
  179.                 if installed and ":" in installed:
  180.                     installed = installed.split(":",1)[1]
  181.                 changelogver = match.group(1)
  182.                 if changelogver and ":" in changelogver:
  183.                     changelogver = changelogver.split(":",1)[1]
  184.                 # we test for "==" here for changelogs 
  185.                 # to ensure that the version
  186.                 # is actually really in the changelog - if not
  187.                 # just display it all, this catches cases like:
  188.                 # gcc-defaults with "binver=4.3.1" and srcver=1.76
  189.                 # 
  190.                 # for NEWS.Debian we do require the changelogver > installed
  191.                 if strict_versioning:
  192.                     if (installed and 
  193.                         apt_pkg.VersionCompare(changelogver,installed)<0):
  194.                         break
  195.                 else:
  196.                     if (installed and 
  197.                         apt_pkg.VersionCompare(changelogver,installed)==0):
  198.                         break
  199.             alllines = alllines + line
  200.         return alllines
  201.         
  202.     def get_news_and_changelog(self, name, lock):
  203.         self.get_news(name)
  204.         self.get_changelog(name)
  205.         lock.release()        
  206.     
  207.     def get_news(self, name):
  208.         " get the NEWS.Debian file from the changelogs location "
  209.         try:
  210.             news = self._get_changelog_or_news(name, "NEWS.Debian", True)
  211.         except Exception, e:
  212.             return
  213.         if news:
  214.             self.all_news[name] = news
  215.                     
  216.     def get_changelog(self, name):
  217.         " get the changelog file from the changelog location "
  218.         origins = self[name].candidateOrigin
  219.         if not "Ubuntu" in [o.origin for o in origins]:
  220.             # FIXME: better string, but we are in string freeze
  221.             self.all_changes[name] = _("Failed to detect distribution")
  222.             return
  223.         srcpkg = self[name].sourcePackageName
  224.         srcver_epoch = self[name].candidateVersion.replace(':', '%3A')
  225.         try:
  226.             changelog = self._get_changelog_or_news(name, "changelog")
  227.             if len(changelog) == 0:
  228.                 changelog = _("The changelog does not contain any relevant changes.\n\n"
  229.                               "Please use http://launchpad.net/ubuntu/+source/%s/%s/+changelog\n"
  230.                               "until the changes become available or try again "
  231.                               "later.") % (srcpkg, srcver_epoch)
  232.         except urllib2.HTTPError, e:
  233.             changelog = _("The list of changes is not available yet.\n\n"
  234.                           "Please use http://launchpad.net/ubuntu/+source/%s/%s/+changelog\n"
  235.                           "until the changes become available or try again "
  236.                           "later.") % (srcpkg, srcver_epoch)
  237.         except (IOError, httplib.BadStatusLine, socket.error), e:
  238.             print "caught exception: ", e
  239.             changelog = _("Failed to download the list "
  240.                           "of changes. \nPlease "
  241.                           "check your Internet "
  242.                           "connection.")
  243.         self.all_changes[name] = changelog
  244.  
  245.  
  246.  
  247.