home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / share / pyshared / UpdateManager / Core / MetaRelease.py < prev    next >
Encoding:
Python Source  |  2009-04-27  |  10.6 KB  |  270 lines
  1. # MetaRelease.py 
  2. #  
  3. #  Copyright (c) 2004,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 thread
  23. import urllib2
  24. import httplib
  25. import os
  26. import string
  27. import apt_pkg
  28. import time
  29. import sys
  30. import rfc822
  31. from ConfigParser import ConfigParser
  32. from subprocess import Popen,PIPE
  33.  
  34. from utils import *
  35.  
  36. class Dist(object):
  37.     def __init__(self, name, version, date, supported):
  38.         self.name = name
  39.         self.version = version
  40.         self.date = date
  41.         self.supported = supported
  42.         self.releaseNotesURI = None
  43.         self.upgradeTool = None
  44.         self.upgradeToolSig = None
  45.  
  46. class MetaReleaseCore(object):
  47.     """
  48.     A MetaReleaseCore object astracts the list of released 
  49.     distributions. 
  50.     """
  51.  
  52.     DEBUG = "DEBUG_UPDATE_MANAGER" in os.environ
  53.  
  54.     # some constants
  55.     CONF = "/etc/update-manager/release-upgrades"
  56.     CONF_METARELEASE = "/etc/update-manager/meta-release"
  57.  
  58.     def __init__(self, 
  59.                  useDevelopmentRelease=False, 
  60.                  useProposed=False,
  61.                  forceLTS=False):
  62.         self._debug("MetaRelease.__init__() useDevel=%s useProposed=%s" % (useDevelopmentRelease, useProposed))
  63.         # information about the available dists
  64.         self.downloading = True
  65.         self.new_dist = None
  66.         self.current_dist_name = get_dist()
  67.         self.no_longer_supported = None
  68.  
  69.         # default (if the conf file is missing)
  70.         self.METARELEASE_URI = "http://changelogs.ubuntu.com/meta-release"
  71.         self.METARELEASE_URI_LTS = "http://changelogs.ubuntu.com/meta-release-lts"
  72.         self.METARELEASE_URI_UNSTABLE_POSTFIX = "-development"
  73.         self.METARELEASE_URI_PROPOSED_POSTFIX = "-development"
  74.  
  75.         # check the meta-release config first
  76.         parser = ConfigParser()
  77.         if os.path.exists(self.CONF_METARELEASE):
  78.             parser.read(self.CONF_METARELEASE)
  79.             # make changing the metarelease file and the location
  80.             # for the files easy
  81.             if parser.has_section("METARELEASE"):
  82.                 sec = "METARELEASE"
  83.                 for k in ["URI",
  84.                           "URI_LTS",
  85.                           "URI_UNSTABLE_POSTFIX",
  86.                           "URI_PROPOSED_POSTFIX"]:
  87.                     if parser.has_option(sec, k):
  88.                         self._debug("%s: %s " % (self.CONF_METARELEASE,
  89.                                                  parser.get(sec,k)))
  90.                         setattr(self, "%s_%s" % (sec, k), parser.get(sec, k))
  91.  
  92.         # check the config file first to figure if we want lts upgrades only
  93.         parser = ConfigParser()
  94.         if os.path.exists(self.CONF):
  95.             parser.read(self.CONF)
  96.             # now check which specific url to use
  97.             if parser.has_option("DEFAULT","Prompt"):
  98.                 type = parser.get("DEFAULT","Prompt").lower()
  99.                 if (type == "never" or type == "no"):
  100.                     # nothing to do for this object
  101.                     # FIXME: what about no longer supported?
  102.                     self.downloading = False
  103.                     return
  104.                 elif type == "lts":
  105.                     self.METARELEASE_URI = self.METARELEASE_URI_LTS
  106.         # needed for the _tryUpgradeSelf() code in DistUpgradeController
  107.         if forceLTS:
  108.             self.METARELEASE_URI = self.METARELEASE_URI_LTS
  109.         # devel and proposed "just" change the postfix
  110.         if useDevelopmentRelease:
  111.             self.METARELEASE_URI += self.METARELEASE_URI_UNSTABLE_POSTFIX
  112.         elif useProposed:
  113.             self.METARELEASE_URI += self.METARELEASE_URI_PROPOSED_POSTFIX
  114.  
  115.         self._debug("metarelease-uri: %s" % self.METARELEASE_URI)
  116.         self.metarelease_information = None
  117.         if not self._buildMetaReleaseFile():
  118.             self._debug("_buildMetaReleaseFile failed")
  119.             return
  120.         # we start the download thread here and we have a timeout
  121.         t=thread.start_new_thread(self.download, ())
  122.         #t=thread.start_new_thread(self.check, ())
  123.  
  124.     def _buildMetaReleaseFile(self):
  125.         # build the metarelease_file name
  126.         self.METARELEASE_FILE = os.path.join("/var/lib/update-manager/",
  127.                                             os.path.basename(self.METARELEASE_URI))
  128.         # check if we can write to the global location, if not,
  129.         # write to homedir
  130.         try:
  131.             open(self.METARELEASE_FILE,"a")
  132.         except IOError, e:
  133.             path = os.path.expanduser("~/.update-manager-core/")
  134.             if not os.path.exists(path):
  135.         try:
  136.                     os.mkdir(path)
  137.         except OSError, e:
  138.                     sys.stderr.write("mkdir() failed: '%s'" % e)
  139.             return False
  140.             self.METARELEASE_FILE = os.path.join(path,os.path.basename(self.METARELEASE_URI))
  141.         # if it is empty, remove it to avoid I-M-S hits on empty file
  142.         try:
  143.             if os.path.getsize(self.METARELEASE_FILE) == 0:
  144.                 os.unlink(self.METARELEASE_FILE)
  145.         except Exception, e:
  146.             pass
  147.         return True
  148.  
  149.     def dist_no_longer_supported(self, dist):
  150.         """ virtual function that is called when the distro is no longer
  151.             supported
  152.         """
  153.         self.no_longer_supported = dist
  154.     def new_dist_available(self, dist):
  155.         """ virtual function that is called when a new distro release
  156.             is available
  157.         """
  158.         self.new_dist = dist
  159.  
  160.     def parse(self):
  161.         self._debug("MetaRelease.parse()")
  162.         current_dist_name = self.current_dist_name
  163.         self._debug("current dist name: '%s'" % current_dist_name)
  164.         current_dist = None
  165.         dists = []
  166.  
  167.         # parse the metarelease_information file
  168.         index_tag = apt_pkg.ParseTagFile(self.metarelease_information)
  169.         step_result = index_tag.Step()
  170.         while step_result:
  171.             if index_tag.Section.has_key("Dist"):
  172.                 name = index_tag.Section["Dist"]
  173.                 #print name
  174.                 rawdate = index_tag.Section["Date"]
  175.                 date = time.mktime(rfc822.parsedate(rawdate))
  176.                 supported = int(index_tag.Section["Supported"])
  177.                 version = index_tag.Section["Version"]
  178.                 # add the information to a new date object
  179.                 dist = Dist(name, version, date,supported)
  180.                 if index_tag.Section.has_key("ReleaseNotes"):
  181.                     dist.releaseNotesURI = index_tag.Section["ReleaseNotes"]
  182.                 if index_tag.Section.has_key("UpgradeTool"):
  183.                     dist.upgradeTool =  index_tag.Section["UpgradeTool"]
  184.                 if index_tag.Section.has_key("UpgradeToolSignature"):
  185.                     dist.upgradeToolSig =  index_tag.Section["UpgradeToolSignature"]
  186.                 dists.append(dist)
  187.                 if name == current_dist_name:
  188.                     current_dist = dist 
  189.             step_result = index_tag.Step()
  190.  
  191.         # first check if the current runing distro is in the meta-release
  192.         # information. if not, we assume that we run on something not
  193.         # supported and silently return
  194.         if current_dist is None:
  195.             #sys.stderr.write("current dist not found in meta-release file\n")
  196.             return False
  197.  
  198.         # then see what we can upgrade to (only upgrade to supported dists)
  199.         upgradable_to = ""
  200.         for dist in dists:
  201.             if dist.date > current_dist.date and dist.supported == True: 
  202.                 upgradable_to = dist
  203.                 self._debug("new dist: %s" % upgradable_to)
  204.                 break
  205.  
  206.         # only warn if unsupported and a new dist is available (because 
  207.         # the development version is also unsupported)
  208.         if upgradable_to != "" and not current_dist.supported:
  209.             self.dist_no_longer_supported(upgradable_to)
  210.         if upgradable_to != "":
  211.             self.new_dist_available(upgradable_to)
  212.  
  213.         # parsing done and sucessfully
  214.         return True
  215.  
  216.     # the network thread that tries to fetch the meta-index file
  217.     # can't touch the gui, runs as a thread
  218.     def download(self):
  219.         self._debug("MetaRelease.download()")
  220.         lastmodified = 0
  221.         req = urllib2.Request(self.METARELEASE_URI)
  222.         # make sure that we always get the latest file (#107716)
  223.         req.add_header("Cache-Control", "No-Cache")
  224.         req.add_header("Pragma", "no-cache")
  225.         if os.access(self.METARELEASE_FILE, os.W_OK):
  226.             lastmodified = os.stat(self.METARELEASE_FILE).st_mtime
  227.         if lastmodified > 0:
  228.             req.add_header("If-Modified-Since", time.asctime(time.gmtime(lastmodified)))
  229.         try:
  230.             uri=urllib2.urlopen(req)
  231.             # sometime there is a root owned meta-relase file
  232.             # there, try to remove it so that we get it
  233.             # with proper permissions
  234.             if (os.path.exists(self.METARELEASE_FILE) and
  235.                 not os.access(self.METARELEASE_FILE,os.W_OK)):
  236.                 try:
  237.                     os.unlink(self.METARELEASE_FILE)
  238.                 except OSError,e:
  239.                     print "Can't unlink '%s' (%s)" % (self.METARELEASE_FILE,e)
  240.             # we may get excpetion here on e.g. disk full
  241.             try:
  242.                 f=open(self.METARELEASE_FILE,"w+")
  243.                 for line in uri.readlines():
  244.                     f.write(line)
  245.                 f.flush()
  246.                 f.seek(0,0)
  247.                 self.metarelease_information=f
  248.             except IOError, e:
  249.                 pass
  250.             uri.close()
  251.         except (urllib2.URLError, httplib.BadStatusLine), e:
  252.             if os.path.exists(self.METARELEASE_FILE):
  253.                 self.metarelease_information=open(self.METARELEASE_FILE,"r")
  254.         # now check the information we have
  255.         if self.metarelease_information != None:
  256.             self._debug("have self.metarelease_information")
  257.             self.parse()
  258.         else:
  259.             self._debug("NO self.metarelease_information")
  260.         self.downloading = False
  261.  
  262.     def _debug(self, msg):
  263.         if self.DEBUG:
  264.             sys.stderr.write(msg+"\n")
  265.  
  266.  
  267. if __name__ == "__main__":
  268.     meta = MetaReleaseCore(False, False)
  269.     
  270.