home *** CD-ROM | disk | FTP | other *** search
/ PC Welt 2006 November (DVD) / PCWELT_11_2006.ISO / casper / filesystem.squashfs / usr / lib / python2.4 / site-packages / UpdateManager / Common / aptsources.py < prev    next >
Encoding:
Python Source  |  2006-08-24  |  21.0 KB  |  673 lines
  1. # aptsource.py.in - parse sources.list
  2. #  
  3. #  Copyright (c) 2004,2005 Canonical
  4. #                2004 Michiel Sikkes
  5. #  
  6. #  Author: Michiel Sikkes <michiel@eyesopened.nl>
  7. #          Michael Vogt <mvo@debian.org>
  8. # 
  9. #  This program is free software; you can redistribute it and/or 
  10. #  modify it under the terms of the GNU General Public License as 
  11. #  published by the Free Software Foundation; either version 2 of the
  12. #  License, or (at your option) any later version.
  13. # 
  14. #  This program is distributed in the hope that it will be useful,
  15. #  but WITHOUT ANY WARRANTY; without even the implied warranty of
  16. #  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17. #  GNU General Public License for more details.
  18. # 
  19. #  You should have received a copy of the GNU General Public License
  20. #  along with this program; if not, write to the Free Software
  21. #  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  22. #  USA
  23.  
  24. import string
  25. import gettext
  26. import re
  27. import apt_pkg
  28. import glob
  29. import shutil
  30. import time
  31. import os.path
  32.  
  33. #import pdb
  34.  
  35. from UpdateManager.Common.DistInfo import DistInfo
  36.  
  37.  
  38. # some global helpers
  39. def is_mirror(master_uri, compare_uri):
  40.   """check if the given add_url is idential or a mirror of orig_uri
  41.     e.g. master_uri = archive.ubuntu.com
  42.       compare_uri = de.archive.ubuntu.com
  43.       -> True
  44.   """
  45.   # remove traling spaces and "/"
  46.   compare_uri = compare_uri.rstrip("/ ")
  47.   master_uri = master_uri.rstrip("/ ")
  48.   # uri is identical
  49.   if compare_uri == master_uri:
  50.     #print "Identical"
  51.     return True
  52.   # add uri is a master site and orig_uri has the from "XX.mastersite"
  53.   # (e.g. de.archive.ubuntu.com)
  54.   try:
  55.     compare_srv = compare_uri.split("//")[1]
  56.     master_srv = master_uri.split("//")[1]
  57.     #print "%s == %s " % (add_srv, orig_srv)
  58.   except IndexError: # ok, somethings wrong here
  59.     #print "IndexError"
  60.     return False
  61.   # remove the leading "<country>." (if any) and see if that helps
  62.   if "." in compare_srv and \
  63.          compare_srv[compare_srv.index(".")+1:] == master_srv:
  64.     #print "Mirror"
  65.     return True
  66.   return False
  67.  
  68. def uniq(s):
  69.   """ simple and efficient way to return uniq list """
  70.   return list(set(s))
  71.  
  72.  
  73.  
  74. # actual source.list entries
  75. class SourceEntry:
  76.  
  77.   def __init__(self, line,file=None):
  78.     self.invalid = False
  79.     self.disabled = False
  80.     self.type = ""
  81.     self.uri = ""
  82.     self.dist = ""
  83.     self.comps = []
  84.     self.comment = ""
  85.     self.line = line
  86.     if file == None:
  87.       file = apt_pkg.Config.FindDir("Dir::Etc")+apt_pkg.Config.Find("Dir::Etc::sourcelist")
  88.     self.file = file
  89.     self.parse(line)
  90.     self.template = None
  91.     self.children = []
  92.  
  93.   # works mostely like split but takes [] into account
  94.   def mysplit(self, line):
  95.     line = string.strip(line)
  96.     pieces = []
  97.     tmp = ""
  98.     # we are inside a [..] block
  99.     p_found = False
  100.     space_found = False
  101.     for i in range(len(line)):
  102.       if line[i] == "[":
  103.         p_found=True
  104.         tmp += line[i]
  105.       elif line[i] == "]":
  106.         p_found=False
  107.         tmp += line[i]
  108.       elif space_found and not line[i].isspace(): # we skip one or more space
  109.         space_found = False
  110.         pieces.append(tmp)
  111.         tmp = line[i]
  112.       elif line[i].isspace() and not p_found:     # found a whitespace
  113.         space_found = True
  114.       else:
  115.         tmp += line[i]
  116.     # append last piece
  117.     if len(tmp) > 0:
  118.       pieces.append(tmp)
  119.     return pieces
  120.  
  121.  
  122.   # parse a given source line and split it into the fields we need
  123.   def parse(self,line):
  124.     line  = string.strip(self.line)
  125.     #print line
  126.     # check if the source is enabled/disabled
  127.     if line == "" or line == "#": # empty line
  128.       self.invalid = True
  129.       return
  130.     if line[0] == "#":
  131.       self.disabled = True
  132.       pieces = string.split(line[1:])
  133.       # if it looks not like a disabled deb line return 
  134.       if not (pieces[0] == "deb" or pieces[0] == "deb-src"):
  135.         self.invalid = True
  136.         return
  137.       else:
  138.         line = line[1:]
  139.     # check for another "#" in the line (this is treated as a comment)
  140.     i = line.find("#")
  141.     if i > 0:
  142.       self.comment = line[i+1:]
  143.       line = line[:i]
  144.     # source is ok, split it and see what we have
  145.     pieces = self.mysplit(line)
  146.     # Sanity check
  147.     if len(pieces) < 3:
  148.         self.invalid = True
  149.         return
  150.     # Type, deb or deb-src
  151.     self.type = string.strip(pieces[0])
  152.     # Sanity check
  153.     if self.type not in ("deb", "deb-src"):
  154.       self.invalid = True
  155.       return
  156.     # URI
  157.     self.uri = string.strip(pieces[1])
  158.     if len(self.uri) < 1:
  159.       self.invalid = True
  160.     # distro and components (optional)
  161.     # Directory or distro
  162.     self.dist = string.strip(pieces[2])
  163.     if len(pieces) > 3:
  164.       # List of components
  165.       self.comps = pieces[3:]
  166.     else:
  167.       self.comps = []
  168.  
  169.     #print self.__dict__
  170.  
  171.  
  172.   # set enabled/disabled
  173.   def set_enabled(self, new_value):
  174.     self.disabled = not new_value
  175.     # enable, remove all "#" from the start of the line
  176.     if new_value == True:
  177.       i=0
  178.       self.line = string.lstrip(self.line)
  179.       while self.line[i] == "#":
  180.         i += 1
  181.       self.line = self.line[i:]
  182.     else:
  183.       # disabled, add a "#" 
  184.       if string.strip(self.line)[0] != "#":
  185.         self.line = "#" + self.line
  186.  
  187.   def __str__(self):
  188.     """ debug helper """
  189.     return self.str().strip()
  190.  
  191.   def str(self):
  192.     """ return the current line as string """
  193.     if self.invalid:
  194.       return self.line
  195.     line = ""
  196.     if self.disabled:
  197.       line = "# "
  198.     line += "%s %s %s" % (self.type, self.uri, self.dist)
  199.     if len(self.comps) > 0:
  200.       line += " " + " ".join(self.comps)
  201.     if self.comment != "":
  202.       line += " #"+self.comment
  203.     line += "\n"
  204.     return line
  205.     
  206. # the SourceList file as a class
  207. class NullMatcher(object):
  208.   def match(self, s):
  209.     return True
  210.  
  211. class SourcesList:
  212.   def __init__(self, withMatcher=True):
  213.     self.list = []      # of Type SourceEntries
  214.     if withMatcher:
  215.       self.matcher = SourceEntryMatcher()
  216.     else:
  217.       self.matcher = NullMatcher()
  218.     self.refresh()
  219.  
  220.   def refresh(self):
  221.     self.list = []
  222.     # read sources.list
  223.     dir = apt_pkg.Config.FindDir("Dir::Etc")
  224.     file = apt_pkg.Config.Find("Dir::Etc::sourcelist")
  225.     self.load(dir+file)
  226.     # read sources.list.d
  227.     partsdir = apt_pkg.Config.FindDir("Dir::Etc::sourceparts")
  228.     for file in glob.glob("%s/*.list" % partsdir):
  229.       self.load(file)
  230.     # check if the source item fits a predefined template
  231.     for source in self.list:
  232.         if source.invalid == False:
  233.             self.matcher.match(source)
  234.  
  235.   def __iter__(self):
  236.     for entry in self.list:
  237.       yield entry
  238.     raise StopIteration
  239.  
  240.   def add(self, type, uri, dist, comps, comment="", pos=-1, file=None):
  241.     """
  242.     Add a new source to the sources.list.
  243.     The method will search for existing matching repos and will try to 
  244.     reuse them as far as possible
  245.     """
  246.     for source in self.list:
  247.       # if there is a repo with the same (type, uri, dist) just add the
  248.       # components
  249.       if source.disabled == False and source.invalid == False and \
  250.          source.type == type and uri == source.uri and \
  251.          source.dist == dist:
  252.         comps = uniq(source.comps + comps)
  253.         source.comps = comps
  254.         return source
  255.       # if there is a corresponding repo which is disabled, enable it
  256.       elif source.disabled == True and source.invalid == False and \
  257.            source.type == type and uri == source.uri and \
  258.            source.dist == dist and \
  259.            len(set(source.comps) & set(comps)) == len(comps):
  260.         source.disabled = False
  261.         return source
  262.     # there isn't any matching source, so create a new line and parse it
  263.     line = "%s %s %s" % (type,uri,dist)
  264.     for c in comps:
  265.       line = line + " " + c;
  266.     if comment != "":
  267.       line = "%s #%s\n" %(line,comment)
  268.     line = line + "\n"
  269.     new_entry = SourceEntry(line)
  270.     if file != None:
  271.       new_entry.file = file
  272.     self.matcher.match(new_entry)
  273.     self.list.insert(pos, new_entry)
  274.     return new_entry
  275.  
  276.   def remove(self, source_entry):
  277.     self.list.remove(source_entry)
  278.  
  279.   def restoreBackup(self, backup_ext):
  280.     " restore sources.list files based on the backup extension "
  281.     dir = apt_pkg.Config.FindDir("Dir::Etc")
  282.     file = apt_pkg.Config.Find("Dir::Etc::sourcelist")
  283.     if os.path.exists(dir+file+backup_ext):
  284.       shutil.copy(dir+file+backup_ext,dir+file)
  285.     # now sources.list.d
  286.     partsdir = apt_pkg.Config.FindDir("Dir::Etc::sourceparts")
  287.     for file in glob.glob("%s/*.list" % partsdir):
  288.       if os.path.exists(file+backup_ext):
  289.         shutil.copy(file+backup_ext,file)
  290.  
  291.   def backup(self, backup_ext=None):
  292.     """ make a backup of the current source files, if no backup extension
  293.         is given, the current date/time is used (and returned) """
  294.     already_backuped = set()
  295.     if backup_ext == None:
  296.       backup_ext = time.strftime("%y%m%d.%H%M")
  297.     for source in self.list:
  298.       if not source.file in already_backuped:
  299.         shutil.copy(source.file,"%s%s" % (source.file,backup_ext))
  300.     return backup_ext
  301.  
  302.   def load(self,file):
  303.     """ (re)load the current sources """
  304.     try:
  305.       f = open(file, "r")
  306.       lines = f.readlines()
  307.       for line in lines:
  308.         source = SourceEntry(line,file)
  309.         self.list.append(source)
  310.     except:
  311.       print "could not open file '%s'" % file
  312.     else:
  313.       f.close()
  314.  
  315.   def save(self):
  316.     """ save the current sources """
  317.     files = {}
  318.     for source in self.list:
  319.       if not files.has_key(source.file):
  320.         files[source.file]=open(source.file,"w")
  321.       files[source.file].write(source.str())
  322.     for f in files:
  323.       files[f].close()
  324.  
  325.   def check_for_relations(self, sources_list):
  326.     """get all parent and child channels in the sources list"""
  327.     parents = []
  328.     used_child_templates = {}
  329.     for source in sources_list:
  330.       # try to avoid checking uninterressting sources
  331.       if source.template == None:
  332.         continue
  333.       # set up a dict with all used child templates and corresponding 
  334.       # source entries
  335.       if source.template.child == True:
  336.           key = source.template
  337.           if not used_child_templates.has_key(key):
  338.               used_child_templates[key] = []
  339.           temp = used_child_templates[key]
  340.           temp.append(source)
  341.       else:
  342.           # store each source with children aka. a parent :)
  343.           if len(source.template.children) > 0:
  344.               parents.append(source)
  345.     #print self.used_child_templates
  346.     #print self.parents
  347.     return (parents, used_child_templates)
  348.  
  349. # templates for the add dialog
  350. class SourceEntryTemplate(SourceEntry):
  351.   def __init__(self,a_type,uri,dist,description,comps):
  352.     self.comps_descriptions = []
  353.     self.type = a_type
  354.     self.uri = uri
  355.     self.dist = dist
  356.     self.description = description
  357.     self.comps = comps
  358.  
  359.   def matches(self,source_entry):
  360.     """ check if a given source_entry matches this one """
  361.     if (self.type != source_entry.type):
  362.       return False
  363.     if (self.dist != source_entry.dist):
  364.       return False
  365.     if not is_mirror(self.uri,source_entry.uri):
  366.       return False
  367.     for e_comp in source_entry.comps:
  368.       for t_comp in self.comps:
  369.         if e_comp == t_comp.name: break
  370.       else:
  371.         return False
  372.     return True
  373.  
  374. class SourceCompTemplate:
  375.   def __init__(self, name, description, on_by_default):
  376.     self.name = name
  377.     self.description = description
  378.     self.on_by_default = on_by_default
  379.  
  380. class SourceEntryTemplates:
  381.   def __init__(self,datadir):
  382.     _ = gettext.gettext
  383.     self.templates = []
  384.  
  385.     dinfo = DistInfo (base_dir=datadir+"channels/")
  386.  
  387.     for suite in dinfo.suites:
  388.       comps = []
  389.       for comp in suite.components:
  390.         comps.append(SourceCompTemplate(comp.name, _(comp.description),
  391.                                         comp.enabled))
  392.       self.templates.append (SourceEntryTemplate(suite.repository_type,
  393.                                                  suite.base_uri,
  394.                                                  suite.name,
  395.                                                  suite.description,
  396.                                                  comps))
  397.  
  398. # matcher class to make a source entry look nice
  399. # lots of predefined matchers to make it i18n/gettext friendly
  400. class SourceEntryMatcher:
  401.   class MatchType:
  402.     def __init__(self, a_type,a_descr):
  403.       self.type = a_type
  404.       self.description = a_descr
  405.   
  406.   class MatchDist:
  407.     def __init__(self,a_uri,a_dist, a_descr,l_comps, l_comps_descr):
  408.       self.uri = a_uri
  409.       self.dist = a_dist
  410.       self.description = a_descr
  411.       self.comps = l_comps
  412.       self.comps_descriptions = l_comps_descr
  413.  
  414.   def __init__(self):
  415.     self.templates = []
  416.     # Get the human readable channel and comp names from the channel .infos
  417.     spec_files = glob.glob("/usr/share/update-manager/channels/*.info")
  418.     for f in spec_files:
  419.         f = os.path.basename(f)
  420.         i = f.find(".info")
  421.         f = f[0:i]
  422.         dist = DistInfo(f)
  423.         for suite in dist.suites:
  424.             if suite.match_uri != None:
  425.                 self.templates.append(suite)
  426.     return
  427.  
  428.   def match(self, source):
  429.     """Add a matching template to the source"""
  430.     _ = gettext.gettext
  431.     found = False
  432.     for template in self.templates:
  433.       #print "'%s'" %source.uri
  434.       if re.search(template.match_uri, source.uri) and \
  435.          re.match(template.match_name, source.dist):
  436.         found = True
  437.         source.template = template
  438.         break
  439.     return found
  440.  
  441. class Distribution:
  442.   def __init__(self):
  443.     """"
  444.     Container for distribution specific informations
  445.     """
  446.     # LSB information
  447.     self.id = ""
  448.     self.codename = ""
  449.     self.description = ""
  450.     self.release = ""
  451.  
  452.     # get the LSB information
  453.     lsb_info = []
  454.     for lsb_option in ["-i", "-c", "-d", "-r"]:
  455.         pipe = os.popen("lsb_release %s -s" % lsb_option)
  456.         lsb_info.append(pipe.read().strip())
  457.         del pipe
  458.     (self.id, self.codename, self.description, self.release) = lsb_info
  459.  
  460.     # get a list of country codes and real names
  461.     self.countries = {}
  462.     try:
  463.         f = open("/usr/share/iso-codes/iso_3166.tab", "r")
  464.         lines = f.readlines()
  465.         for line in lines:
  466.             parts = line.split("\t")
  467.             self.countries[parts[0].lower()] = parts[1]
  468.     except:
  469.         print "could not open file '%s'" % file
  470.     else:
  471.         f.close()
  472.  
  473.   def get_sources(self, sources_list):
  474.     """
  475.     Find the corresponding template, main and child sources 
  476.     for the distribution 
  477.     """
  478.     # corresponding sources
  479.     self.source_template = None
  480.     self.child_sources = []
  481.     self.main_sources = []
  482.     self.disabled_sources = []
  483.     self.cdrom_sources = []
  484.     self.download_comps = []
  485.     self.enabled_comps = []
  486.     self.cdrom_comps = []
  487.     self.used_media = []
  488.     self.get_source_code = False
  489.     self.source_code_sources = []
  490.  
  491.     # location of the sources
  492.     self.default_server = ""
  493.     self.main_server = ""
  494.     self.nearest_server = ""
  495.     self.used_servers = []
  496.  
  497.     # find the distro template
  498.     for template in sources_list.matcher.templates:
  499.         if template.name == self.codename and\
  500.            template.distribution == self.id:
  501.             #print "yeah! found a template for %s" % self.description
  502.             #print template.description, template.base_uri, template.components
  503.             self.source_template = template
  504.             break
  505.     if self.source_template == None:
  506.         print "Error: could not find a distribution template"
  507.         # FIXME: will go away - only for debugging issues
  508.         sys.exit(1)
  509.  
  510.     # find main and child sources
  511.     media = []
  512.     comps = []
  513.     cdrom_comps = []
  514.     enabled_comps = []
  515.     source_code = []
  516.     for source in sources_list.list:
  517.         if source.invalid == False and\
  518.            source.dist == self.codename and\
  519.            source.template and\
  520.            source.template.name == self.codename:
  521.             #print "yeah! found a distro repo:  %s" % source.line
  522.             # cdroms need do be handled differently
  523.             if source.uri.startswith("cdrom:") and \
  524.                source.disabled == False:
  525.                 self.cdrom_sources.append(source)
  526.                 cdrom_comps.extend(source.comps)
  527.             elif source.uri.startswith("cdrom:") and \
  528.                  source.disabled == True:
  529.                 self.cdrom_sources.append(source)
  530.             elif source.type == "deb" and source.disabled == False:
  531.                 self.main_sources.append(source)
  532.                 comps.extend(source.comps)
  533.                 media.append(source.uri)
  534.             elif source.type == "deb" and source.disabled == True:
  535.                 self.disabled_sources.append(source)
  536.             elif source.type.endswith("-src") and source.disabled == False:
  537.                 self.source_code_sources.append(source)
  538.             elif source.type.endswith("-src") and source.disabled == True:
  539.                 self.disabled_sources.append(source)
  540.         if source.template in self.source_template.children:
  541.             #print "yeah! child found: %s" % source.template.name
  542.             if source.type == "deb":
  543.                 self.child_sources.append(source)
  544.             elif source.type == "deb-src":
  545.                 self.source_code_sources.append(source)
  546.     self.download_comps = set(comps)
  547.     self.cdrom_comps = set(cdrom_comps)
  548.     enabled_comps.extend(comps)
  549.     enabled_comps.extend(cdrom_comps)
  550.     self.enabled_comps = set(enabled_comps)
  551.     self.used_media = set(media)
  552.  
  553.     self.get_mirrors()
  554.   
  555.   def get_mirrors(self):
  556.     """
  557.     Provide a set of mirrors where you can get the distribution from
  558.     """
  559.     # the main server is stored in the template
  560.     self.main_server = self.source_template.base_uri
  561.  
  562.     # try to guess the nearest mirror from the locale
  563.     # FIXME: for debian we need something different
  564.     if self.id == "Ubuntu":
  565.         locale = os.getenv("LANG", default="en.UK")
  566.         a = locale.find("_")
  567.         z = locale.find(".")
  568.         if z == -1:
  569.             z = len(locale)
  570.         country_code = locale[a+1:z].lower()
  571.         self.nearest_server = "http://%s.archive.ubuntu.com/ubuntu/" % \
  572.                               country_code
  573.         if self.countries.has_key(country_code):
  574.             self.country = self.countries[country_code]
  575.         else:
  576.             self.country = None
  577.  
  578.     # other used servers
  579.     for medium in self.used_media:
  580.         if not medium.startswith("cdrom:"):
  581.             # seems to be a network source
  582.             self.used_servers.append(medium)
  583.  
  584.     if len(self.main_sources) == 0:
  585.         self.default_server = self.main_server
  586.     else:
  587.         self.default_server = self.main_sources[0].uri
  588.  
  589.   def add_source(self, sources_list, type=None, 
  590.                  uri=None, dist=None, comps=None, comment=""):
  591.     """
  592.     Add distribution specific sources
  593.     """
  594.     if uri == None:
  595.         # FIXME: Add support for the server selector
  596.         uri = self.default_server
  597.     if dist == None:
  598.         dist = self.codename
  599.     if comps == None:
  600.         comps = list(self.enabled_comps)
  601.     if type == None:
  602.         type = "deb"
  603.     if comment == "":
  604.         comment == "Added by software-properties"
  605.     new_source = sources_list.add(type, uri, dist, comps, comment)
  606.     # if source code is enabled add a deb-src line after the new
  607.     # source
  608.     if self.get_source_code == True and not type.endswith("-src"):
  609.         sources_list.add("%s-src" % type, uri, dist, comps, comment, 
  610.                          file=new_source.file,
  611.                          pos=sources_list.list.index(new_source)+1)
  612.  
  613.   def enable_component(self, sourceslist, comp):
  614.     """
  615.     Disable a component in all main, child and source code sources
  616.     (excluding cdrom based sources)
  617.  
  618.     sourceslist:  an aptsource.sources_list
  619.     comp:         the component that should be enabled
  620.     """
  621.     sources = []
  622.     sources.extend(self.main_sources)
  623.     sources.extend(self.child_sources)
  624.     sources.extend(self.source_code_sources)
  625.     # check if there is a main source at all
  626.     if len(self.main_sources) < 1:
  627.         # create a new main source
  628.         self.add_source(sourceslist, comps=["%s"%comp])
  629.     else:
  630.         # add the comp to all main, child and source code sources
  631.         for source in sources:
  632.             if comp not in source.comps:
  633.                 source.comps.append(comp)
  634.     if self.get_source_code == True:
  635.         for source in self.source_code_sources:
  636.             if comp not in source.comps: source.comps.append(comp)
  637.  
  638.   def disable_component(self, sourceslist, comp):
  639.     """
  640.     Disable a component in all main, child and source code sources
  641.     (excluding cdrom based sources)
  642.     """
  643.     sources = []
  644.     sources.extend(self.main_sources)
  645.     sources.extend(self.child_sources)
  646.     sources.extend(self.source_code_sources)
  647.     if comp in self.cdrom_comps:
  648.         sources = []
  649.         sources.extend(self.main_sources)
  650.  
  651.     for source in sources:
  652.         if comp in source.comps: 
  653.             source.comps.remove(comp)
  654.             if len(source.comps) < 1: 
  655.                sourceslist.remove(source)
  656.  
  657.  
  658. # some simple tests
  659. if __name__ == "__main__":
  660.   apt_pkg.InitConfig()
  661.   sources = SourcesList()
  662.  
  663.   for entry in sources:
  664.     print entry.str()
  665.     #print entry.uri
  666.  
  667.   mirror = is_mirror("http://archive.ubuntu.com/ubuntu/",
  668.                      "http://de.archive.ubuntu.com/ubuntu/")
  669.   print "is_mirror(): %s" % mirror
  670.   
  671.   print is_mirror("http://archive.ubuntu.com/ubuntu",
  672.                   "http://de.archive.ubuntu.com/ubuntu/")
  673.