Move generic kickstart file processing code into its own package and make

sure to include it properly.  Also fixed a variety of typos related to LVM
and RAID on kickstart.

6 files changed, 43 insertions, 1086 deletions

diff --git a/ChangeLog b/ChangeLog
index b6d55e2a8..f59690b46 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,23 @@
+2005-10-05  Chris Lumens  <clumens@redhat.com>
+
+	* anaconda.spec:  Bump version.
+
+2005-10-05  Chris Lumens  <clumens@redhat.com>
+
+	* anaconda:  Reference pykickstart package.
+	* kickstart.py:  Likewise.  Fixed up LVM and RAID partitioning typos.
+	* kickstartData.py, kickstartParser.py:  Removed.
+	* iw/network_gui.py (NetworkWindow.getNext):  Remove kickstart import.
+	
+	* anaconda.spec:  Pull in pykickstart package.
+	* scripts/upd-instroot:  Likewise.  Pull in firstboot_module_window
+	from the right place.
+
+	* constants.py:  Pull in kickstart constants.
+
+	* gui.py (InstallControlWindow.releaseNotesButtonClicked):  Display
+	release notes instead of raising an exception.
+
 2005-10-04  Chris Lumens  <clumens@redhat.com>
 
 	* kickstart.py:  Switch to using new ksdata objects instead of lists
diff --git a/anaconda b/anaconda
index a75e1c17c..7cc136b76 100755
--- a/anaconda
+++ b/anaconda
@@ -642,8 +642,8 @@ else:
 if ksfile is not None:
     from kickstart import pullRemainingKickstartConfig, KickstartError
     from kickstart import VNCHandlers
-    from kickstartData import KickstartData
-    from kickstartParser import KickstartParser
+    from pykickstart.data import KickstartData
+    from pykickstart.parser import KickstartParser
 
     try:
         rc = pullRemainingKickstartConfig(ksfile)
@@ -660,8 +660,8 @@ if ksfile is not None:
     # line options for password, connect host and port override values in
     # kickstart file
     ksdata = KickstartData()
-    parser = KickstartParser(ksdata, VNCHandlers(ksdata))
-    parser.readKickstart(ksfile)
+    ksparser = KickstartParser(ksdata, VNCHandlers(ksdata))
+    ksparser.readKickstart(ksfile)
 
     ksusevnc = ksdata.vnc["enabled"]
 
diff --git a/constants.py b/constants.py
index dd5898fb6..d4c1f4673 100644
--- a/constants.py
+++ b/constants.py
@@ -44,11 +44,6 @@ REQUEST_PROTECTED = 8
 REQUEST_VG = 16 # volume group
 REQUEST_LV = 32 # logical volume
 
-# when clearing partitions, what do we clear
-CLEARPART_TYPE_LINUX = 1
-CLEARPART_TYPE_ALL   = 2
-CLEARPART_TYPE_NONE  = 3
-
 # XXX this is made up and used by the size spinner; should just be set with
 # a callback
 MAX_PART_SIZE = 1024*1024*1024
@@ -58,10 +53,8 @@ CHECK_DEPS = 0
 IGNORE_DEPS = 1
 RESOLVE_DEPS = 2
 
-# firstboot settings
-FIRSTBOOT_DEFAULT = 0
-FIRSTBOOT_SKIP = 1
-FIRSTBOOT_RECONFIG = 2
+# pull in kickstart constants as well
+from pykickstart.constants import *
 
 # common string needs to be easy to change
 import product
diff --git a/kickstart.py b/kickstart.py
index d768c7e79..52c0ad02d 100644
--- a/kickstart.py
+++ b/kickstart.py
@@ -26,8 +26,8 @@ import string
 import partRequests
 import urlgrabber.grabber as grabber
 import lvm
-from kickstartParser import *
-from kickstartData import KickstartData
+from pykickstart.parser import *
+from pykickstart.data import *
 
 import logging
 log = logging.getLogger("anaconda")
@@ -192,14 +192,14 @@ class AnacondaKSHandlers(KickstartHandlers):
 
         if lvd.mountpoint == "swap":
             filesystem = fileSystemTypeGet("swap")
-            lvd.mountpoint = None
+            lvd.mountpoint = ""
 
             if lvd.recommended == True:
                 (lvd.size, lvd.maxSizeMB) = iutil.swapSuggestion()
                 lvd.grow = True
         else:
             if lvd.fstype != "":
-                fiesystem = fileSystemTypeGet(lvd.fstype)
+                filesystem = fileSystemTypeGet(lvd.fstype)
             else:
                 filesystem = fileSystemTypeGetDefault()
 
@@ -207,15 +207,16 @@ class AnacondaKSHandlers(KickstartHandlers):
 	if lvd.mountpoint != "" and lvd.mountpoint[0] != '/':
 	    raise KickstartValueError, "The mount point \"%s\" is not valid." % (lvd.mountpoint,)
 
-        if lvd.size == 0 and lvd.percent == 0 and lvd.preexist == False:
-            raise KickstartValueError, "Size required for logical volume %s" % lvd.name
+        if lvd.percent == 0:
+            if lvd.size == 0 and lvd.preexist == False:
+                raise KickstartValueError, "Size required for logical volume %s" % lvd.name
         elif lvd.percent <= 0 or lvd.percent > 100:
             raise KickstartValueError, "Percentage must be between 0 and 100 for logical volume %s" % lvd.name
 
         vgid = self.ksVGMapping[lvd.vgname]
 	for areq in id.partitions.autoPartitionRequests:
 	    if areq.type == REQUEST_LV:
-		if areq.volumeGroup == vgid and areq.logicalVolumeName == lvd.nam:
+		if areq.volumeGroup == vgid and areq.logicalVolumeName == lvd.name:
 		    raise KickstartValueError, "Logical volume name %s already used in volume group %s" % (lvd.name, lvd.vgname)
 
         if not self.ksVGMapping.has_key(lvd.vgname):
@@ -342,7 +343,7 @@ class AnacondaKSHandlers(KickstartHandlers):
 
         request = partRequests.PartitionSpec(filesystem,
                                              mountpoint = pd.mountpoint,
-                                             format = 1,
+                                             format = pd.format,
                                              fslabel = pd.label,
                                              bytesPerInode = pd.bytesPerInode)
         
@@ -360,8 +361,6 @@ class AnacondaKSHandlers(KickstartHandlers):
             request.drive = [ pd.disk ]
         if pd.primOnly == True:
             request.primary = pd.primOnly
-        if pd.format == True:
-            request.format = pd.format
         if uniqueID:
             request.uniqueID = uniqueID
         if pd.onPart != "":
@@ -385,6 +384,8 @@ class AnacondaKSHandlers(KickstartHandlers):
         KickstartHandlers.doRaid(self, args)
         rd = self.ksdata.raidList[-1]
 
+	uniqueID = None
+
         if rd.mountpoint == "swap":
             filesystem = fileSystemTypeGet('swap')
             rd.mountpoint = None
@@ -401,7 +402,7 @@ class AnacondaKSHandlers(KickstartHandlers):
             rd.mountpoint = ""
         else:
             if rd.fstype != "":
-                filesystem = fileSystemTypeGet(fstype)
+                filesystem = fileSystemTypeGet(rd.fstype)
             else:
                 filesystem = fileSystemTypeGetDefault()
 
@@ -435,7 +436,7 @@ class AnacondaKSHandlers(KickstartHandlers):
                                                raidminor = rd.device,
                                                preexist = rd.preexist)
 
-        if uniqueID:
+        if uniqueID is not None:
             request.uniqueID = uniqueID
         if rd.preexist == True and rd.device != "":
             request.device = "md%s" % rd.device
@@ -678,10 +679,10 @@ class Kickstart(BaseInstallClass):
 
         # parse the %pre
         self.ksdata = KickstartData()
-        parser = KickstartPreParser(self.ksdata, None)
+        self.ksparser = KickstartPreParser(self.ksdata, None)
 
         try:
-            parser.readKickstart(self.file)
+            self.ksparser.readKickstart(self.file)
         except KickstartError, e:
            if intf:
                intf.kickstartErrorWindow(e.__str__())
@@ -695,10 +696,10 @@ class Kickstart(BaseInstallClass):
         # now read the kickstart file for real
         self.ksdata = KickstartData()
         self.handlers = AnacondaKSHandlers(self.ksdata)
-        parser = AnacondaKSParser(self.ksdata, self.handlers, self.id)
+        self.ksparser = AnacondaKSParser(self.ksdata, self.handlers, self.id)
 
         try:
-            parser.readKickstart(self.file)
+            self.ksparser.readKickstart(self.file)
         except KickstartError, e:
             if intf:
                 intf.kickstartErrorWindow(e.__str__())
diff --git a/kickstartData.py b/kickstartData.py
deleted file mode 100644
index c030dfdbe..000000000
--- a/kickstartData.py
+++ /dev/null
@@ -1,155 +0,0 @@
-#
-# kickstartParser.py:  Unified kickstart file parser for anaconda and
-# s-c-kickstart, among others.
-#
-# Chris Lumens <clumens@redhat.com>
-#
-# Copyright 2005 Red Hat, Inc.
-#
-# This software may be freely redistributed under the terms of the GNU
-# general public license.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-#
-from constants import *
-
-DISPLAY_MODE_CMDLINE = 0
-DISPLAY_MODE_GRAPHICAL = 1
-DISPLAY_MODE_TEXT = 2
-
-KS_MISSING_PROMPT = 0
-KS_MISSING_IGNORE = 1
-
-class KickstartData:
-    def __init__(self):
-        # Set by command handlers.
-        self.authconfig = ""
-        self.autopart = False
-        self.autostep = {"autoscreenshot": False}
-        self.bootloader = {"appendLine": "", "driveorder": [],
-                           "forceLBA": False, "location": "mbr", "md5pass": "",
-                           "password": "", "upgrade": False}
-        self.clearpart = {"drives": [], "initAll": False,
-                          "type": CLEARPART_TYPE_NONE}
-        self.device = ""
-        self.deviceprobe = ""
-        self.displayMode = DISPLAY_MODE_GRAPHICAL
-        self.driverdisk = ""
-        self.firewall = {"enabled": True, "ports": [], "trusts": []}
-        self.firstboot = FIRSTBOOT_SKIP
-        self.ignoredisk = []
-        self.interactive = False
-        self.keyboard = ""
-        self.lang = ""
-        self.mediacheck = False
-        self.method = {"method": ""}
-        self.monitor = {"hsync": "", "monitor": "", "vsync": ""}
-        self.network = []
-        self.platform = ""
-        self.reboot = True
-        self.rootpw = {"isCrypted": False, "password": ""}
-        self.selinux = 2
-        self.skipx = False
-        self.timezone = {"isUtc": False, "timezone": ""}
-        self.upgrade = False
-        self.vnc = {"enabled": False, "password": "", "host": "", "port": ""}
-        self.xconfig = {"driver": "", "defaultdesktop": "", "depth": 0,
-                        "hsync": "", "monitor": "", "probe": True,
-                        "resolution": "", "startX": False,
-                        "videoRam": "", "vsync": ""}
-        self.zerombr = False
-        self.zfcp = {"devnum": "", "fcplun": "", "scsiid": "", "scsilun": "",
-                     "wwpn": ""}
-
-        self.lvList = []
-        self.partitions = []
-        self.raidList = []
-        self.vgList = []
-
-        # Set by %package header.
-        self.excludeDocs = False
-        self.addBase = True
-        self.handleMissing = KS_MISSING_PROMPT
-
-        # Set by sections.
-        self.groupList = []
-        self.packageList = []
-        self.excludedList = []
-        self.preScripts = []
-        self.postScripts = []
-        self.tracebackScripts = []
-
-class KickstartLogVolData:
-    def __init__(self):
-        self.bytesPerInode = 0
-        self.fsopts = ""
-        self.fstype = ""
-        self.grow = False
-        self.maxSizeMB = 0
-        self.name = ""
-        self.format = True
-        self.percent = 0
-        self.recommended = False
-        self.size = 0
-        self.preexist = False
-        self.vgname = ""
-        self.mountpoint = ""
-
-class KickstartNetworkData:
-    def __init__(self):
-        self.bootProto = "dhcp"
-        self.dhcpclass = ""
-        self.device = ""
-        self.essid = ""
-        self.ethtool = ""
-        self.gateway = ""
-        self.hostname = ""
-        self.ip = ""
-        self.nameserver = ""
-        self.netmask = ""
-        self.nodns = False
-        self.notksdevice = False
-        self.onboot = True
-        self.wepkey = ""
-
-class KickstartPartData:
-    def __init__ (self):
-        self.active = False
-        self.primOnly = False
-        self.bytesPerInode = 0
-        self.end = 0
-        self.fsopts = ""
-        self.fstype = ""
-        self.grow = False
-        self.label = ""
-        self.maxSizeMB = 0
-        self.format = True
-        self.onbiosdisk = ""
-        self.disk = ""
-        self.onPart = ""
-        self.recommended = False
-        self.size = 0
-        self.start = 0
-        self.mountpoint = ""
-
-class KickstartRaidData:
-    def __init__ (self):
-        self.device = ""
-        self.fsopts = ""
-        self.fstype = ""
-        self.level = ""
-        self.format = True
-        self.spares = 0
-        self.preexist = False
-        self.mountpoint = ""
-        self.members = ""
-
-class KickstartVolGroupData:
-    def __init__(self):
-        self.format = True
-        self.pesize = 32768
-        self.preexist = False
-        self.vgname = ""
-        self.physvols = ""
diff --git a/kickstartParser.py b/kickstartParser.py
deleted file mode 100644
index 0bdcf0778..000000000
--- a/kickstartParser.py
+++ /dev/null
@@ -1,902 +0,0 @@
-#
-# kickstartParser.py:  Unified kickstart file parser for anaconda and
-# s-c-kickstart.
-#
-# Chris Lumens <clumens@redhat.com>
-#
-# Copyright 2005 Red Hat, Inc.
-#
-# This software may be freely redistributed under the terms of the GNU
-# general public license.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-#
-
-import shlex
-import sys
-import string
-from optparse import OptionParser, Option
-from rhpl.translate import _, N_
-from kickstartData import *
-from constants import *
-
-STATE_END = 0
-STATE_COMMANDS = 1
-STATE_PACKAGES = 2
-STATE_SCRIPT_HDR = 3
-STATE_PRE = 4
-STATE_POST = 5
-STATE_TRACEBACK = 6
-
-class KickstartError(Exception):
-    def __init__(self, val = ""):
-        self.value = val
-
-    def __str__ (self):
-        return self.value
-
-class KickstartParseError(KickstartError):
-    def __init__(self, line = ""):
-        self.value = N_("There was a problem reading the following line "
-                        "from the kickstart file.  This could be due to "
-                        "an error on the line or using a keyword that no "
-                        "longer exists.\n\n%s") % line
-
-    def __str__(self):
-        return self.value
-
-class KickstartValueError(KickstartError):
-    def __init__(self, val = ""):
-        self.value = val
-
-    def __str__ (self):
-        return self.value
-
-# Specialized OptionParser, mainly to handle the MappableOption and to turn
-# off help.
-class KSOptionParser(OptionParser):
-    def exit(self, status=0, msg=None):
-        pass
-
-    def error(self, msg):
-        raise KickstartParseError, msg
-
-    def keys(self):
-        retval = []
-
-        for opt in self.option_list:
-            if opt not in retval:
-                retval.append(opt.dest)
-
-        return retval
-
-    def _init_parsing_state (self):
-        OptionParser._init_parsing_state(self)
-        self.option_seen = {}
-
-    def check_values (self, values, args):
-        for option in self.option_list:
-            if (isinstance(option, Option) and option.required and
-                not self.option_seen.has_key(option)):
-                raise KickstartError, "Option %s is required" % option
-
-        return (values, args)
-
-    def __init__(self, map={}):
-        self.map = map
-        OptionParser.__init__(self, option_class=MappableOption,
-                              add_help_option=False)
-
-# Creates a new Option type that supports a "required" option attribute.  Any
-# option with this attribute must be supplied or an exception is thrown.
-class RequiredOption (Option):
-    ATTRS = Option.ATTRS + ['required']
-
-    def _check_required (self):
-        if self.required and not self.takes_value():
-            raise OptionError(
-                "required flag set for option that doesn't take a value",
-                 self)
-
-    # Make sure _check_required() is called from the constructor!
-    CHECK_METHODS = Option.CHECK_METHODS + [_check_required]
-
-    def process (self, opt, value, values, parser):
-        Option.process(self, opt, value, values, parser)
-        parser.option_seen[self] = 1
-
-# Additional OptionParser actions.  "map" allows you to define a opt -> val
-# mapping such that dest gets val when opt is seen.  "map_extend" allows you
-# to define an opt -> [val1, ... valn] mapping such that dest gets a list of
-# vals build up when opt is seen.
-class MappableOption(RequiredOption):
-    ACTIONS = Option.ACTIONS + ("map", "map_extend",)
-    STORE_ACTIONS = Option.STORE_ACTIONS + ("map", "map_extend",)
-
-    def take_action(self, action, dest, opt, value, values, parser):
-        if action == "map":
-            values.ensure_value(dest, parser.map[opt.lstrip('-')])
-        elif action == "map_extend":
-            values.ensure_value(dest, []).extend(parser.map[opt.lstrip('-')])
-        else:
-            RequiredOption.take_action(self, action, dest, opt, value, values, parser)
-
-# You may make a subclass of Script if you need additional script handling
-# besides just a data representation.  For instance, anaconda may subclass
-# this to add a run method.
-class Script:
-    def __repr__(self):
-        str = ("(s: '%s' i: %s c: %d)") %  \
-              (self.script, self.interp, self.inChroot)
-        return string.replace(str, "\n", "|")
-
-    def __init__(self, script, interp = "/bin/sh", inChroot = False,
-                 logfile = None, errorOnFail = False):
-        self.script = string.join(script, "")
-        self.interp = interp
-        self.inChroot = inChroot
-        self.logfile = logfile
-        self.errorOnFail = errorOnFail
-
-    # Produce a string representation of the script suitable for writing
-    # to a kickstart file.  Add this to the end of the %whatever header.
-    def write(self):
-        str = ""
-        if self.interp != "/bin/sh":
-            str = str + " --interp %s" % self.interp
-        if not self.inChroot:
-            str = str + " --nochroot"
-        if self.logfile != None:
-            str = str + " --logfile %s" % self.logfile
-        if self.errorOnFail:
-            str = str + " --erroronfail"
-        
-        str = str + "\n%s" % self.script
-        return str
-
-# You may make a subclass of KickstartHandlers if you need to do something
-# besides just build up the data store.  If you need to do additional processing
-# just make a subclass, define handlers for each command in your subclass, and
-# make sure to call the same handler in the super class before whatever you
-# want to do.  Also if you need to make a new parser that only takes action
-# for a subset of commands, make a subclass and define all the handlers to
-# None except the ones you care about.
-class KickstartHandlers:
-    def __init__ (self, ksdata):
-        self.ksdata = ksdata
-
-        self.handlers = { "auth"    : self.doAuthconfig,
-                     "authconfig"   : self.doAuthconfig,
-                     "autopart"     : self.doAutoPart,
-                     "autostep"     : self.doAutoStep,
-                     "bootloader"   : self.doBootloader,
-                     "cdrom"        : self.doMethod,
-                     "clearpart"    : self.doClearPart,
-                     "cmdline"      : self.doDisplayMode,
-                     "device"       : self.doDevice,
-                     "deviceprobe"  : self.doDeviceProbe,
-                     "driverdisk"   : self.doDriverDisk,
-                     "firewall"     : self.doFirewall,
-                     "firstboot"    : self.doFirstboot,
-                     "graphical"    : self.doDisplayMode,
-                     "halt"         : self.doReboot,
-                     "harddrive"    : self.doMethod,
-                     "ignoredisk"   : self.doIgnoreDisk,
-                     # implied by lack of "upgrade" command
-                     "install"      : None,
-                     "interactive"  : self.doInteractive,
-                     "keyboard"     : self.doKeyboard,
-                     "lang"         : self.doLang,
-                     "langsupport"  : self.doLangSupport,
-                     "logvol"       : self.doLogicalVolume,
-                     "mediacheck"   : self.doMediaCheck,
-                     "monitor"      : self.doMonitor,
-                     "mouse"        : self.doMouse,
-                     "network"      : self.doNetwork,
-                     "nfs"          : self.doMethod,
-                     "part"         : self.doPartition,
-                     "partition"    : self.doPartition,
-                     "poweroff"     : self.doReboot,
-                     "raid"         : self.doRaid,
-                     "reboot"       : self.doReboot,
-                     "rootpw"       : self.doRootPw,
-                     "selinux"      : self.doSELinux,
-                     "shutdown"     : self.doReboot,
-                     "skipx"        : self.doSkipX,
-                     "text"         : self.doDisplayMode,
-                     "timezone"     : self.doTimezone,
-                     "url"          : self.doMethod,
-                     "upgrade"      : self.doUpgrade,
-                     "vnc"          : self.doVnc,
-                     "volgroup"     : self.doVolumeGroup,
-                     "xconfig"      : self.doXConfig,
-                     "zerombr"      : self.doZeroMbr,
-                     "zfcp"         : self.doZFCP,
-                   }
-
-    def resetHandlers (self):
-        for key in self.handlers.keys():
-            self.handlers[key] = None
-
-    def doAuthconfig(self, args):
-        self.ksdata.authconfig = string.join(args)
-
-    def doAutoPart(self, args):
-        self.ksdata.autopart = True
-
-    def doAutoStep(self, args):
-        op = KSOptionParser()
-        op.add_option("--autoscreenshot", dest="autoscreenshot",
-                      action="store_true", default=False)
-
-        (opts, extra) = op.parse_args(args=args)
-        self.ksdata.autostep["autoscreenshot"] = opts.autoscreenshot
-
-    def doBootloader(self, args):
-        def driveorder_cb (option, opt_str, value, parser):
-            for d in value.split(','):
-                parser.values.ensure_value(option.dest, []).append(d)
-            
-        op = KSOptionParser()
-        op.add_option("--append", dest="appendLine")
-        op.add_option("--location", dest="location", type="choice",
-                      default="mbr",
-                      choices=["mbr", "partition", "none", "boot"])
-        op.add_option("--lba32", dest="forceLBA", action="store_true",
-                      default=False)
-        op.add_option("--password", dest="password", default="")
-        op.add_option("--md5pass", dest="md5pass", default="")
-        op.add_option("--upgrade", dest="upgrade", action="store_true",
-                      default=False)
-        op.add_option("--driveorder", dest="driveorder", action="callback",
-                      callback=driveorder_cb, nargs=1, type="string")
-
-        (opts, extra) = op.parse_args(args=args)
-
-        for key in filter (lambda k: getattr(opts, k) != None, op.keys()):
-            self.ksdata.bootloader[key] = getattr(opts, key)
-
-    def doClearPart(self, args):
-        def drive_cb (option, opt_str, value, parser):
-            for d in value.split(','):
-                parser.values.ensure_value(option.dest, []).append(d)
-            
-        op = KSOptionParser()
-        op.add_option("--all", dest="type", action="store_const",
-                      const=CLEARPART_TYPE_ALL)
-        op.add_option("--drives", dest="drives", action="callback",
-                      callback=drive_cb, nargs=1, type="string")
-        op.add_option("--initlabel", dest="initAll", action="store_true",
-                      default=False)
-        op.add_option("--linux", dest="type", action="store_const",
-                      const=CLEARPART_TYPE_LINUX)
-        op.add_option("--none", dest="type", action="store_const",
-                      const=CLEARPART_TYPE_NONE)
-
-        (opts, extra) = op.parse_args(args=args)
-
-        for key in filter (lambda k: getattr(opts, k) != None, op.keys()):
-            self.ksdata.clearpart[key] = getattr(opts, key)
-
-    def doDevice(self, args):
-        self.ksdata.device = string.join(args)
-
-    def doDeviceProbe(self, args):
-        self.ksdata.deviceprobe = string.join(args)
-
-    def doDisplayMode(self, args):
-        if self.currentCmd == "cmdline":
-            self.ksdata.displayMode = DISPLAY_MODE_CMDLINE
-        elif self.currentCmd == "graphical":
-            self.ksdata.displayMode = DISPLAY_MODE_GRAPHICAL
-        elif self.currentCmd == "text":
-            self.ksdata.displayMode = DISPLAY_MODE_TEXT
-
-    def doDriverDisk(self, args):
-        self.ksdata.driverdisk = string.join(args)
-
-    def doFirewall(self, args):
-        def firewall_port_cb (option, opt_str, value, parser):
-            for p in value.split(","):
-                p = p.strip()
-                if p.find(":") == -1:
-                    p = "%s:tcp" % p
-                parser.values.ensure_value(option.dest, []).append(p)
-
-        op = KSOptionParser({"ssh":["22:tcp"], "telnet":["23:tcp"],
-                             "smtp":["25:tcp"], "http":["80:tcp", "443:tcp"],
-                             "ftp":["21:tcp"]})
-
-        op.add_option("--disable", "--disabled", dest="enabled",
-                      action="store_false")
-        op.add_option("--enable", "--enabled", dest="enabled",
-                      action="store_true", default=True)
-        op.add_option("--ftp", "--http", "--smtp", "--ssh", "--telnet",
-                      dest="ports", action="map_extend")
-        op.add_option("--port", dest="ports", action="callback",
-                      callback=firewall_port_cb, nargs=1, type="string")
-        op.add_option("--trust", dest="trusts", action="append")
-
-        (opts, extra) = op.parse_args(args=args)
-
-        for key in filter (lambda k: getattr(opts, k) != None, op.keys()):
-            self.ksdata.firewall[key] = getattr(opts, key)
-
-    def doFirstboot(self, args):
-        op = KSOptionParser()
-        op.add_option("--disable", "--disabled", dest="firstboot",
-                      action="store_const", const=FIRSTBOOT_SKIP)
-        op.add_option("--enable", "--enabled", dest="firstboot",
-                      action="store_const", const=FIRSTBOOT_DEFAULT)
-        op.add_option("--reconfig", dest="firstboot", action="store_const",
-                      const=FIRSTBOOT_RECONFIG)
-
-        (opts, extra) = op.parse_args(args=args)
-        self.ksdata.firstboot = opts.firstboot
-
-    def doIgnoreDisk(self, args):
-        def drive_cb (option, opt_str, value, parser):
-            for d in value.split(','):
-                parser.values.ensure_value(option.dest, []).append(d)
-            
-        op = KSOptionParser()
-        op.add_option("--drives", dest="drives", action=callback,
-                      callback=drive_cb, nargs=1, type="string")
-
-        (opts, extra) = op.parse_args(args=args)
-
-        self.ksdata.ignoredisk = opt.ignoredisk
-
-    def doInteractive(self, args):
-        self.ksdata.interactive = True
-
-    def doKeyboard(self, args):
-        self.ksdata.keyboard = args[0]
-
-    def doLang(self, args):
-        self.ksdata.lang = args[0]
-
-    def doLangSupport(self, args):
-        raise KickstartError, "The langsupport keyword has been removed.  Instead, please alter your kickstart file to include the support package groups for the languages you want instead of using langsupport.  For instance, include the french-support group instead of specifying 'langsupport fr'."
-
-    def doLogicalVolume(self, args):
-        def lv_cb (option, opt_str, value, parser):
-            parser.values.ensure_value(option.dest, False)
-            parser.values.ensure_value("preexist", True)
-
-        op = KSOptionParser()
-        op.add_option("--bytes-per-inode", dest="bytesPerInode", action="store",
-                      type="int", nargs=1)
-        op.add_option("--fsoptions", dest="fsopts")
-        op.add_option("--fstype", dest="fstype")
-        op.add_option("--grow", dest="grow", action="store_true",
-                      default=False)
-        op.add_option("--maxsize", dest="maxSizeMB", action="store", type="int",
-                      nargs=1)
-        op.add_option("--name", dest="name", required=1)
-        op.add_option("--noformat", action="callback", callback=lv_cb,
-                      dest="format", default=True, nargs=0)
-        op.add_option("--percent", dest="percent", action="store", type="int",
-                      nargs=1)
-        op.add_option("--recommended", dest="recommended", action="store_true",
-                      default=False)
-        op.add_option("--size", dest="size", action="store", type="int",
-                      nargs=1)
-        op.add_option("--useexisting", dest="preexist", action="store_true",
-                      default=False)
-        op.add_option("--vgname", dest="vgname", required=1)
-
-        (opts, extra) = op.parse_args(args=args)
-
-        if len(extra) == 0:
-            raise KickstartValueError, "Mount point required on line:\n\nlogvol %s" % string.join (args)
-
-        lvd = KickstartLogVolData()
-        for key in filter (lambda k: getattr(opts, k) != None, op.keys()):
-            setattr(lvd, key, getattr(opts, key))
-
-        lvd.mountpoint = extra[0]
-        self.ksdata.lvList.append(lvd)
-
-    def doMediaCheck(self, args):
-        self.ksdata.mediacheck = True
-
-    def doMethod(self, args):
-        op = KSOptionParser()
-
-        self.ksdata.method["method"] = self.currentCmd
-
-        if self.currentCmd == "cdrom":
-            pass
-        elif self.currentCmd == "harddrive":
-            op.add_option("--partition", dest="partition", required=1)
-            op.add_option("--dir", dest="dir", required=1)
-
-            (opts, extra) = op.parse_args(args=args)
-            self.ksdata.method["partition"] = opts.partition
-            self.ksdata.method["dir"] = opts.dir
-        elif self.currentCmd == "nfs":
-            op.add_option("--server", dest="server", required=1)
-            op.add_option("--dir", dest="dir", required=1)
-
-            (opts, extra) = op.parse_args(args=args)
-            self.ksdata.method["server"] = opts.server
-            self.ksdata.method["dir"] = opts.dir
-        elif self.currentCmd == "url":
-            op.add_option("--url", dest="url", required=1)
-
-            (opts, extra) = op.parse_args(args=args)
-            self.ksdata.method["url"] = opts.url
-
-    def doMonitor(self, args):
-        op = KSOptionParser()
-        op.add_option("--hsync", dest="hsync")
-        op.add_option("--monitor", dest="monitor")
-        op.add_option("--vsync", dest="vsync")
-
-        (opts, extra) = op.parse_args(args=args)
-
-        if extra:
-            raise KickstartValueError, "Unexpected arguments to monitor: %s" % string.join(args)
-
-        for key in filter (lambda k: getattr(opts, k) != None, op.keys()):
-            self.ksdata.monitor[key] = getattr(opts, key)
-
-    def doMouse(self, args):
-        raise KickstartError, "The mouse keyword has not been functional for several releases and has now been removed.  Please modify your kickstart file by removing this keyword."
-
-    def doNetwork(self, args):
-        def onboot_cb (option, opt_str, value, parser):
-            if value == "no":
-                parser.values.ensure_value(option.dest, False)
-            else:
-                parser.values.ensure_value(option.dest, True)
-
-        op = KSOptionParser()
-        op.add_option("--bootproto", dest="bootProto", default="dhcp")
-        op.add_option("--class", dest="dhcpclass")
-        op.add_option("--device", dest="device")
-        op.add_option("--essid", dest="essid")
-        op.add_option("--ethtool", dest="ethtool")
-        op.add_option("--gateway", dest="gateway")
-        op.add_option("--hostname", dest="hostname")
-        op.add_option("--ip", dest="ip")
-        op.add_option("--nameserver", dest="nameserver")
-        op.add_option("--netmask", dest="netmask")
-        op.add_option("--nodns", dest="nodns", action="store_true",
-                      default=False)
-        op.add_option("--notksdevice", dest="notksdevice", action="store_true",
-                      default=False)
-        op.add_option("--onboot", dest="onboot", action="callback",
-                      callback=onboot_cb, nargs=1, type="string")
-        op.add_option("--wepkey", dest="wepkey")
-
-        (opts, extra) = op.parse_args(args=args)
-
-        nd = KickstartNetworkData()
-        for key in filter (lambda k: getattr(opts, k) != None, op.keys()):
-            setattr(nd, key, getattr(opts, key))
-
-        self.ksdata.network.append(nd)
-
-    def doPartition(self, args):
-        def part_cb (option, opt_str, value, parser):
-            if value.startswith("/dev/"):
-                parser.values.ensure_value(option.dest, value[5:])
-            else:
-                parser.values.ensure_value(option.dest, value)
-
-        op = KSOptionParser()
-        op.add_option("--active", dest="active", action="store_true",
-                      default=False)
-        op.add_option("--asprimary", dest="primOnly", action="store_true",
-                      default=False)
-        op.add_option("--bytes-per-inode", dest="bytesPerInode", action="store",
-                      type="int", nargs=1)
-        op.add_option("--end", dest="end", action="store", type="int",
-                      nargs=1)
-        op.add_option("--fsoptions", dest="fsopts")
-        op.add_option("--fstype", "--type", dest="fstype")
-        op.add_option("--grow", dest="grow", action="store_true", default=False)
-        op.add_option("--label", dest="label")
-        op.add_option("--maxsize", dest="maxSizeMB", action="store", type="int",
-                      nargs=1)
-        op.add_option("--noformat", dest="format", action="store_false",
-                      default=True)
-        op.add_option("--onbiosdisk", dest="onbiosdisk")
-        op.add_option("--ondisk", "--ondrive", dest="disk")
-        op.add_option("--onpart", "--usepart", dest="onPart", action="callback",
-                      callback=part_cb, nargs=1, type="string")
-        op.add_option("--recommended", dest="recommended", action="store_true",
-                      default=False)
-        op.add_option("--size", dest="size", action="store", type="int",
-                      nargs=1)
-        op.add_option("--start", dest="start", action="store", type="int",
-                      nargs=1)
-
-        (opts, extra) = op.parse_args(args=args)
-
-        if len(extra) != 1:
-            raise KickstartValueError, "Mount point required on line:\n\npartition %s" % string.join (args)
-
-        pd = KickstartPartData()
-        for key in filter (lambda k: getattr(opts, k) != None, op.keys()):
-            setattr(pd, key, getattr(opts, key))
-
-        pd.mountpoint = extra[0]
-        self.ksdata.partitions.append(pd)
-
-    def doReboot(self, args):
-        self.ksdata.reboot = True
-
-    def doRaid(self, args):
-        def raid_cb (option, opt_str, value, parser):
-            parser.values.ensure_value(option.dest, False)
-            parser.values.ensure_value("preexist", True)
-
-        def device_cb (option, opt_str, value, parser):
-            if value[0:2] == "md":
-                parser.values.ensure_value(option.dest, value[2:])
-            else:
-                parser.values.ensure_value(option.dest, value)
-
-        def level_cb (option, opt_str, value, parser):
-            if value == "RAID0" or value == "0":
-                parser.values.ensure_value(option.dest, "RAID0")
-            elif value == "RAID1" or value == "1":
-                parser.values.ensure_value(option.dest, "RAID1")
-            elif value == "RAID5" or value == "5":
-                parser.values.ensure_value(option.dest, "RAID5")
-            elif value == "RAID6" or value == "6":
-                parser.values.ensure_value(option.dest, "RAID6")
-
-        op = KSOptionParser()
-        op.add_option("--device", action="callback", callback=device_cb,
-                      dest="device", type="string", nargs=1, required=1)
-        op.add_option("--fsoptions", dest="fsopts")
-        op.add_option("--fstype", dest="fstype")
-        op.add_option("--level", dest="level", action="callback",
-                      callback=level_cb, type="string", nargs=1, required=1)
-        op.add_option("--noformat", action="callback", callback=raid_cb,
-                      dest="format", default=True, nargs=0)
-        op.add_option("--spares", dest="spares", action="store", type="int",
-                      nargs=1, default=0)
-        op.add_option("--useexisting", dest="preexist", action="store_true",
-                      default=False)
-
-        (opts, extra) = op.parse_args(args=args)
-
-        if len(extra) == 0:
-            raise KickstartValueError, "Mount point required on line:\n\nraid %s" % string.join (args)
-
-        rd = KickstartRaidData()
-        for key in filter (lambda k: getattr(opts, k) != None, op.keys()):
-            setattr(rd, key, getattr(opts, key))
-
-        rd.mountpoint = extra[0]
-        rd.members = extra[1:]
-        self.ksdata.raidList.append(rd)
-
-    def doRootPw(self, args):
-        op = KSOptionParser()
-        op.add_option("--iscrypted", dest="isCrypted", action="store_true",
-                      default=False)
-
-        (opts, extra) = op.parse_args(args=args)
-        self.ksdata.rootpw["isCrypted"] = opts.isCrypted
-
-        if len(extra) != 1:
-            raise KickstartValueError, "A single argument is expected for rootpw"
-
-        self.ksdata.rootpw["password"] = extra[0]
-
-    def doSELinux(self, args):
-        op = KSOptionParser()
-        op.add_option("--disabled", dest="sel", action="store_const", const=0)
-        op.add_option("--enforcing", dest="sel", action="store_const", const=1)
-        op.add_option("--permissive", dest="sel", action="store_const", const=2)
-
-        (opts, extra) = op.parse_args(args=args)
-        self.ksdata.selinux = opts.sel
-
-    def doSkipX(self, args):
-        self.ksdata.skipx = True
-
-    def doTimezone(self, args):
-        op = KSOptionParser()
-        op.add_option("--utc", dest="isUtc", action="store_true", default=False)
-
-        (opts, extra) = op.parse_args(args=args)
-        self.ksdata.timezone["isUtc"] = opts.isUtc
-
-        if len(extra) != 1:
-            raise KickstartValueError, "A single argument is expected for timezone"
-
-        self.ksdata.timezone["timezone"] = extra[0]
-
-    def doUpgrade(self, args):
-        self.ksdata.upgrade = True
-
-    def doVnc(self, args):
-        def connect_cb (option, opt_str, value, parser):
-            cargs = opt_str.split(":")
-            parser.values.ensure_value("host", cargs[0])
-
-            if len(cargs) > 1:
-                parser.values.ensure_value("port", cargs[1])
-
-        op = KSOptionParser()
-        op.add_option("--connect", action="callback", callback=connect_cb,
-                      nargs=1, type="string", required=1)
-        op.add_option("--password", dest="password")
-
-        (opts, extra) = op.parse_args(args=args)
-
-        self.ksdata.vnc["enabled"] = True
-
-        for key in filter (lambda k: getattr(opts, k) != None, op.keys()):
-            self.ksdata.vnc[key] = getattr(opts, key)
-
-    def doVolumeGroup(self, args):
-        # Have to be a little more complicated to set two values.
-        def vg_cb (option, opt_str, value, parser):
-            parser.values.ensure_value(option.dest, False)
-            parser.values.ensure_value("preexist", True)
-
-        op = KSOptionParser()
-        op.add_option("--noformat", action="callback", callback=vg_cb,
-                      dest="format", default=True, nargs=0)
-        op.add_option("--pesize", dest="pesize", type="int", nargs=1,
-                      default=32768)
-        op.add_option("--useexisting", dest="preexist", action="store_true",
-                      default=False)
-
-        (opts, extra) = op.parse_args(args=args)
-
-        vgd = KickstartVolGroupData()
-        for key in filter (lambda k: getattr(opts, k) != None, op.keys()):
-            setattr(vgd, key, getattr(opts, key))
-
-        vgd.vgname = extra[0]
-        vgd.physvols = extra[1:]
-        self.ksdata.vgList.append(vgd)
-
-    def doXConfig(self, args):
-        op = KSOptionParser()
-        op.add_option("--driver", dest="driver")
-        op.add_option("--defaultdesktop", dest="defaultdesktop")
-        op.add_option("--depth", dest="depth", action="store", type="int",
-                      nargs=1)
-        op.add_option("--hsync", dest="hsync")
-        op.add_option("--monitor", dest="monitor")
-        op.add_option("--noprobe", dest="probe", action="store_false",
-                      default=True)
-        op.add_option("--resolution", dest="resolution")
-        op.add_option("--startxonboot", dest="startX", action="store_true",
-                      default=False)
-        op.add_option("--videoram", dest="videoRam")
-        op.add_option("--vsync", dest="vsync")
-
-        (opts, extra) = op.parse_args(args=args)
-        if extra:
-            raise KickstartValueError, "Unexpected arguments to xconfig: %s" % string.join (args)
-
-        for key in filter (lambda k: getattr(opts, k) != None, op.keys()):
-            self.ksdata.xconfig[key] = getattr(opts, key)
-
-    def doZeroMbr(self, args):
-        self.ksdata.zerombr = True
-
-    def doZFCP(self, args):
-        op = KSOptionParser()
-        op.add_option("--devnum", dest="devnum", required=1)
-        op.add_option("--fcplun", dest="fcplun", required=1)
-        op.add_option("--scsiid", dest="scsiid", required=1)
-        op.add_option("--scsilun", dest="scsilun", required=1)
-        op.add_option("--wwpn", dest="wwpn", required=1)
-
-        (opts, extra) = op.parse_args(args=args)
-
-        for key in filter (lambda k: getattr(opts, k) != None, op.keys()):
-            self.ksdata.zfcp[key] = getattr(opts, key)
-
-# The kickstart file parser.  This only transitions between states and calls
-# handlers at certain points.  To create a specialized parser, make a subclass
-# of this and override the methods you care about.  Methods that don't need to
-# do anything may just pass.
-#
-# Passing None for kshandlers is valid just in case you don't care about
-# handling any commands.
-class KickstartParser:
-    def __init__ (self, ksdata, kshandlers):
-        self.handler = kshandlers
-        self.ksdata = ksdata
-        self.followIncludes = True
-        self.state = STATE_COMMANDS
-        self.script = None
-        self.includeDepth = 0
-
-    # Functions to be called when we are at certain points in the
-    # kickstart file parsing.  Override these if you need special
-    # behavior.
-    def addScript (self):
-        if string.join(self.script["body"]).strip() == "":
-            return
-
-        s = Script (self.script["body"], self.script["interp"],
-                    self.script["chroot"], self.script["log"],
-                    self.script["errorOnFail"])
-
-        if self.state == STATE_PRE:
-            self.ksdata.preScripts.append(s)
-        elif self.state == STATE_POST:
-            self.ksdata.postScripts.append(s)
-        elif self.state == STATE_TRACEBACK:
-            self.ksdata.tracebackScripts.append(s)
-
-    def addPackages (self, line):
-        if line[0] == '@':
-            line = line[1:]
-            self.ksdata.groupList.append(line.lstrip())
-        elif line[0] == '-':
-            line = line[1:]
-            self.ksdata.excludedList.append(line.lstrip())
-        else:
-            self.ksdata.packageList.append(line.lstrip())
-
-    def handleCommand (self, cmd, args):
-        if not self.handler:
-            return
-
-        if not self.handler.handlers.has_key(cmd):
-            raise KickstartParseError, (cmd + " " + string.join (args))
-        else:
-            if self.handler.handlers[cmd] != None:
-                setattr(self.handler, "currentCmd", cmd)
-                self.handler.handlers[cmd](args)
-
-    def handlePackageHdr (self, args):
-        op = KSOptionParser()
-        op.add_option("--excludedocs", dest="excludedocs", action="store_true",
-                      default=False)
-        op.add_option("--ignoremissing", dest="ignoremissing",
-                      action="store_true", default=False)
-        op.add_option("--nobase", dest="nobase", action="store_true",
-                      default=False)
-
-        (opts, extra) = op.parse_args(args=args[1:])
-
-        self.ksdata.excludeDocs = opts.excludedocs
-        self.ksdata.addBase = not opts.nobase
-        if opts.ignoremissing:
-            self.ksdata.handleMissing = KS_MISSING_IGNORE
-        else:
-            self.ksdata.handleMissing = KS_MISSING_PROMPT
-
-    def handleScriptHdr (self, args):
-        op = KSOptionParser()
-        op.add_option("--erroronfail", dest="errorOnFail", action="store_true",
-                      default=False)
-        op.add_option("--interpreter", dest="interpreter", default="/bin/sh")
-        op.add_option("--log", "--logfile", dest="log")
-
-        if args[0] == "%pre" or args[0] == "%traceback":
-            self.script["chroot"] = False
-        elif args[0] == "%post":
-            self.script["chroot"] = True
-            op.add_option("--nochroot", dest="nochroot", action="store_true",
-                          default=False)
-
-        (opts, extra) = op.parse_args(args=args[1:])
-
-        self.script["interp"] = opts.interpreter
-        self.script["log"] = opts.log
-        self.script["errorOnFail"] = opts.errorOnFail
-	if hasattr(opts, "nochroot"):
-            self.script["chroot"] = not opts.nochroot
-
-    def readKickstart (self, file):
-        packages = []
-        groups = []
-        excludedPackages = []
-
-        fh = open(file)
-        needLine = True
-
-        while True:
-            if needLine:
-                line = fh.readline()
-                needLine = False
-
-            if line == "" and self.includeDepth > 0:
-                fh.close()
-                break
-
-            # Don't eliminate whitespace or comments from scripts.
-            if line.isspace() or (line != "" and line[0] == '#'):
-                # Save the platform for s-c-kickstart, though.
-                if line[:10] == "#platform=" and self.state == STATE_COMMANDS:
-                    self.ksdata.platform = line[11:]
-
-                if self.state in [STATE_PRE, STATE_POST, STATE_TRACEBACK]:
-                    self.script["body"].append(line)
-
-                needLine = True
-                continue
-
-            args = shlex.split(line)
-
-            if args and args[0] == "%include" and self.followIncludes:
-                if not args[1]:
-                    raise KickstartParseError, line
-                else:
-                    self.includeDepth += 1
-                    self.readKickstart (args[1])
-                    self.includeDepth -= 1
-                    needLine = True
-                    continue
-
-            if self.state == STATE_COMMANDS:
-                if not args and self.includeDepth == 0:
-                    self.state = STATE_END
-                elif args[0] in ["%pre", "%post", "%traceback"]:
-                    self.state = STATE_SCRIPT_HDR
-                elif args[0] == "%packages":
-                    self.state = STATE_PACKAGES
-                elif args[0][0] == '%':
-                    raise KickstartParseError, line
-                else:
-                    needLine = True
-                    self.handleCommand(args[0], args[1:])
-
-            elif self.state == STATE_PACKAGES:
-                if not args and self.includeDepth == 0:
-                    self.state = STATE_END
-                elif args[0] in ["%pre", "%post", "%traceback"]:
-                    self.state = STATE_SCRIPT_HDR
-                elif args[0] == "%packages":
-                    needLine = True
-                    self.handlePackageHdr (args)
-                elif args[0][0] == '%':
-                    raise KickstartParseError, line
-                else:
-                    needLine = True
-                    self.addPackages (string.rstrip(line))
-
-            elif self.state == STATE_SCRIPT_HDR:
-                needLine = True
-                self.script = {"body": [], "interp": "/bin/sh", "log": None,
-                               "errorOnFail": False}
-
-                if not args and self.includeDepth == 0:
-                    self.state = STATE_END
-                elif args[0] == "%pre":
-                    self.state = STATE_PRE
-                elif args[0] == "%post":
-                    self.state = STATE_POST
-                elif args[0] == "%traceback":
-                    self.state = STATE_TRACEBACK
-                elif args[0][0] == '%':
-                    raise KickstartParseError, line
-
-                self.handleScriptHdr (args)
-
-            elif self.state in [STATE_PRE, STATE_POST, STATE_TRACEBACK]:
-                # If this is part of a script, append to it.
-                if not args and self.includeDepth == 0:
-                    self.addScript()
-                    self.state = STATE_END
-                elif args[0] in ["%pre", "%post", "%traceback", "%packages"]:
-                    # Otherwise, figure out what kind of a script we just
-                    # finished reading, add it to the list, and switch to
-                    # the initial state.
-                    self.addScript()
-                    self.state = STATE_COMMANDS
-                else:
-                    self.script["body"].append(line)
-                    needLine = True
-
-            elif self.state == STATE_END:
-                break