pykickstart/version.py

   1 #
   2 # Chris Lumens <clumens@redhat.com>
   3 #
   4 # Copyright 2006, 2007, 2008 Red Hat, Inc.
   5 #
   6 # This copyrighted material is made available to anyone wishing to use, modify,
   7 # copy, or redistribute it subject to the terms and conditions of the GNU
   8 # General Public License v.2.  This program is distributed in the hope that it
   9 # will be useful, but WITHOUT ANY WARRANTY expressed or implied, including the
  10 # implied warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  11 # See the GNU General Public License for more details.
  12 #
  13 # You should have received a copy of the GNU General Public License along with
  14 # this program; if not, write to the Free Software Foundation, Inc., 51
  15 # Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.  Any Red Hat
  16 # trademarks that are incorporated in the source code or documentation are not
  17 # subject to the GNU General Public License and may only be used or replicated
  18 # with the express permission of Red Hat, Inc.
  19 #
  20 """
  21 Methods for working with kickstart versions.
  22
  23 This module defines several symbolic constants that specify kickstart syntax
  24 versions.  Each version corresponds roughly to one release of Red Hat Linux,
  25 Red Hat Enterprise Linux, or Fedora Core as these are where most syntax
  26 changes take place.
  27
  28 This module also exports several functions:
  29
  30     makeVersion - Given a version number, return an instance of the
  31                   matching handler class.
  32
  33     returnClassForVersion - Given a version number, return the matching
  34                             handler class.  This does not return an
  35                             instance of that class, however.
  36
  37     stringToVersion - Convert a string representation of a version number
  38                       into the symbolic constant.
  39
  40     versionToString - Perform the reverse mapping.
  41
  42     versionFromFile - Read a kickstart file and determine the version of
  43                       syntax it uses.  This requires the kickstart file to
  44                       have a version= comment in it.
  45 """
  46 import imputil, re, sys
  47 from urlgrabber import urlopen
  48
  49 import gettext
  50 _ = lambda x: gettext.ldgettext("pykickstart", x)
  51
  52 from pykickstart.errors import KickstartVersionError
  53
  54 # Symbolic names for internal version numbers.
  55 RHEL3 = 900
  56 FC3 = 1000
  57 RHEL4 = 1100
  58 FC4 = 2000
  59 FC5 = 3000
  60 FC6 = 4000
  61 RHEL5 = 4100
  62 F7  = 5000
  63 F8 = 6000
  64 F9 = 7000
  65 F10 = 8000
  66 F11 = 9000
  67
  68 # This always points at the latest version and is the default.
  69 DEVEL = F11
  70
  71 """A one-to-one mapping from string representations to version numbers."""
  72 versionMap = {
  73         "DEVEL": DEVEL,
  74         "FC3": FC3, "FC4": FC4, "FC5": FC5, "FC6": FC6, "F7": F7, "F8": F8,
  75         "F9": F9, "F10": F10, "F11": F11,
  76         "RHEL3": RHEL3, "RHEL4": RHEL4, "RHEL5": RHEL5
  77 }
  78
  79 def stringToVersion(s):
  80     """Convert string into one of the provided version constants.  Raises
  81        KickstartVersionError if string does not match anything.
  82     """
  83     # First try these short forms.
  84     try:
  85         return versionMap[s.upper()]
  86     except KeyError:
  87         pass
  88
  89     # Now try the Fedora versions.
  90     m = re.match("^fedora.* (\d+)$", s, re.I)
  91
  92     if m and m.group(1):
  93         if versionMap.has_key("FC" + m.group(1)):
  94             return versionMap["FC" + m.group(1)]
  95         elif versionMap.has_key("F" + m.group(1)):
  96             return versionMap["F" + m.group(1)]
  97         else:
  98             raise KickstartVersionError(_("Unsupported version specified: %s") % s)
  99
 100     # Now try the RHEL versions.
 101     m = re.match("^red hat enterprise linux.* (\d+)([\.\d]*)$", s, re.I)
 102
 103     if m and m.group(1):
 104         if versionMap.has_key("RHEL" + m.group(1)):
 105             return versionMap["RHEL" + m.group(1)]
 106         else:
 107             raise KickstartVersionError(_("Unsupported version specified: %s") % s)
 108
 109     # If nothing else worked, we're out of options.
 110     raise KickstartVersionError(_("Unsupported version specified: %s") % s)
 111
 112 def versionToString(version, skipDevel=False):
 113     """Convert version into a string representation of the version number.
 114        This is the reverse operation of stringToVersion.  Raises
 115        KickstartVersionError if version does not match anything.
 116     """
 117     for (key, val) in versionMap.iteritems():
 118         if version == DEVEL and key == "DEVEL" and skipDevel:
 119             continue
 120
 121         if val == version:
 122             return key
 123
 124     raise KickstartVersionError(_("Unsupported version specified: %s") % version)
 125
 126 def versionFromFile(f):
 127     """Given a file or URL, look for a line starting with #version= and
 128        return the version number.  If no version is found, return DEVEL.
 129     """
 130     v = DEVEL
 131
 132     fh = urlopen(f)
 133
 134     while True:
 135         try:
 136             l = fh.readline()
 137         except StopIteration:
 138             break
 139
 140         # At the end of the file?
 141         if l == "":
 142             break
 143
 144         if l.isspace() or l.strip() == "":
 145             continue
 146
 147         if l[:9] == "#version=":
 148             v = stringToVersion(l[9:].rstrip())
 149             break
 150
 151     fh.close()
 152     return v
 153
 154 def returnClassForVersion(version=DEVEL):
 155     """Return the class of the syntax handler for version.  version can be
 156        either a string or the matching constant.  Raises KickstartValueError
 157        if version does not match anything.
 158     """
 159     try:
 160         version = int(version)
 161         module = "%s" % versionToString(version, skipDevel=True)
 162     except ValueError:
 163         module = "%s" % version
 164         version = stringToVersion(version)
 165
 166     module = module.lower()
 167
 168     try:
 169         import pykickstart.handlers
 170         sys.path.extend(pykickstart.handlers.__path__)
 171         found = imputil.imp.find_module(module)
 172         loaded = imputil.imp.load_module(module, found[0], found[1], found[2])
 173
 174         for (k, v) in loaded.__dict__.iteritems():
 175             if k.lower().endswith("%shandler" % module):
 176                 return v
 177     except:
 178         raise KickstartVersionError(_("Unsupported version specified: %s") % version)
 179
 180 def makeVersion(version=DEVEL):
 181     """Return a new instance of the syntax handler for version.  version can be
 182        either a string or the matching constant.  This function is useful for
 183        standalone programs which just need to handle a specific version of
 184        kickstart syntax (as provided by a command line argument, for example)
 185        and need to instantiate the correct object.
 186     """
 187     cl = returnClassForVersion(version)
 188     return cl()