30 files changed, 1244 insertions, 531 deletions

diff --git a/bootloader.py b/bootloader.py
index 88610ffcf..e4630ea9e 100644
--- a/bootloader.py
+++ b/bootloader.py
@@ -71,6 +71,11 @@ def bootloaderSetupChoices(dispatch, bl, fsset, diskSet, dir):
     
 
 def writeBootloader(intf, instRoot, fsset, bl, langs, comps):
+    def dosync():
+        isys.sync()
+        isys.sync()
+        isys.sync()
+        
     justConfigFile = not flags.setupFilesystems
 
     if bl.defaultDevice == -1:
@@ -117,13 +122,13 @@ def writeBootloader(intf, instRoot, fsset, bl, langs, comps):
 	    kernelList.append((kernelLabel, kernelLongLabel, version))
 	    plainLabelUsed = 1
 
-
     # FIXME: blah, exec-shield breaks grub.  turn it off for now
     if os.access("/proc/sys/kernel/exec-shield", os.W_OK):
         f = open("/proc/sys/kernel/exec-shield", "w")
         f.write("0")
         f.close()
     
+    dosync()
     try:
         bl.write(instRoot, fsset, bl, langs, kernelList, otherList, defaultDev,
                  justConfigFile, intf)
@@ -135,6 +140,7 @@ def writeBootloader(intf, instRoot, fsset, bl, langs, comps):
                                _("No kernel packages were installed on your "
                                  "system.  Your boot loader configuration "
                                  "will not be changed."))
+    dosync()
 
 # note that this function no longer actually creates an initrd.
 # the kernel's %post does this now
diff --git a/comps.py b/comps.py
index 9b2aad4e9..89475313c 100644
--- a/comps.py
+++ b/comps.py
@@ -196,7 +196,11 @@ class HeaderList:
                 preordered = 0
         return preordered
 
-    def __init__(self, hdlist, compatPackages = None, noscore = 0):
+    # JKFIXME: prunePPCKernels is an awful hack to let us do something
+    # with kernel-iseries and kernel-pseries and still be able to get
+    # both of them for the pkgorder file.  
+    def __init__(self, hdlist, compatPackages = None, noscore = 0,
+                 prunePPCKernels = 1):
         self.hdlist = hdlist
 	self.packages = {}
 	newCompat = []
@@ -206,14 +210,14 @@ class HeaderList:
 
             # we should only keep kernel-pseries and kernel-iseries on
             # the appropriate machine
-            if name == "kernel-pseries" and iutil.getPPCMachine() != "pSeries":
+            if prunePPCKernels and name == "kernel-pseries" and iutil.getPPCMachine() != "pSeries":
                 continue
-            if name == "kernel-iseries" and iutil.getPPCMachine() != "iSeries":
+            if prunePPCKernels and name == "kernel-iseries" and iutil.getPPCMachine() != "iSeries":
                 continue
 
             # FIXME: this is a really bad hack so that we can try to avoid
             # weirdness with kernel packages
-            if name == "kernel-iseries" or name == "kernel-pseries":
+            if prunePPCKernels and (name == "kernel-iseries" or name == "kernel-pseries"):
                 self.packages["kernel"] = Package(h)
             
             if noscore:
@@ -240,10 +244,10 @@ class HeaderList:
 
 class HeaderListFromFile (HeaderList):
 
-    def __init__(self, path, compatPackages = None, noscore = 0):
+    def __init__(self, path, compatPackages = None, noscore = 0, prunePPCKernels = 1):
 	hdlist = rpm.readHeaderListFromFile(path)
 	HeaderList.__init__(self, hdlist, compatPackages = compatPackages,
-			    noscore = noscore)
+			    noscore = noscore, prunePPCKernels = prunePPCKernels)
 
 class HeaderListFD (HeaderList):
     def __init__(self, fd):
diff --git a/dispatch.py b/dispatch.py
index 80dec2f7a..c9446ccc0 100644
--- a/dispatch.py
+++ b/dispatch.py
@@ -108,14 +108,14 @@ installSteps = [
     ("desktopchoice", ("intf", "id.instClass", "dispatch")),
     ("findpackages", upgradeFindPackages, ("intf", "method", "id",
                                            "instPath", "dir")),
-    ("selectlangpackages", selectLanguageSupportGroups, ("id.comps","id.langSupport")),    
-    ("package-selection", ("id.comps", "id.langSupport", "id.instClass", "dispatch")),
-    ("indivpackage", ("id.comps", "id.hdList")),
+    ("selectlangpackages", selectLanguageSupportGroups, ("id.grpset","id.langSupport")),    
+    ("package-selection", ("id.grpset", "id.langSupport", "id.instClass", "dispatch")),
+    ("indivpackage", ("id.grpset")),
     ("handleX11pkgs", handleX11Packages, ("dir", "intf", "dispatch",
                                           "id", "instPath")),
     ("checkdeps", checkDependencies, ("dir", "intf", "dispatch",
                                       "id", "instPath")),
-    ("dependencies", ("id.comps", "id.dependencies")),
+    ("dependencies", ("id.grpset", "id.dependencies")),
     ("confirminstall", ()),
     ("confirmupgrade", ()),
     ("install", ("dir", "intf", "id")),
@@ -135,10 +135,10 @@ installSteps = [
     ("firstboot", firstbootConfiguration, ("id", "instPath")),
     ("instbootloader", writeBootloader, ("intf", "instPath", "id.fsset", 
                                          "id.bootloader", "id.langSupport",
-                                         "id.comps")),
+                                         "id.grpset")),
     ("bootdisk", ("dir", "dispatch", "id.fsset")),
     ("makebootdisk", makeBootdisk, ("intf", "dir", "id.floppyDevice",
-                                    "id.hdList", "instPath", "id.bootloader")),
+                                    "id.grpset", "instPath", "id.bootloader")),
 #
 # we dont use videocard and xcustom currently, they are still listed as
 # steps but are not listed in the list of install steps in installclass.py
@@ -149,7 +149,7 @@ installSteps = [
 # failed. Needs to be here if we enable videocard and xcustom again.
 #    ("monitor", ("id.xsetup", "id.monitor", "intf")),
     ("xcustom", ("id.xsetup", "id.monitor", "id.videocard",
-                 "id.desktop", "id.comps", "id.instClass", "instPath")),
+                 "id.desktop", "id.grpset", "id.instClass", "instPath")),
     ("writexconfig", writeXConfiguration, ("id", "instPath")),
     ("writeksconfig", writeKSConfiguration, ("id", "instPath")),
     ("dopostaction", doPostAction, ("id", "instPath")),
diff --git a/harddrive.py b/harddrive.py
index 615ebe705..f1dcf42fa 100644
--- a/harddrive.py
+++ b/harddrive.py
@@ -12,7 +12,7 @@
 #
 
 
-from comps import ComponentSet, HeaderList, HeaderListFromFile
+from hdrlist import groupSetFromCompsFile, HeaderListFromFile
 from installmethod import InstallMethod, FileCopyException
 from image import findIsoImages
 import shutil
@@ -67,7 +67,7 @@ class HardDriveInstallMethod(InstallMethod):
     def readCompsViaMethod(self, hdlist):
 	self.mountMedia(1)
 	fname = self.findBestFileMatch(self.tree, 'comps.xml')
-	cs = ComponentSet(fname, hdlist)
+        cs = groupSetFromCompsFile(fname, hdlist)
 	self.umountMedia()
 	return cs
 
@@ -113,7 +113,7 @@ class HardDriveInstallMethod(InstallMethod):
 	hdlist.mergeFullHeaders(self.tree + "/RedHat/base/hdlist2")
 	self.umountMedia()
 
-    def systemMounted(self, fsset, mntPoint, selected):
+    def systemMounted(self, fsset, mntPoint):
 	self.mountMedia(1)
 	    
     def systemUnmounted(self):
diff --git a/hdrlist.py b/hdrlist.py
new file mode 100644
index 000000000..df91adc97
--- /dev/null
+++ b/hdrlist.py
@@ -0,0 +1,828 @@
+#
+# hdrlist.py: header list and group set management.
+# Parts from old anaconda/comps.py
+#
+# Erik Troan <ewt@redhat.com>
+# Matt Wilson <msw@redhat.com>
+# Michael Fulbright <msf@redhat.com>
+# Jeremy Katz <katzj@redhat.com>
+#
+# Copyright 2001-2003 Red Hat, Inc.
+#
+# This software may be freely redistributed under the terms of the GNU
+# library public license.
+#
+# You should have received a copy of the GNU Library Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+#
+
+import rpm
+import os,sys,time
+
+from rhpl.log import log
+from rhpl.translate import _, N_
+import rhpl.comps
+
+import language
+
+ON = 1
+MANUAL_ON = 2
+OFF = -1
+MANUAL_OFF = -2
+MANUAL_NONE = 0
+ON_STATES = (ON, MANUAL_ON)
+OFF_STATES = (OFF, MANUAL_OFF)
+
+PKGTYPE_MANDATORY = 0
+PKGTYPE_DEFAULT = 1
+PKGTYPE_OPTIONAL = 2
+
+def showMem():
+    f = open("/proc/self/status", "r")
+    lines = f.readlines()
+    f.close()
+    for line in lines:
+        if line.startswith("VmSize:"):
+            vmsize = line.split(":")[1].strip()
+        if line.startswith("VmRSS:"):
+            vmrss = line.split(":")[1].strip()
+    print vmsize, vmrss
+
+
+def nevra(hdr):
+    "Convenience function to return the NEVRA in canonical form for a header."
+    if hdr[rpm.RPMTAG_EPOCH]:
+        epoch = hdr[rpm.RPMTAG_EPOCH]
+    else:
+        epoch = "0"
+
+    return "%s-%s:%s-%s.%s" %(hdr[rpm.RPMTAG_NAME],
+                              epoch,
+                              hdr[rpm.RPMTAG_VERSION],
+                              hdr[rpm.RPMTAG_RELEASE],
+                              hdr[rpm.RPMTAG_ARCH])
+
+def getLangs():
+    if os.environ.has_key("LANG"):
+        langs = language.expandLangs(os.environ["LANG"])
+    else:
+        langs = []
+    return langs
+
+
+class DependencyChecker:
+    def __init__(self, grpset, how = "i"):
+        self.grpset = grpset
+        self.added = []
+        self.unknown = []
+        self.how = how
+
+    # FIXME: this is the simple stupid version.  it doesn't actually handle
+    # paying attention to EVR
+    def callback(self, ts, tag, name, evr, flags):
+        if tag == rpm.RPMTAG_REQUIRENAME:
+            hdr = None
+            if name[0] == "/":
+                for h in self.grpset.hdrlist.pkgs.values():
+                    l = []
+                    for f in h.hdr.fiFromHeader(): l.append(f[0])
+                    
+                    if ((name in l) and
+                        ((hdr is None) or (len(h[rpm.RPMTAG_NAME]) <
+                                           len(hdr[rpm.RPMTAG_NAME])))):
+                        hdr = h
+            else:
+                # do we have a package named this?
+                if self.grpset.hdrlist.has_key(name):
+                    hdr = self.grpset.hdrlist[name]
+                # otherwise, go through provides and find the shortest name
+                else:
+                    for h in self.grpset.hdrlist.pkgs.values():
+                        if ((name in h[rpm.RPMTAG_PROVIDENAME]) and
+                            ((hdr is None) or (len(h[rpm.RPMTAG_NAME]) <
+                                               len(hdr[rpm.RPMTAG_NAME])))):
+                            hdr = h
+                            
+            if hdr is not None:
+                if evr:
+                    nevr = "%s-%s" %(name, evr)
+                else:
+                    nevr = name
+                log("using %s to satisfy %s" %(nevra(hdr), nevr))
+                ts.addInstall(hdr.hdr, hdr.hdr, self.how)
+                self.added.append(nevra(hdr.hdr))
+                return -1
+
+        return 1
+            
+
+class Package:
+    def __init__(self, hdr):
+        self.hdr = hdr
+        self.usecount = 0
+        self.manual_state = MANUAL_NONE
+        self.dependencies = []
+
+        self.name = self.hdr[rpm.RPMTAG_NAME]
+
+    def getState(self):
+        return (self.usecount, self.manual_state)
+
+    def setState(self, state):
+        (self.usecount, self.manual_state) = state
+
+    def addDeps(self, deps):
+        self.dependencies.extend(deps)
+
+    def select(self, isManual = 0):
+        self.usecount = self.usecount + 1
+        if isManual:
+            if self.manual_state == MANUAL_NONE:
+                self.manual_state = MANUAL_ON
+            elif self.manual_state == MANUAL_OFF:
+                self.manual_state = MANUAL_NONE
+
+    def unselect(self, isManual = 0):
+        self.usecount = self.usecount - 1
+        if isManual:
+            if self.manual_state == MANUAL_NONE:
+                self.manual_state = MANUAL_OFF
+            elif self.manual_state == MANUAL_ON:
+                self.manual_state = MANUAL_NONE
+
+        # DEBUG
+        if self.usecount < 0:
+            log("WARNING: usecount for %s dropped below 0 (%d)" %(nevra(self.hdr),self.usecount))
+
+    # if we've been manually turned on or off, follow that
+    # otherwise, if the usecount is > 0, then we're selected
+    def isSelected(self):
+        if self.manual_state == MANUAL_ON:
+            return 1
+        elif self.manual_state == MANUAL_OFF:
+            return 0
+        elif self.usecount > 0:
+            return 1
+        else:
+            return 0
+
+    def __getitem__(self, item):
+        return self.hdr[item]
+
+    def __repr__(self):
+        return "%s" %(self.nevra(),)
+
+    def getDescription(self):
+        return self.hdr[rpm.RPMTAG_SUMMARY]
+
+    def nevra(self):
+        return nevra(self.hdr)
+
+class HeaderList:
+    def __init__(self, hdlist):
+        self.hdlist = hdlist
+        self.pkgs = {}
+        self.pkgnames = {}
+
+        for h in hdlist:
+            nevrastr = nevra(h)
+            name = h['name']
+
+            if self.pkgs.has_key(nevra):
+                log("Have more than one copy of %s, skipping" %(nevrastr,))
+                continue
+
+            self.pkgs[nevrastr] = Package(h)
+            if self.pkgnames.has_key(name):
+                self.pkgnames[name].append( (nevrastr, h['arch']) )
+            else:
+                self.pkgnames[name] = [ (nevrastr, h['arch']) ]
+
+        self.hasFullHeaders = None
+
+    def has_key(self, item):
+        if self.pkgs.has_key(item):
+            return 1
+        elif self.pkgnames.has_key(item):
+            return 1
+        return 0
+
+    def keys(self):
+        return self.pkgnames.keys()
+
+    def values(self):
+        return self.pkgs.values()
+
+    # FIXME: the package deps stuff needs to be nevra instead of name based
+    def mergePackageDeps(self, pkgsxml):
+        for pkg in pkgsxml.values():
+            for (p, a) in self.pkgnames[pkg.name]:
+                self.pkgs[p].addDeps(pkg.dependencies)
+
+    # this is definite crack rock, but it allows us to avoid tripling
+    # our memory usage :(
+    # reads an hdlist2 file and merges the header information we split out
+    # (things like file lists)
+    # FIXME: BUSTED!
+    def mergeFullHeaders(self, file):
+        if self.hasFullHeaders is not None:
+            return
+        fd = os.open(file, os.O_RDONLY)
+        rpm.mergeHeaderListFromFD(self.hdlist, fd, 1000004)
+        os.close(fd)
+        self.hasFullHeaders = 1
+ 
+    def preordered(self):
+        preordered = 1
+        for h in self.pkgs.values():
+            if h.isSelected() and h[1000003] == None:
+                preordered = 0
+        return preordered
+
+    # get the best nevra for the package name.
+    # FIXME: surely this can be made faster/less complicated
+    # doing scoring everytime seems like it might be overkill
+    # then again, it shouldn't be called *that* often so it might not matter
+    def getBestNevra(self, item):
+        bestscore = 0
+        bestpkg = None
+
+        if not self.pkgnames.has_key(item):
+            return None
+        
+        for (nevra, arch) in self.pkgnames[item]:
+            # FIXME: need to use our replacement for arch scoring
+            # so that we can work with biarch
+            score = rpm.archscore(arch)
+            if not score:
+                continue
+            if (bestscore == 0) or (score < bestscore):
+                bestpkg = nevra
+                bestscore = score
+        return bestpkg
+
+    # FIXME: surely this can be made faster/less complicated
+    # doing scoring everytime seems like it might be overkill
+    # then again, it shouldn't be called *that* often so it might not matter
+    def __getitem__(self, item):
+        if self.pkgs.has_key(item):
+            return self.pkgs[item]
+
+        # explict nevra not specified -- see what we can do
+        pkg = self.getBestNevra(item)
+
+        if pkg is None:
+            raise KeyError, "No such package"
+
+        return self.pkgs[pkg]
+
+
+class HeaderListFromFile (HeaderList):
+    def __init__(self, path):
+	hdlist = rpm.readHeaderListFromFile(path)
+	HeaderList.__init__(self, hdlist)
+
+class Group:
+    def __init__(self, grpset, xmlgrp):
+        # dict of package info.  nevra and type are obvious
+        # state is one of the ON/OFF states
+        def makePackageDict(pkgnevra, type, installed = 0):
+            return { "nevra": pkgnevra, "type": type, "state": installed }
+        
+        self.id = xmlgrp.id
+        self.basename = xmlgrp.name
+
+        # We want to have translated name/descriptions
+        self.name = None
+        self.description = None
+        for lang in getLangs():
+            if (self.name is None and
+                xmlgrp.translated_name.has_key(lang)):
+                self.name = xmlgrp.translated_name[lang]
+            if (self.description is None and
+                xmlgrp.translated_description.has_key(lang)):
+                self.description = xmlgrp.translated_description[lang]
+        # fall back to english if they're not set
+        if self.name is None:
+            self.name = xmlgrp.name
+        if self.description is None:
+            self.description = xmlgrp.description
+
+        # obviously enough, hidden components aren't shown
+        self.hidden = not xmlgrp.user_visible
+        # whether or not a group should be enabled by default.  only
+        # really matters for custom installs
+        self.default = xmlgrp.default
+        # FIXME: this is a hack to handle language support groups
+        self.langonly = xmlgrp.langonly
+
+        # FIXME: do we really want to keep this?  needed to select packages
+        self.grpset = grpset
+        hdrlist = grpset.hdrlist
+
+        # refcount/manual state just like with packages
+        self.usecount = 0
+        self.manual_state = MANUAL_NONE
+
+        # included groups (ie groups that are required if we're selected)
+        self.groupreqs = []
+
+        self.packages = {}
+        for (pkg, (type, name)) in xmlgrp.packages.items():
+            pkgnevra = hdrlist.getBestNevra(pkg)
+            if pkgnevra is None:
+                log("%s references package %s which doesn't exist"
+                    %(self.id, pkg))
+                continue
+
+            if type == u'mandatory':
+                pkgtype = PKGTYPE_MANDATORY
+            elif type == u'default':
+                pkgtype = PKGTYPE_DEFAULT
+            elif type == u'optional':
+                pkgtype = PKGTYPE_OPTIONAL
+            else:
+                log("Invalid package type of %s for %s in %s; defaulting to "
+                    "optional" % (type, pkgnevra, self.id))
+                pkgtype = PKGTYPE_OPTIONAL
+
+            self.packages[pkgnevra] = makePackageDict(pkgnevra, pkgtype)
+
+    def getState(self):
+        return (self.usecount, self.manual_state)
+
+    def setState(self, state):
+        (self.usecount, self.manual_state) = state
+
+    def addGroupRequires(self, grpid):
+        if grpid not in self.groupreqs:
+            self.groupreqs.append(grpid)
+
+    # FIXME: this doesn't seem like the right place for it, but ... :/
+    def selectDeps(self, pkgs, uses = 1):
+        checked = []
+        while len(pkgs) > 0:
+            tocheck = pkgs
+            pkgs = []
+            for pkgnevra in tocheck:
+                pkg = self.grpset.hdrlist[pkgnevra]
+
+                deps = pkg.dependencies
+                for dep in deps:
+                    # hmm, not in the header list.  we can't do much but
+                    # hope for the best
+                    if not self.grpset.hdrlist.has_key(dep):
+                        log("Package %s requires %s which we don't have"
+                            %(tocheck, dep))
+                        continue
+                    # if we've already checked for this package, don't worry
+                    if dep in checked:
+                        continue
+                    self.grpset.hdrlist[dep].select()
+                    # FIXME: this is a hack so we can make sure the usecount
+                    # is bumped high enough for langsupport packages
+                    self.grpset.hdrlist[dep].usecount += uses - 1
+                    pkgs.append(nevra(self.grpset.hdrlist[dep]))
+                    checked.append(dep)
+
+
+    # FIXME: this doesn't seem like the right place for it, but ... :/
+    def unselectDeps(self, pkgs):
+        checked = []
+        while len(pkgs) > 0:
+            tocheck = pkgs
+            pkgs = []
+            for pkgnevra in tocheck:
+                pkg = self.grpset.hdrlist[pkgnevra]
+
+                deps = pkg.dependencies
+                for dep in deps:
+                    # hmm, not in the header list.  we can't do much but
+                    # hope for the best
+                    if not self.grpset.hdrlist.has_key(dep):
+                        log("Package %s requires %s which we don't have"
+                            %(tocheck, dep))
+                        continue
+                    # if we've already checked for this package, don't worry
+                    if dep in checked:
+                        continue
+                    sys.stdout.flush()
+                    self.grpset.hdrlist[dep].unselect()
+                    pkgs.append(nevra(self.grpset.hdrlist[dep]))
+                    checked.append(dep)
+        
+
+    # forInclude is whether this group is an include from a previous
+    # subAsInclude allows us to say that included groups shouldn't be
+    #    forInclude  (useful for Workstation Common, etc)
+    def select(self, forInclude = 0, subAsInclude = 0):
+        hdrlist = self.grpset.hdrlist
+
+        # update the usecount.  if this is manual, change the state if needed
+        # if we were already previously selected, we don't need to bump up
+        # refcounts (which makes things faster)
+        self.usecount = self.usecount + 1
+        if not forInclude:
+            self.manual_state = MANUAL_ON
+        if self.usecount > 1:
+            return
+
+        selected = []
+        for (pkgnevra, pkg) in self.packages.items():
+            # if it's not optional, we should turn it on
+            if pkg["type"] == PKGTYPE_OPTIONAL:
+                continue
+            pkg["state"] = ON
+            hdrlist[pkgnevra].select()
+            selected.append(pkgnevra)
+        self.selectDeps(selected)
+
+        for grpid in self.groupreqs:
+            self.grpset.groups[grpid].select(forInclude = (not subAsInclude))
+
+    # manual package selection
+    def selectPackage(self, pkgnevra):
+        pkg = self.packages[pkgnevra]
+        if pkg["state"] in ON_STATES:
+            return
+        pkg["state"] = ON
+        self.grpset.hdrlist[pkgnevra].select()
+        self.selectDeps([pkgnevra])
+            
+    def unselect(self, forInclude = 0):
+        hdrlist = self.grpset.hdrlist
+
+        # update the usecount.  if this is manual, change the state if needed
+        # if we were already previously selected, we don't need to bump up
+        # refcounts (which makes things faster)
+        self.usecount = self.usecount - 1
+        if not forInclude:
+            self.manual_state = MANUAL_OFF
+        if self.usecount < 0: log("WARNING: usecount for %s < 0 (%d)" %(self.id, self.usecount))
+        if self.usecount > 0:
+            return
+
+        selected = []
+        for pkg in self.packages.values():
+            pkgnevra = pkg["nevra"]
+            if pkg["state"] not in ON_STATES:
+                continue
+            hdrlist[pkgnevra].unselect()
+            pkg["state"] = OFF
+            selected.append(pkgnevra)
+        self.unselectDeps(selected)
+        
+        for grpid in self.groupreqs:
+            self.grpset.groups[grpid].unselect(forInclude = 1)
+
+    def unselectPackage(self, pkgnevra):
+        pkg = self.packages[pkgnevra]
+        if pkg["state"] not in ON_STATES:
+            return
+        self.grpset.hdrlist[pkgnevra].unselect()
+        pkg["state"] = OFF
+        self.unselectDeps([pkgnevra])        
+
+    def isSelected(self, justManual = 0):
+        if justManual:
+            if self.manual_state == MANUAL_ON:
+                return 1
+            else:
+                return 0
+        return (self.usecount > 0)
+
+    def packageInfo(self):
+        ret = {}
+        for pkg in self.packages.values():
+            ret[pkg["nevra"]] = (pkg["type"], pkg["state"])
+
+        return ret
+
+    # FIXME: remove this
+    def includesPackage(self, pkg):
+        pkgnevra = nevra(pkg)
+        if self.packages.has_key(pkgnevra):
+            return 1
+
+        # make sure it's not in this group for deps
+        tocheck = self.packages.keys()
+        checked = []
+        while len(tocheck) > 0:
+            pkgs = tocheck
+            tocheck = []
+            for p in pkgs:
+                if pkgnevra in self.grpset.hdrlist[p].dependencies:
+                    return 1
+                checked.append(p)
+                for m in self.grpset.hdrlist[p].dependencies:
+                    if m not in checked and m not in tocheck:
+                        tocheck.append(m)
+        return 0
+            
+
+    def getDescription(self):
+        if self.id == "everything":
+            return _("This group includes all the packages available.  "
+                     "Note that there are substantially more packages than "
+                     "just the ones in all the other package groups on "
+                     "this page.")
+        return self.description
+        
+
+class GroupSet:
+    def __init__(self, compsxml, hdrlist):
+        self.hdrlist = hdrlist
+        self.compsxml = compsxml
+        self.groups = {}
+
+        for xmlgrp in compsxml.groups.values():
+            group = Group(self, xmlgrp)
+            self.groups[xmlgrp.id] = group
+
+        # have to do includes and metagroups in a second pass so that
+        # we can make sure the group is defined.  
+        for xmlgrp in compsxml.groups.values():
+            group = self.groups[xmlgrp.id]
+            for id in xmlgrp.groups.keys():
+                if not self.groups.has_key(id):
+                    log("%s references component %s which doesn't exist"
+                        %(xmlgrp.id, id))
+                    continue
+                group.addGroupRequires(id)
+            # FIXME: need to add back metapkgs
+
+    def mergePackageDeps(self):
+        self.hdrlist.mergePackageDeps(self.compsxml.packages)
+
+    def selectGroup(self, group, asMeta = 0):
+        if self.groups.has_key(group):
+            self.groups[group].select(subAsInclude = asMeta)
+            return
+        for grp in self.compsxml.groups.values():
+            if (grp.name == group) and self.groups.has_key(grp.id):
+                self.groups[grp.id].select(subAsInclude = asMeta)
+                return
+        raise KeyError, "No such group %s" %(group,)
+
+    def unselectAll(self):
+        for group in self.groups.values():
+            if group.isSelected(justManual = 1):
+                group.unselect()
+
+    def getSelectionState(self):
+        grpst = []
+        for group in self.groups.values():
+            grpst.append((group, group.getState()))
+
+        pkgst = []
+        for pkg in self.hdrlist.values():
+            pkgst.append((pkg, pkg.getState()))
+            
+        return (grpst, pkgst)
+
+    def setSelectionState(self, state):
+        (grpst, pkgst) = state
+
+        for (grp, state) in grpst:
+            grp.setState(state)
+
+        for (pkg,state) in pkgst:
+            pkg.setState(state)
+
+    def size(self):
+	size = 0
+	for pkg in self.hdrlist.values():
+	    if pkg.isSelected(): size = size + (pkg[rpm.RPMTAG_SIZE] / 1024)
+
+	return size / 1024
+
+    def sizeStr(self):
+	megs = self.size()
+	if (megs >= 1000):
+	    big = megs / 1000
+	    little = megs % 1000
+	    return "%d,%03dM" % (big, little)
+
+	return "%dM" % (megs)
+
+    def kernelVersionList(self):
+	kernelVersions = []
+
+	# nick is used to generate the lilo name
+	for (ktag, nick) in [ ('kernel-summit', 'summit'),
+                              ('kernel-bigmem', 'bigmem'),
+			      ('kernel-smp', 'smp'),
+			      ('kernel-tape', 'tape'),
+                              ('kernel-pseries', ''),
+                              ('kernel-iseries', '') ]:
+	    tag = ktag.split('-')[1]
+	    if (self.hdrlist.has_key(ktag) and 
+		self.hdrlist[ktag].isSelected()):
+		version = (self.hdrlist[ktag][rpm.RPMTAG_VERSION] + "-" +
+			   self.hdrlist[ktag][rpm.RPMTAG_RELEASE] + tag)
+		kernelVersions.append((version, nick))
+
+        if (self.hdrlist.has_key('kernel') and
+            self.hdrlist['kernel'].isSelected()):
+            version = (self.hdrlist['kernel'][rpm.RPMTAG_VERSION] + "-" +
+                       self.hdrlist['kernel'][rpm.RPMTAG_RELEASE])
+            kernelVersions.append((version, 'up'))
+ 
+	return kernelVersions
+
+
+def groupSetFromCompsFile(filename, hdrlist):
+    import urllib2
+    
+    tries = 0
+    while tries < 5:
+        try:
+            file = urllib2.urlopen(filename)
+        except urllib2.HTTPError, e:
+            log("HTTPError: %s occurred getting %s", filename, e)
+        except urllib2.URLError, e:
+            log("URLError: %s occurred getting %s", filename, e)
+        except IOError, (errnum, msg):
+            log("IOError %s occurred getting %s: %s", filename,
+                errnum, str(msg))
+        except IOError, (errnum, msg):
+            log("OSError %s occurred getting %s: %s", filename,
+                errnum, str(msg))
+        else:
+            break
+
+        time.sleep(5)
+        tries = tries + 1
+
+    compsxml = rhpl.comps.Comps(file)
+    file.close()
+    grpset = GroupSet(compsxml, hdrlist)
+
+    grpset.mergePackageDeps()
+
+    for group in grpset.groups.values():
+        if group.default:
+            group.select()
+    
+    return grpset
+
+def getGroupDescription(group):
+    if group.id == "everything":
+	return _("This group includes all the packages available.  Note that "
+		 "there are substantially more packages than just the ones "
+		 "in all the other package groups on this page.")
+    elif group.id == "base":
+	return _("Choose this group to get the minimal possible set of "
+		 "packages.  Useful for creating small router/firewall "
+		 "boxes, for example.")
+    
+    return group.description
+
+# this is a temporary way to set order of packages
+def orderPackageGroups(grpset):
+    compsParents = grpset.compsxml.hierarchy.order
+    compsHierarchy = grpset.compsxml.hierarchy
+
+    grpids = []
+    for grp in grpset.groups.values():
+	grpids.append(grp.id)
+
+    ignorelst = []
+    retlist = []
+    retdict = {}
+ 
+    if os.environ.has_key("LANG"):
+        langs = language.expandLangs(os.environ["LANG"])
+    else:
+        langs = []
+   
+    for key in compsParents:
+
+        # get the translated name
+        myname = None
+        if not compsHierarchy.translations.has_key(key):
+            myname = key
+        else:
+            for lang in langs:
+                if compsHierarchy.translations[key].has_key(lang):
+                    myname = compsHierarchy.translations[key][lang]
+                    break
+            if myname is None:
+                myname = key
+        
+        retlist.append(myname)
+        retdict[myname] = []
+        
+	compslist = compsHierarchy[key]
+	for grp in compslist:
+
+	    if grp in grpids:
+                thecomp = grpset.groups[grp]
+		ignorelst.append(grp)
+                retdict[myname].append(thecomp)
+
+    miscgrp = _("Miscellaneous")
+    for grp in grpids:
+	if grp in ignorelst:
+	    continue
+
+        thecomp = grpset.groups[grp]
+	if miscgrp not in retlist:
+	    retlist.append(miscgrp)
+	    retdict[miscgrp] = [thecomp]
+	else:
+	    retdict[miscgrp].append(thecomp)
+		    
+    return (retlist, retdict)
+
+if __name__ == "__main__":
+    tree = "/mnt/test/latest-taroon-i386/"
+    
+    def simpleInstallCallback(what, amount, total, h, (param)):
+        global rpmfd
+	if (what == rpm.RPMCALLBACK_TRANS_START):
+	    # step 6 is the bulk of the transaction set
+	    # processing time
+	    if amount == 6:
+                print "Preparing to install..."
+	if (what == rpm.RPMCALLBACK_TRANS_PROGRESS):
+            pass
+		
+        if (what == rpm.RPMCALLBACK_TRANS_STOP):
+            pass
+
+	if (what == rpm.RPMCALLBACK_INST_OPEN_FILE):
+            print "Installing %s" %(nevra(h),)
+            rpmfd = os.open("%s/RedHat/RPMS/%s-%s-%s.%s.rpm"
+                            %(tree, h['name'], h['version'], h['release'],
+                              h['arch']), os.O_RDONLY)
+	    return rpmfd
+	elif (what == rpm.RPMCALLBACK_INST_PROGRESS):
+            pass
+	elif (what == rpm.RPMCALLBACK_INST_CLOSE_FILE):
+	    os.close (rpmfd)
+        elif ((what == rpm.RPMCALLBACK_UNPACK_ERROR) or
+              (what == rpm.RPMCALLBACK_CPIO_ERROR)):
+            print "ERROR!"
+            sys.exit(0)
+	else:
+	    pass
+
+    def packageSort(first, second):
+        one = first[1000002]
+        two = second[1000002]
+
+        if one < two:
+            return -1
+        elif one > two:
+            return 1
+        return 0
+        
+    
+    fd = os.open(tree + "/RedHat/base/hdlist", os.O_RDONLY)
+    hdrs = rpm.readHeaderListFromFD(fd)
+    os.close(fd)
+    showMem()
+#     fd = os.open(tree + "/RedHat/base/hdlist2", os.O_RDONLY)
+#     rpm.mergeHeaderListFromFD(hdrs, fd, 1000004)
+#     os.close(fd)
+    showMem()
+    f = open(tree + "/RedHat/base/comps.xml", "r")
+    comps = rhpl.comps.Comps(f)
+    f.close()
+    showMem()
+    hdrlist = HeaderList(hdrs)
+    hdrlist.mergeFullHeaders(tree + "/RedHat/base/hdlist2")
+    showMem()
+    hdrlist.mergePackageDeps(comps.packages)
+    showMem()    
+    groups = GroupSet(comps, hdrlist)
+    showMem()
+
+#    sys.exit(0)
+
+    ts = rpm.TransactionSet("/tmp/testinstall")
+    ts.setVSFlags(-1)
+    ts.setFlags(rpm.RPMTRANS_FLAG_ANACONDA)
+    showMem()
+
+    l = []
+    groups.groups["base"].select()
+    groups.hdrlist["evolution"].select()
+
+    for hdr in groups.hdrlist.pkgs.values():
+        if hdr.isSelected():
+            l.append(hdr)
+            print "going to install %s" %(nevra(hdr),)
+
+    depcheck = DependencyChecker(groups)
+
+    l.sort(packageSort)
+    for h in l:
+        ts.addInstall(h.hdr, h.hdr, "i")
+    foo = ts.check(depcheck.callback)
+
+    print depcheck.added
+    sys.exit(0)
+    ts.run(simpleInstallCallback, 0)
diff --git a/image.py b/image.py
index 836c15a88..050d8589f 100644
--- a/image.py
+++ b/image.py
@@ -11,7 +11,7 @@
 # Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 #
 
-from comps import ComponentSet, HeaderListFromFile
+from hdrlist import groupSetFromCompsFile, HeaderListFromFile
 from installmethod import InstallMethod, FileCopyException
 import iutil
 import os
@@ -31,11 +31,9 @@ class ImageInstallMethod(InstallMethod):
 
     def readCompsViaMethod(self, hdlist):
 	fname = self.findBestFileMatch(self.tree, 'comps.xml')
-	#
-	# XXX - we dont handle case where file wasnt found
-	#       instead we fail down in ComponentSet!!!
-	#
-	return ComponentSet(fname, hdlist)
+        if fname is None:
+            raise FileCopyException
+	return groupSetFromCompsFile(fname, hdlist)
 
     def getFilename(self, h, timer, callback=None):
 	return self.tree + "/RedHat/RPMS/" + h[1000000]
@@ -102,7 +100,7 @@ class CdromInstallMethod(ImageInstallMethod):
 			"%s/RedHat/base/stage2.img" % self.tree)
 	    self.loopbackFile = None
 
-    def systemMounted(self, fsset, chroot, selected):
+    def systemMounted(self, fsset, chroot):
 	self.loopbackFile = "%s%s%s" % (chroot,
                                         fsset.filesystemSpace(chroot)[0][0],
                                         "/rhinstall-stage2.img")
diff --git a/installclass.py b/installclass.py
index 1ddd7af6d..f2884b826 100644
--- a/installclass.py
+++ b/installclass.py
@@ -121,7 +121,6 @@ class BaseInstallClass:
 		 "languagesupport",
 		 "timezone",
 		 "accounts",
-		 "authentication",
 		 "readcomps",
                  "selectlangpackages",
 		 "package-selection",
@@ -142,7 +141,6 @@ class BaseInstallClass:
                  "dopostaction",
 		 "writexconfig",
 		 "writeksconfig",
-		 "bootdisk",
                  "methodcomplete",
 		 "complete"
 		)
@@ -174,7 +172,7 @@ class BaseInstallClass:
         # 'noupgrade' can be used on the command line to force not looking
         # for partitions to upgrade.  useful in some cases...
         cmdline = open("/proc/cmdline", "r").read()
-        if cmdline.find("noupgrade") != -1:
+        if cmdline.find("upgrade") == -1:
             dispatch.skipStep("findrootparts")
 
     # called from anaconda so that we can skip steps in the headless case
@@ -199,33 +197,9 @@ class BaseInstallClass:
     # This is called after the comps is read in (after setPackageSelection()).
     # It can both select groups, change the default selection for groups, and
     # change which groups are hidden.
-    def setGroupSelection(self, comps, intf):
+    def setGroupSelection(self, grpset, intf):
 	pass
 
-    # this is a utility function designed to be called from setGroupSelection()
-    # it hides all of the groups not in the "groups" list
-    def showGroups(self, comps, groups):
-	groupSet = {}
-
-	for group in groups:
-	    if type(group) == type("a"):
-		groupSet[group] = None
-	    else:
-		(group, val) = group
-		groupSet[group] = val
-	    
-	for comp in comps:
-	    if groupSet.has_key(comp.name):
-		comp.hidden = 0
-
-		# do nothing if groupSet[comp.name] == None
-		if groupSet[comp.name] == 1:
-		    comp.select()
-		elif groupSet[comp.name] == 0:
-		    comp.unselect(0)
-	    else:
-		comp.hidden = 1
-
     def getMakeBootdisk(self):
 	return self.makeBootdisk
 
diff --git a/installclasses/personal_desktop.py b/installclasses/personal_desktop.py
index b09cea076..564e4564a 100644
--- a/installclasses/personal_desktop.py
+++ b/installclasses/personal_desktop.py
@@ -27,14 +27,13 @@ class InstallClass(BaseInstallClass):
         dispatch.skipStep("desktopchoice", skip = 0)
         dispatch.skipStep("package-selection", skip = 1)
 
-    def setGroupSelection(self, comps, intf):
-	BaseInstallClass.__init__(self, comps)
+    def setGroupSelection(self, grpset, intf):
+	BaseInstallClass.__init__(self, grpset)
 
-        for comp in comps.comps:
-            comp.unselect()
+        grpset.unselectAll()
 
-        comps["Workstation Common"].includeMembers()
-        comps["GNOME Desktop Environment"].select()
+        grpset.selectGroup("workstation-common", asMeta = 1)
+        grpset.selectGroup("gnome-desktop")
 
     def setInstallData(self, id):
 	BaseInstallClass.setInstallData(self, id)
diff --git a/installclasses/server.py b/installclasses/server.py
index 337a4cd91..df03d304f 100644
--- a/installclasses/server.py
+++ b/installclasses/server.py
@@ -24,12 +24,11 @@ class InstallClass(BaseInstallClass):
 	BaseInstallClass.setSteps(self, dispatch);
 	dispatch.skipStep("authentication")
 
-    def setGroupSelection(self, comps, intf):
-	BaseInstallClass.__init__(self, comps)
+    def setGroupSelection(self, grpset, intf):
+	BaseInstallClass.__init__(self, grpset)
 
-        for comp in comps.comps:
-            comp.unselect()
-	comps["Server"].includeMembers()
+        grpset.unselectAll()
+        grpset.selectGroup("server", asMeta = 1)
 
     def setInstallData(self, id):
 	BaseInstallClass.setInstallData(self, id)
diff --git a/installclasses/workstation.py b/installclasses/workstation.py
index 0733f03f0..89560e751 100644
--- a/installclasses/workstation.py
+++ b/installclasses/workstation.py
@@ -14,12 +14,12 @@ class InstallClass(personal_desktop.InstallClass):
     sortPriority = 2
     showLoginChoice = 0
 
-    def setGroupSelection(self, comps, intf):
-        personal_desktop.InstallClass.setGroupSelection(self, comps, intf)
-        comps["Emacs"].select()
-        comps["GNOME Software Development"].select()
-	comps["X Software Development"].select()
-        comps["Development Tools"].select()
+    def setGroupSelection(self, grpset, intf):
+        personal_desktop.InstallClass.setGroupSelection(self, grpset, intf)
+        grpset.selectGroup("emacs")
+        grpset.selectGroup("gnome-software-development")
+	grpset.selectGroup("x-software-development")
+        grpset.selectGroup("development-tools")
 
     def __init__(self, expert):
 	personal_desktop.InstallClass.__init__(self, expert)
diff --git a/installmethod.py b/installmethod.py
index 28c2008fb..deb449813 100644
--- a/installmethod.py
+++ b/installmethod.py
@@ -13,7 +13,7 @@
 
 import os
 import string
-from comps import ComponentSet
+from hdrlist import groupSetFromCompsFile
 
 from rhpl.log import log
 
@@ -59,7 +59,7 @@ class InstallMethod:
 		    break
 
 	if path:
-	    return ComponentSet(path, hdlist)
+	    return groupSetFromCompsFile(path, hdlist)
 	else:
 	    return self.readCompsViaMethod(hdlist)
 	pass
@@ -88,7 +88,7 @@ class InstallMethod:
     def systemUnmounted(self):
 	pass
 
-    def systemMounted(self, fstab, mntPoint, selected):
+    def systemMounted(self, fstab, mntPoint):
 	pass
 
     def filesDone(self):
diff --git a/instdata.py b/instdata.py
index a1c5da156..a8c7ca9da 100644
--- a/instdata.py
+++ b/instdata.py
@@ -59,8 +59,7 @@ class InstallData:
         self.rootPassword = users.RootPassword ()
 	self.auth = users.Authentication()
 	self.desktop = desktop.Desktop()
-	self.hdList = None
-	self.comps = None
+        self.grpset = None
 	self.upgrade = Boolean()
         # XXX move fsset and/or diskset into Partitions object?
 	self.fsset.reset()
@@ -149,6 +148,7 @@ class InstallData:
 	self.accounts.writeKScommands(f, self.auth)
 
     def writePackagesKS(self, f):
+        return
 	f.write("\n%packages")
         if self.handleDeps == IGNORE_DEPS:
             f.write(" --ignoredeps\n")
diff --git a/isys/vio.c b/isys/vio.c
index a39cf13f2..bad6ac708 100644
--- a/isys/vio.c
+++ b/isys/vio.c
@@ -77,7 +77,7 @@ int vioGetCdDevs(struct knownDevices * devices) {
 
 	    model = alloca((20 + strlen(chptr)) * sizeof(char *));
 	    sprintf(model, "IBM Virtual CD-ROM Model %s", chptr);
-	    snprintf(ctl, 63, "iseries/vcd%d", ctlNum);
+	    snprintf(ctl, 63, "iseries/vcd%c", ctlNum + 'a');
 
 	    if (!deviceKnown(devices, ctl)) {
 	      newDevice.name = strdup(ctl);
diff --git a/iw/package_gui.py b/iw/package_gui.py
index eec70d9c1..30e7d8c36 100644
--- a/iw/package_gui.py
+++ b/iw/package_gui.py
@@ -4,8 +4,9 @@
 # Brent Fox <bfox@redhat.com>
 # Matt Wilson <msw@redhat.com>
 # Jeremy Katz <katzj@redhat.com>
+# Michael Fulbright <msf@redhat.com>
 #
-# Copyright 2000-2002 Red Hat, Inc.
+# Copyright 2000-2003 Red Hat, Inc.
 #
 # This software may be freely redistributed under the terms of the GNU
 # library public license.
@@ -27,9 +28,11 @@ from string import *
 from thread import *
 from examine_gui import *
 from rhpl.translate import _, N_
-from comps import orderPackageGroups, getCompGroupDescription
-from comps import PKGTYPE_MANDATORY, PKGTYPE_DEFAULT, PKGTYPE_OPTIONAL
-from comps import Package, Component
+from hdrlist import orderPackageGroups, getGroupDescription
+from hdrlist import PKGTYPE_MANDATORY, PKGTYPE_DEFAULT, PKGTYPE_OPTIONAL
+from hdrlist import ON, MANUAL_ON, OFF, MANUAL_OFF, MANUAL_NONE
+from hdrlist import ON_STATES, OFF_STATES
+from hdrlist import Package, Group
 from rhpl.log import log
 import packages
 
@@ -49,20 +52,6 @@ class IndividualPackageSelectionWindow (InstallWindow):
     windowTitle = N_("Individual Package Selection")
     htmlTag = "sel-indiv"
 
-    def __init__ (self, ics):
-	InstallWindow.__init__ (self, ics)
-        self.ics = ics
-        self.DIR = 0
-        self.DIR_UP = 1
-        self.RPM = 2
-        self.rownum = 0
-        self.maxrows = 0
-        self.updatingIcons = gtk.FALSE
-
-    def getPrev (self):
-        return None
-    
-
     def build_packagelists(self, groups):
         toplevels = {}
         self.packageGroupStore = gtk.TreeStore(gobject.TYPE_STRING,
@@ -210,7 +199,7 @@ class IndividualPackageSelectionWindow (InstallWindow):
         desc = replace (desc, "\x00", "\n\n")
         return desc
 
-    def make_group_list(self, hdList, comps, displayBase = 0):
+    def make_group_list(self, grpset, displayBase = 0):
         """Go through all of the headers and get group names, placing
            packages in the dictionary.  Also have in the upper level group"""
         
@@ -219,8 +208,8 @@ class IndividualPackageSelectionWindow (InstallWindow):
         # special group for listing all of the packages (aka old flat view)
         groups["allpkgs"] = []
         
-        for key in hdList.packages.keys():
-            header = hdList.packages[key]
+        for key in grpset.hdrlist.pkgs.keys():
+            header = grpset.hdrlist.pkgs[key]
 
             group = header[rpm.RPMTAG_GROUP]
 	    hier = string.split(group, '/')
@@ -235,7 +224,7 @@ class IndividualPackageSelectionWindow (InstallWindow):
                     groups[toplevel] = []
 
             # don't display package if it is in the Base group
-            if not comps["Core"].includesPackage(header) or displayBase:
+            if not grpset.groups["core"].includesPackage(header) or displayBase:
                 groups[group].append(header)
 		if len(hier) > 1:
 		    groups[toplevel].append(header)
@@ -260,7 +249,7 @@ class IndividualPackageSelectionWindow (InstallWindow):
 
 
     def updateSize(self):
-        text = _("Total install size: %s") % (self.comps.sizeStr(),)
+        text = _("Total install size: %s") % (self.grpset.sizeStr(),)
         self.totalSizeLabel.set_text(text)
 
 
@@ -280,7 +269,7 @@ class IndividualPackageSelectionWindow (InstallWindow):
             if not self.allPkgs:
                 self.allPkgs = []
                 for pkg in self.pkgs.values():
-                    if not self.comps["Core"].includesPackage(pkg):
+                    if not self.grpset.groups["core"].includesPackage(pkg):
                         self.allPkgs.append(pkg)
             packages = self.allPkgs
             self.packageTreeView.set_model(gtk.ListStore(gobject.TYPE_STRING))
@@ -328,9 +317,9 @@ class IndividualPackageSelectionWindow (InstallWindow):
 	    
 		
     # IndividualPackageSelectionWindow tag="sel-indiv"
-    def getScreen (self, comps, hdList):
-	self.comps = comps
-        self.pkgs = hdList
+    def getScreen (self, grpset):
+        self.grpset = grpset
+        self.pkgs = self.grpset.hdrlist
         self.allPkgs = None
         
         self.packageTreeView = gtk.TreeView()
@@ -343,7 +332,7 @@ class IndividualPackageSelectionWindow (InstallWindow):
         self.packageTreeView.set_rules_hint(gtk.FALSE)
         self.packageTreeView.set_enable_search(gtk.FALSE)
         
-        self.flat_groups = self.make_group_list(hdList, comps)
+        self.flat_groups = self.make_group_list(grpset)
         self.build_packagelists(self.flat_groups)
 
         selection = self.packageTreeView.get_selection()
@@ -488,7 +477,7 @@ class PackageSelectionWindow (InstallWindow):
         self.files_found = "gtk.FALSE"
         
     def getPrev (self):
-	self.comps.setSelectionState(self.origSelection)
+	self.grpset.setSelectionState(self.origSelection)
 
     def getNext (self):
 	if self.individualPackages.get_active():
@@ -504,7 +493,7 @@ class PackageSelectionWindow (InstallWindow):
 
     def setSize(self):
         self.sizelabel.set_text (_("Total install size: %s") % 
-					self.comps.sizeStr())
+					self.grpset.sizeStr())
 
     # given a value, set all components except Everything and Base to
     # that value.  Handles restoring state if it exists
@@ -512,13 +501,13 @@ class PackageSelectionWindow (InstallWindow):
 	tmpval = self.ignoreComponentToggleEvents
 	self.ignoreComponentToggleEvents = 1
 	for (cb, lbl, al, ebutton, cbox, cbox2, cbcomp) in self.checkButtons:
-	    if cbcomp.name == comp.name:
+	    if cbcomp.id == comp.id:
 		continue
 
 	    if value:
-		if cbcomp.name not in [u"Everything", u"Base"]:
+		if cbcomp.id not in ["everything", "base"]:
 #		    print "restoring checkbutton for ",cbcomp.name," at state ",self.savedStateDict[cbcomp.name]
-		    if self.savedStateFlag and self.savedStateDict[cbcomp.name]:
+		    if self.savedStateFlag and self.savedStateDict[cbcomp.id]:
 			cb.set_active(1)
 		    else:
 			cb.set_active(0)
@@ -565,16 +554,15 @@ class PackageSelectionWindow (InstallWindow):
 
 	    # dont turn off Base, and if we're turning off everything
 	    # we need to be sure language support stuff is on
-	    if comp.name != u"Base":
+	    if comp.id != "base":
 		comp.unselect ()
-		if comp.name == u"Everything":
-		    packages.selectLanguageSupportGroups(self.comps, self.langSupport)
+		if comp.id == "everything":
+		    packages.selectLanguageSupportGroups(self.grpset, self.langSupport)
 
         if count:
             self.setCompCountLabel(comp, count)
 
-        ### XXX - need to i18n??
-        if comp.name == u"Everything" or comp.name == u"Base":
+        if comp.id == "everything" or comp.id == "base":
 	    
 	    self.ignoreComponentToggleEvents = 1
 	    # save state of buttons if they hit everything or minimal
@@ -586,25 +574,25 @@ class PackageSelectionWindow (InstallWindow):
 	    else:
 		savestate = 0
 
-	    for c in self.comps:
-		if c.name in [u"Everything", u"Base"]:
+	    for c in self.grpset.groups.values():
+		if c.id in ["everything", "base"]:
 		    continue
 		
 		if newstate:
 			sel = c.isSelected()			
 #			print "saving ",c.name," at state ",sel
 			if savestate:
-			    self.savedStateDict[c.name] = sel
+			    self.savedStateDict[c.id] = sel
 			if sel:
 			    c.unselect()
 		else:
 #		    print "restoring ",c.name," at state ",self.savedStateDict[c.name]
-		    if self.savedStateFlag and self.savedStateDict[c.name]:
+		    if self.savedStateFlag and self.savedStateDict[c.id]:
 			c.select()
 
 	    # turn on lang support if we're minimal and enabling
-	    if comp.name == u"Base" and newstate:
-		packages.selectLanguageSupportGroups(self.comps, self.langSupport)
+	    if comp.id == "base" and newstate:
+		packages.selectLanguageSupportGroups(self.grpset, self.langSupport)
 
 	    self.setComponentsSensitive(comp, not newstate)
 
@@ -619,48 +607,34 @@ class PackageSelectionWindow (InstallWindow):
 
     def pkgGroupMemberToggled(self, widget, data):
 	(comp, sizeLabel, pkg) = data
-	(ptype, sel) = self.getFullInfo(pkg, comp)
+	(ptype, sel) = comp.packageInfo()[pkg]
 
 	# dont select or unselect if its already in that state
 	if widget.get_active():
-	    if not sel:
-		if ptype == PKGTYPE_OPTIONAL:
-		    comp.selectOptionalPackage(pkg)
-		else:
-		    log("Got callback with mandatory pkg %s!!", pkg.name)
+            if sel not in ON_STATES:
+                comp.selectPackage(pkg)
 	    else:
-		log("already selected, not selecting!")
+		log("%s already selected, not selecting!" %(pkg,))
 	else:
-	    if sel:
-		if ptype == PKGTYPE_OPTIONAL:
-		    comp.unselectOptionalPackage(pkg)
-		else:
-		    log("Got callback with mandatory pkg %s!!", pkg.name)
+            if sel in ON_STATES:
+                comp.unselectPackage(pkg)
 	    else:
-		log("already unselected, not unselecting!")
+		log("%s already unselected, not unselecting!" %(pkg,))
 
 	if sizeLabel:
 	    self.setDetailSizeLabel(comp, sizeLabel)
 
-    def getFullInfo(self, obj, comp):
-	if isinstance(obj, Package):
-	    return comp.packagesFullInfo()[obj]
-	elif isinstance(obj, Component):
-	    return comp.metapackagesFullInfo()[obj]
-	else:
-	    return None
-
     # have to do magic to handle 'Minimal'
     def setCheckButtonState(self, cb, comp):
 	state = 0
-	if comp.name != u"Base":
+	if comp.id != "base":
 	    state = comp.isSelected(justManual = 1)	    
 	    cb.set_active (state)
 	else:
 	    state = 1
-	    for c in self.comps:
+	    for c in self.grpset.groups.values():
 		# ignore base and langsupport files pulled in by 'minimal'
-		if c.name == u"Base" or self.comps.compsxml.groups[c.name].langonly is not None:
+		if c.id == "base" or self.grpset.groups[c.id].langonly is not None:
 		    continue
 		
 		if c.isSelected(justManual = 1):
@@ -672,10 +646,12 @@ class PackageSelectionWindow (InstallWindow):
 	return state
 	
     def getStats(self, comp):
-	allpkgs = comp.packagesFullInfo().keys() + comp.metapackagesFullInfo().keys()
+        # FIXME: metapkgs
+#	allpkgs = comp.packageInfo().keys() + comp.metapackagesFullInfo().keys()
+	allpkgs = comp.packageInfo()
 	
-	if comp.name == u"Everything":
-	    total = len(allpkgs)
+	if comp.id == "everything":
+	    total = len(allpkgs.keys())
 	    if comp.isSelected(justManual = 1):
 		selected = total
 	    else:
@@ -684,23 +660,23 @@ class PackageSelectionWindow (InstallWindow):
 	
 	total = 0
 	selected = 0
-	for pkg in allpkgs:
+	for pkg in allpkgs.values():
 	    total = total + 1
-	    (ptype, sel) = self.getFullInfo(pkg, comp)
-	    if sel:
+	    (ptype, sel) = pkg
+            if sel in ON_STATES:
 		selected = selected + 1
 
         return (selected, total)
 
     def setDetailSizeLabel(self, comp, sizeLabel):
-        text = _("Total install size: %s") % (self.comps.sizeStr(),)
+        text = _("Total install size: %s") % (self.grpset.sizeStr(),)
 	sizeLabel.set_text(text)
 
     def setCompLabel(self, comp, label):
-	if comp.name == u"Base":
+        if comp.id == "base":
 	    nm = _("Minimal")
 	else:
-	    nm = comp.displayName
+	    nm = comp.name
 	label.set_markup("<b>%s</b>" % (nm,))
 
     def setCompCountLabel(self, comp, label):
@@ -708,7 +684,7 @@ class PackageSelectionWindow (InstallWindow):
         if not comp.isSelected(justManual = 1):
             selpkg = 0
 
-	if comp.name == u"Everything" or comp.name == u"Base":
+	if comp.id == "everything" or comp.id == "base":
 	    txt = ""
 	else:
 	    txt = "<b>[%d/%d]</b>" % (selpkg, totpkg)
@@ -716,15 +692,13 @@ class PackageSelectionWindow (InstallWindow):
 	label.set_markup(txt)
 
     def editDetails(self, button, data):
-
 	# do all magic for packages and metapackages
 	def getDescription(obj, comp):
-	    if isinstance(obj, Package):
-		basedesc = obj.h[rpm.RPMTAG_SUMMARY]
-	    elif isinstance(obj, Component):
-		basedesc = getCompGroupDescription(obj)
-	    else:
-		return None
+            if self.grpset.hdrlist.pkgs.has_key(obj):
+                obj = self.grpset.hdrlist.pkgs[obj]
+            elif self.grpset.groups.has_key(obj):
+                obj = self.grpset.groups[obj]
+            basedesc = obj.getDescription()
 
 	    if basedesc is not None:
 		desc = replace (basedesc, "\n\n", "\x00")
@@ -738,15 +712,14 @@ class PackageSelectionWindow (InstallWindow):
 	def getNextMember(goodpkgs, comp, domandatory = 0):
 	    curpkg = None
 	    for pkg in goodpkgs:
-
 		if domandatory:
-		    (ptype, sel) = self.getFullInfo(pkg, comp)
+		    (ptype, sel) = comp.packageInfo()[pkg]
 		    if ptype != PKGTYPE_MANDATORY:
 			continue
 
 		foundone = 1
 		if curpkg is not None:
-		    if pkg.name < curpkg.name:
+		    if pkg < curpkg:
 			curpkg = pkg
 		else:
 		    curpkg = pkg
@@ -760,16 +733,10 @@ class PackageSelectionWindow (InstallWindow):
 	# backup state
 	(comp, hdrlbl, countlbl, compcb) = data
 	origpkgselection = {}
-	for pkg in comp.packagesFullInfo().keys():
-	    val = comp.packagesFullInfo()[pkg]
+	for (pkg, val) in comp.packageInfo().items():
 	    origpkgselection[pkg] = val
 	    
-	origmetapkgselection = {}
-	for pkg in comp.metapackagesFullInfo().keys():
-	    val = comp.metapackagesFullInfo()[pkg]
-	    origmetapkgselection[pkg] = val
-	
-        self.dialog = gtk.Dialog(_("Details for '%s'") % (comp.displayName,))
+        self.dialog = gtk.Dialog(_("Details for '%s'") % (comp.name,))
         gui.addFrame(self.dialog)
         self.dialog.add_button('gtk-cancel', 2)
         self.dialog.add_button('gtk-ok', 1)
@@ -810,8 +777,10 @@ class PackageSelectionWindow (InstallWindow):
         sizeLabel = gtk.Label("")
 	self.setDetailSizeLabel(comp, sizeLabel)
 
-	
-        goodpkgs = comp.packagesFullInfo().keys() + comp.metapackagesFullInfo().keys()
+        goodpkgs = comp.packageInfo().keys()
+        # FIXME
+#        goodpkgs = comp.packagesFullInfo().keys() + comp.metapackagesFullInfo().keys()
+
 
 	# first show default members, if any
 	haveBase = 0
@@ -865,8 +834,8 @@ class PackageSelectionWindow (InstallWindow):
 		lbl.set_property("use-underline", gtk.FALSE)
 		cb = gtk.CheckButton()
 		cb.add(lbl)
-		(ptype, sel) = self.getFullInfo(next, comp)
-		cb.set_active(sel)
+		(ptype, sel) = comp.packageInfo()[next]
+		cb.set_active((sel in ON_STATES))
 		cb.connect("toggled", self.pkgGroupMemberToggled,
 			   (comp, sizeLabel, next))
 
@@ -903,31 +872,17 @@ class PackageSelectionWindow (InstallWindow):
 
 	    # they hit cancel, restore original state and quit
 	    if rc == 2:
-		allpkgs = comp.packagesFullInfo().keys()
+		allpkgs = comp.packageInfo().keys()
 		for pkg in allpkgs:
-		    (ptype, sel) = comp.packagesFullInfo()[pkg]
+		    (ptype, sel) = comp.packageInfo()[pkg]
 		    (optype, osel) = origpkgselection[pkg]
 
-		    if ptype == PKGTYPE_OPTIONAL:
-			if osel:
-			    if not sel:
-				comp.selectOptionalPackage(pkg)
-			else:
-			    if sel:
-				comp.unselectOptionalPackage(pkg)
-		allpkgs = comp.metapackagesFullInfo().keys()
-		for pkg in allpkgs:
-		    (ptype, sel) = comp.metapackagesFullInfo()[pkg]
-		    (optype, osel) = origmetapkgselection[pkg]
-
-		    if ptype == PKGTYPE_OPTIONAL:
-			if osel:
-			    if not sel:
-				comp.selectOptionalPackage(pkg)
-			else:
-			    if sel:
-				comp.unselectOptionalPackage(pkg)
-
+                    if (osel == sel):
+                        pass
+                    elif (osel not in OFF_STATES) and (sel not in ON_STATES):
+                        comp.selectPackage(pkg)
+                    elif (osel not in ON_STATES) and (sel not in OFF_STATES):
+                        comp.unselectPackage(pkg)
 	    break
 	
         self.dialog.destroy()
@@ -965,16 +920,16 @@ class PackageSelectionWindow (InstallWindow):
 	
 	
 
-    def getScreen(self, comps, langSupport, instClass, dispatch):
+    def getScreen(self, grpset, langSupport, instClass, dispatch):
 
     # PackageSelectionWindow tag="sel-group"
         ICON_SIZE = 32
         
-	self.comps = comps
+	self.grpset = grpset
 	self.langSupport = langSupport
 	self.dispatch = dispatch
 
-	self.origSelection = self.comps.getSelectionState()
+	self.origSelection = self.grpset.getSelectionState()
 
         self.checkButtons = []
 
@@ -983,7 +938,7 @@ class PackageSelectionWindow (InstallWindow):
 	self.savedStateFlag = 0
 	self.ignoreComponentToggleEvents = 0
 
-	(parlist, pardict) = orderPackageGroups(self.comps)
+	(parlist, pardict) = orderPackageGroups(self.grpset)
 
         topbox = gtk.VBox(gtk.FALSE, 3)
         topbox.set_border_width(3)
@@ -1015,7 +970,7 @@ class PackageSelectionWindow (InstallWindow):
 
 	    for comp in pardict[par]:
 		if comp.hidden:
-		    if comp.name != u"Base":
+                    if comp.id != "base":
 			continue
 		    else:
 			if not instClass.showMinimal:
@@ -1065,7 +1020,7 @@ class PackageSelectionWindow (InstallWindow):
                 compbox.pack_start(buttonal, gtk.FALSE, gtk.FALSE)
 
 		# now make the url looking button for details
-		if comp.name != u"Everything" and comp.name != u"Base":
+		if comp.id != "everything" and comp.id != "base":
 		    nlbl = gtk.Label("")
                     selected = comp.isSelected(justManual = 1)
                     nlbl.set_markup('<span foreground="#3030c0"><u>'
@@ -1095,7 +1050,7 @@ class PackageSelectionWindow (InstallWindow):
                     detailbox.pack_start(al, gtk.FALSE, gtk.FALSE, 10)
                     
 		# add description if it exists
-		descr = getCompGroupDescription(comp)
+		descr = getGroupDescription(comp)
 		if descr is not None:
 		    label=gtk.Label("")
 		    label.set_alignment (0.0, 0.0)
@@ -1112,11 +1067,11 @@ class PackageSelectionWindow (InstallWindow):
                 topbox.pack_start(detailbox)
 
 		state = self.setCheckButtonState(checkButton, comp)
-		if comp.name == u"Base":
+                if comp.id == "base":
 		    minimalActive = state
 		    minimalComp = comp
 		    minimalCB = checkButton
-		elif comp.name == u"Everything":
+		elif comp.id == "everything":
 		    everythingActive = state
 		    everythingComp = comp
 		    everythingCB = checkButton
@@ -1166,7 +1121,7 @@ class PackageSelectionWindow (InstallWindow):
 		_("_Select individual packages"))
         self.individualPackages.set_active (
 		not dispatch.stepInSkipList("indivpackage"))
-        hbox.pack_start (self.individualPackages, gtk.FALSE)
+#        hbox.pack_start (self.individualPackages, gtk.FALSE)
 
         self.sizelabel = gtk.Label ("")
         self.setSize()
diff --git a/kickstart.py b/kickstart.py
index 4391c6402..4e2b11fc3 100644
--- a/kickstart.py
+++ b/kickstart.py
@@ -1192,9 +1192,6 @@ class KickstartBase(BaseInstallClass):
     # Note that this assumes setGroupSelection() is called after
     # setPackageSelection()
     def setPackageSelection(self, hdlist, intf):
-	for pkg in hdlist.keys():
-	    hdlist[pkg].setState((0, 0))
-
 	for n in self.packageList:
             if hdlist.has_key(n):
                 hdlist[n].select()
@@ -1216,35 +1213,35 @@ class KickstartBase(BaseInstallClass):
                     pass
                                 
 
-    def setGroupSelection(self, comps, intf):
-	for comp in comps:
-	    comp.unselect()
+    def setGroupSelection(self, grpset, intf):
+        grpset.unselectAll()
 
-	comps['Base'].select()
+	grpset.selectGroup("base")
 	for n in self.groupList:
-            if comps.has_key(n):
-                comps[n].select()
-            elif self.handleMissing == KS_MISSING_IGNORE:
-                log("group %s doesn't exist, ignoring" %(n,))
-            else:
-                rc = intf.messageWindow(_("Missing Group"),
-                                        _("You have specified that the "
-                                          "group '%s' should be installed.  "
-                                          "This group does not exist. "
-                                          "Would you like to continue or "
-                                          "abort your installation?") %(n,),
-                                        type="custom",
-                                        custom_buttons=[_("_Abort"),
-                                                        _("_Continue")])
-                if rc == 0:
-                    sys.exit(1)
+            try:
+                grpset.selectGroup(n)
+            except KeyError:
+                if self.handleMissing == KS_MISSING_IGNORE:
+                    log("group %s doesn't exist, ignoring" %(n,))
                 else:
-                    pass
+                    rc = intf.messageWindow(_("Missing Group"),
+                                            _("You have specified that the "
+                                              "group '%s' should be installed.  "
+                                              "This group does not exist. "
+                                              "Would you like to continue or "
+                                              "abort your installation?")
+                                            %(n,),
+                                            type="custom",
+                                            custom_buttons=[_("_Abort"),
+                                                            _("_Continue")])
+                    if rc == 0:
+                        sys.exit(1)
+                    else:
+                        pass
                 
-
         for n in self.excludedList:
-            if comps.packages.has_key(n):
-                comps.packages[n].unselect()
+            if grpset.hdrlist.has_key(n):
+                grpset.hdrlist[n].unselect(isManual = 1)
             else:
                 log("%s does not exist, can't exclude" %(n,))
 
diff --git a/loader2/init.c b/loader2/init.c
index a5341f7fb..8b572baba 100644
--- a/loader2/init.c
+++ b/loader2/init.c
@@ -97,6 +97,7 @@ char * env[] = {
 int testing=0;
 void unmountFilesystems(void);
 void disableSwap(void);
+struct termios ts;
 
 int mystrstr(char *str1, char *str2) {
     char *p;
@@ -164,9 +165,9 @@ int hasNetConfiged(void) {
     struct ifconf configs;
     struct ifreq devs[10];
 
-    #ifdef __i386__
-	return 0;
-    #endif
+#ifdef __i386__
+    return 0;
+#endif
 
     s = socket(AF_INET, SOCK_STREAM, 0);
     if (s < 0) {
@@ -434,11 +435,20 @@ int copyDirectory(char * from, char * to) {
     return 0;
 }
 
+void sigintHandler(int signum)
+{
+    /* reset terminal */
+    tcsetattr(0, TCSANOW, &ts);
+    /* Shift in, default color, move down 100 lines */
+    /* ^O        ^[[0m          ^[[100E */
+    printf("\017\033[0m\033[100E\n");
+    shutDown(0, 1);
+}
 
 int main(int argc, char **argv) {
     pid_t installpid, childpid;
     int waitStatus;
-    int fd;
+    int fd; 
     int doReboot = 0;
     int doShutdown =0;
     int isSerial = 0;
@@ -450,7 +460,6 @@ int main(int argc, char **argv) {
     char buf[500];
     int len;
 
-
 #if !defined(__s390__) && !defined(__s390x__)
     testing = (getppid() != 0) && (getppid() != 1);
 #endif
@@ -483,9 +492,6 @@ int main(int argc, char **argv) {
     }
     printf("done\n");
 
-    signal(SIGINT, SIG_IGN);
-    signal(SIGTSTP, SIG_IGN);
-
     /* these args are only for testing from commandline */
     for (i = 1; i < argc; i++) {
 	if (!strcmp (argv[i], "serial")) {
@@ -551,6 +557,13 @@ int main(int argc, char **argv) {
     dup2(0, 2);
 #endif
 
+    /* disable Ctrl+Z, Ctrl+C, etc */
+    tcgetattr(0, &ts);
+    ts.c_iflag &= ~BRKINT;
+    ts.c_iflag |= IGNBRK;
+    ts.c_iflag &= ~ISIG;
+    tcsetattr(0, TCSANOW, &ts);
+
     setsid();
     if (ioctl(0, TIOCSCTTY, NULL)) {
 	printf("could not set new controlling tty\n");
@@ -613,6 +626,23 @@ int main(int argc, char **argv) {
 	exit(0);
     }
 
+    /* set up the ctrl+alt+delete handler to kill our pid, not pid 1 */
+    signal(SIGINT, sigintHandler);
+    if ((fd = open("/proc/sys/kernel/cad_pid", O_WRONLY)) != -1) {
+	char buf[7];
+	int count;
+	sprintf(buf, "%d", getpid());
+	count = write(fd, buf, strlen(buf));
+	close(fd);
+	/* if we succeeded in writing our pid, turn off the hard reboot
+	   ctrl-alt-del handler */
+	if (count == strlen(buf) &&
+	    (fd = open("/proc/sys/kernel/ctrl-alt-del", O_WRONLY)) != -1) {
+	    write(fd, "0", 1);
+	    close(fd);
+	}
+    }
+    
     while (!doShutdown) {
 	childpid = wait4(-1, &waitStatus, 0, NULL);
 
diff --git a/loader2/linuxrc.s390 b/loader2/linuxrc.s390
index a3dfc2a2f..df964865d 100644
--- a/loader2/linuxrc.s390
+++ b/loader2/linuxrc.s390
@@ -367,6 +367,15 @@ HOME=$HOME
 PYTHONPATH=$PYTHONPATH
 EOF
 
+cat >> /etc/profile <<EOF
+LD_LIBRARY_PATH=$LD_LIBRARY_PATH
+PATH=$PATH
+HOME=$HOME
+PYTHONPATH=$PYTHONPATH
+export LD_LIBRARY_PATH PATH HOME PYTHONPATH
+EOF
+
+
 if [ "$NETTYPE" = "ctc" ]; then
    echo "REMIP=$GATEWAY" >> /tmp/netinfo 
    echo "export REMIP=$GATEWAY" >> /etc/profile
diff --git a/loader2/loader.c b/loader2/loader.c
index a44c99119..2882785c3 100644
--- a/loader2/loader.c
+++ b/loader2/loader.c
@@ -1058,7 +1058,7 @@ int main(int argc, char ** argv) {
     checkForRam(flags);
 
     
-    mlLoadModuleSet("cramfs:vfat:nfs:loop:isofs", modLoaded, modDeps, 
+    mlLoadModuleSet("cramfs:vfat:nfs:loop:isofs:floppy", modLoaded, modDeps, 
                     modInfo, flags);
 
     /* now let's do some initial hardware-type setup */
diff --git a/loader2/net.c b/loader2/net.c
index 0e4fc1925..d8c6d1bcb 100644
--- a/loader2/net.c
+++ b/loader2/net.c
@@ -314,7 +314,7 @@ int readNetConfig(char * device, struct networkDeviceConfig * cfg, int flags) {
 
         if (!cfg->noDns)
             writeResolvConf(cfg);
-        return 0;
+        return LOADER_NOOP;
     }        
 
     text = newtTextboxReflowed(-1, -1, 
@@ -489,12 +489,7 @@ int readNetConfig(char * device, struct networkDeviceConfig * cfg, int flags) {
         writeResolvConf(cfg);
     }
 
-    /* JKFIXME: this is a hack */
-#if !defined(__s390__) && !defined(__s390x__)
     return 0;
-#else
-    return LOADER_NOOP;
-#endif
 }
 
 int configureNetwork(struct networkDeviceConfig * dev) {
@@ -803,7 +798,7 @@ int kickstartNetworkUp(struct knownDevices * kd,
     setupNetworkDeviceConfig(netCfgPtr, loaderData, flags);
 
     rc = readNetConfig(loaderData->netDev, netCfgPtr, flags);
-    if (rc) {
+    if ((rc == LOADER_BACK) || (rc == LOADER_ERROR)) {
         logMessage("unable to setup networking");
         return -1;
     }
diff --git a/packages.py b/packages.py
index ec1274b48..49362b18f 100644
--- a/packages.py
+++ b/packages.py
@@ -4,7 +4,7 @@
 # Erik Troan <ewt@redhat.com>
 # Matt Wilson <msw@redhat.com>
 # Michael Fulbright <msf@redhat.com>
-# Jeremy Katzj <katzj@redhat.com>
+# Jeremy Katz <katzj@redhat.com>
 #
 # Copyright 2001-2003 Red Hat, Inc.
 #
@@ -32,7 +32,7 @@ from flags import flags
 from product import *
 from constants import *
 from syslogd import syslog
-from comps import PKGTYPE_MANDATORY, PKGTYPE_DEFAULT
+from hdrlist import PKGTYPE_MANDATORY, PKGTYPE_DEFAULT, DependencyChecker
 from installmethod import FileCopyException
 
 from rhpl.log import log
@@ -130,10 +130,17 @@ def writeXConfiguration(id, instPath):
     id.desktop.write(instPath)
 
 def readPackages(intf, method, id):
-    while id.hdList is None:
+    if id.grpset:
+        grpset = id.grpset
+        hdrlist = idr.grpset.hdrlist
+    else:
+        grpset = None
+        hdrlist = None
+        
+    while hdrlist is None:
 	w = intf.waitWindow(_("Reading"), _("Reading package information..."))
         try:
-            id.hdList = method.readHeaders()
+            hdrlist = method.readHeaders()
         except FileCopyException:
             w.pop()
             method.unmountCD()
@@ -144,11 +151,11 @@ def readPackages(intf, method, id):
             continue
 
         w.pop()
-        id.instClass.setPackageSelection(id.hdList, intf)
+        id.instClass.setPackageSelection(hdrlist, intf)
 
-    while id.comps is None:
+    while grpset is None:
         try:
-            id.comps = method.readComps(id.hdList)
+            grpset = method.readComps(hdrlist)
         except FileCopyException:
             method.unmountCD()            
             intf.messageWindow(_("Error"),
@@ -156,12 +163,9 @@ def readPackages(intf, method, id):
                                  "due to a missing file or bad media.  "
                                  "Press <return> to try again."))
             continue
-        id.instClass.setGroupSelection(id.comps, intf)
+        id.instClass.setGroupSelection(grpset, intf)
+    id.grpset = grpset
 
-    else:
-	# re-evaluate all the expressions for packages with qualifiers.
-
-	id.comps.updateSelections()
 
 def handleX11Packages(dir, intf, disp, id, instPath):
 
@@ -173,8 +177,8 @@ def handleX11Packages(dir, intf, disp, id, instPath):
     # uncomment this block if you want X configuration to be presented
     #
 # START BLOCK
-#     if (not id.comps.packages.has_key('XFree86') or
-#         not id.comps.packages['XFree86'].selected):
+#     if (not id.grpset.hdrlist.has_key('XFree86') or
+#         not id.grpset.hdrlist['XFree86'].isSelected()):
 #         disp.skipStep("videocard")
 #         disp.skipStep("monitor")
 #         disp.skipStep("xcustom")
@@ -191,10 +195,10 @@ def handleX11Packages(dir, intf, disp, id, instPath):
 # END BLOCK
 
     # set default runlevel based on packages
-    gnomeSelected = (id.comps.packages.has_key('gnome-session')
-                     and id.comps.packages['gnome-session'].selected)
-    kdeSelected = (id.comps.packages.has_key('kdebase')
-                   and id.comps.packages['kdebase'].selected)
+    gnomeSelected = (id.grpset.hdrlist.has_key('gnome-session')
+                     and id.grpset.hdrlist['gnome-session'].isSelected())
+    kdeSelected = (id.grpset.hdrlist.has_key('kdebase')
+                   and id.grpset.hdrlist['kdebase'].isSelected())
 
     if gnomeSelected:
         id.desktop.setDefaultDesktop("GNOME")
@@ -220,28 +224,6 @@ def setSaneXSettings(xsetup):
 	    xsetup.xhwstate.choose_sane_default()
 	    xsetup.imposed_sane_default = 1
 	    
-
-def checksig(fileName):
-    # RPM spews to stdout/stderr.  Redirect.
-    # stolen from up2date/up2date.py
-    saveStdout = os.dup(1)
-    saveStderr = os.dup(2)
-    redirStdout = os.open("/dev/null", os.O_WRONLY | os.O_APPEND)
-    redirStderr = os.open("/dev/null", os.O_WRONLY | os.O_APPEND)
-    os.dup2(redirStdout, 1)
-    os.dup2(redirStderr, 2)
-    # now do the rpm thing
-    ret = rpm.checksig(fileName, rpm.CHECKSIG_MD5)
-    # restore normal stdout and stderr
-    os.dup2(saveStdout, 1)
-    os.dup2(saveStderr, 2)
-    # Clean up
-    os.close(redirStdout)
-    os.close(redirStderr)
-    os.close(saveStdout)
-    os.close(saveStderr)
-    return ret    
-
 def checkDependencies(dir, intf, disp, id, instPath):
     if dir == DISPATCH_BACK:
 	return
@@ -249,16 +231,34 @@ def checkDependencies(dir, intf, disp, id, instPath):
     win = intf.waitWindow(_("Dependency Check"),
       _("Checking dependencies in packages selected for installation..."))
 
-    id.dependencies = id.comps.verifyDeps(instPath, id.upgrade.get())
+    # FIXME: we really don't need to build up a ts more than once
+    # granted, this is better than before still
+    if id.upgrade.get():
+        ts = rpm.TransactionSet(instPath)
+        how = "u"
+    else:
+        ts = rpm.TransactionSet()
+        how = "i"
+    ts.setVSFlags(-1)
+    ts.setFlags(rpm.RPMTRANS_FLAG_ANACONDA)
+    
+    for p in id.grpset.hdrlist.pkgs.values():
+        if p.isSelected():
+            ts.addInstall(p.hdr, p.hdr, how)
+    depcheck = DependencyChecker(id.grpset, how)
+    id.dependencies = ts.check(depcheck.callback)
 
     win.pop()
 
-    if (id.dependencies and id.comps.canResolveDeps(id.dependencies)
-        and id.handleDeps == CHECK_DEPS):
+    if id.dependencies and id.handleDeps == CHECK_DEPS:
 	disp.skipStep("dependencies", skip = 0)
+        log("FIXME: had dependency problems.  resolved them without informing the user")
+	disp.skipStep("dependencies")
     else:
 	disp.skipStep("dependencies")
 
+    return
+    # FIXME: I BROKE IT
     # this is kind of hackish, but makes kickstart happy
     if id.handleDeps == CHECK_DEPS:
         pass
@@ -269,36 +269,6 @@ def checkDependencies(dir, intf, disp, id, instPath):
         id.comps.selectDepCause(id.dependencies)        
         id.comps.selectDeps(id.dependencies)
 
-#XXX
-#try:
-    #self.todo.getHeaderList ()
-    #self.todo.getCompsList()
-    #self.files_found = "TRUE"
-#except ValueError, msg:
-    #extra = msg
-#except RuntimeError, msg:
-    #extra = msg
-#except TypeError, msg:
-    #extra = msg
-#except KeyError, key:
-    #extra = ("The comps file references a package called \"%s\" which "
-	     #"could not be found." % (key,))
-#except:
-    #extra = ""
-#
-#if self.files_found == "FALSE":
-    #if extra:
-	#text = (_("The following error occurred while "
-		  #"retreiving hdlist file:\n\n"
-		  #"%s\n\n"
-		  #"Installer will exit now.") % extra)
-    #else:
-	#text = (_("An error has occurred while retreiving the hdlist "
-		  #"file.  The installation media or image is "
-		  #"probably corrupt.  Installer will exit now."))
-    #win = ErrorWindow (text)
-#else:
-
 class InstallCallback:
     def packageDownloadCB(self, state,  amount):
 	self.progress.setPackageStatus(state, amount)
@@ -536,7 +506,7 @@ def doPreInstall(method, id, intf, instPath, dir):
     arch = iutil.getArch ()
 
     # this is a crappy hack, but I don't want bug reports from these people
-    if (arch == "i386") and (not id.hdList.has_key("kernel")):
+    if (arch == "i386") and (not id.grpset.hdrlist.has_key("kernel")):
         intf.messageWindow(_("Error"),
                            _("You are trying to install on a machine "
                              "which isn't supported by this release of "
@@ -548,68 +518,66 @@ def doPreInstall(method, id, intf, instPath, dir):
     # shorthand
     upgrade = id.upgrade.get()
 
-    def select(hdList, name):
-        if hdList.has_key(name):
-            hdList[name].selected = 1
+    def select(hdrlist, name):
+        if hdrlist.has_key(name):
+            hdrlist[name].select(isManual = 1)
 
     if not upgrade:
 	# this is NICE and LATE. It lets kickstart/server/workstation
 	# installs detect this properly
         if arch == "s390":
 	    if (string.find(os.uname()[2], "tape") > -1):
-		select(id.hdList, 'kernel-tape')
+		select(id.grpset.hdrlist, 'kernel-tape')
         elif arch == "ppc" and iutil.getPPCMachine() == "pSeries":
-            select(id.hdList, 'kernel-pseries')
+            select(id.grpset.hdrlist, 'kernel-pseries')
         elif arch == "ppc" and iutil.getPPCMachine() == "iSeries":
-            select(id.hdList, "kernel-iseries")
+            select(id.grpset.hdrlist, "kernel-iseries")
                 
 	if isys.smpAvailable() or isys.htavailable():
-            select(id.hdList, 'kernel-smp')
+            select(id.grpset.hdrlist, 'kernel-smp')
 
-	if (id.hdList.has_key('kernel-bigmem')):
-	    if iutil.needsEnterpriseKernel():
-		id.hdList['kernel-bigmem'].selected = 1
+        if iutil.needsEnterpriseKernel():
+            select(id.grpset.hdrlist, "kernel-bigmem")
 
-	if (id.hdList.has_key('kernel-summit')):
-	    if isys.summitavailable():
-		id.hdList['kernel-summit'].selected = 1
+        if isys.summitavailable():
+            select(id.grpset.hdrlist, "kernel-summit")
 
 	# we *always* need a kernel installed
-        select(id.hdList, 'kernel')
+        select(id.grpset.hdrlist, 'kernel')
 
 	# if NIS is configured, install ypbind and dependencies:
 	if id.auth.useNIS:
-            select(id.hdList, 'ypbind')
-            select(id.hdList, 'yp-tools')
-            select(id.hdList, 'portmap')
+            select(id.grpset.hdrlist, 'ypbind')
+            select(id.grpset.hdrlist, 'yp-tools')
+            select(id.grpset.hdrlist, 'portmap')
 
 	if id.auth.useLdap:
-            select(id.hdList, 'nss_ldap')
-            select(id.hdList, 'openldap')
-            select(id.hdList, 'perl')
+            select(id.grpset.hdrlist, 'nss_ldap')
+            select(id.grpset.hdrlist, 'openldap')
+            select(id.grpset.hdrlist, 'perl')
 
 	if id.auth.useKrb5:
-            select(id.hdList, 'pam_krb5')
-            select(id.hdList, 'krb5-workstation')
-            select(id.hdList, 'krbafs')
-            select(id.hdList, 'krb5-libs')
+            select(id.grpset.hdrlist, 'pam_krb5')
+            select(id.grpset.hdrlist, 'krb5-workstation')
+            select(id.grpset.hdrlist, 'krbafs')
+            select(id.grpset.hdrlist, 'krb5-libs')
 
         if id.auth.useSamba:
-            select(id.hdList, 'pam_smb')
+            select(id.grpset.hdrlist, 'pam_smb')
 
         if iutil.getArch() == "i386" and id.bootloader.useGrubVal == 0:
-            select(id.hdList, 'lilo')
+            select(id.grpset.hdrlist, 'lilo')
         elif iutil.getArch() == "i386" and id.bootloader.useGrubVal == 1:
-            select(id.hdList, 'grub')
+            select(id.grpset.hdrlist, 'grub')
         elif iutil.getArch() == "s390":
-            select(id.hdList, 's390utils')
+            select(id.grpset.hdrlist, 's390utils')
         elif iutil.getArch() == "ppc":
-            select(id.hdList, 'yaboot')
+            select(id.grpset.hdrlist, 'yaboot')
         elif iutil.getArch() == "ia64":
-            select(id.hdList, 'elilo')
+            select(id.grpset.hdrlist, 'elilo')
 
         if pcmcia.pcicType():
-            select(id.hdList, 'kernel-pcmcia-cs')
+            select(id.grpset.hdrlist, 'kernel-pcmcia-cs')
 
     if flags.test:
 	return
@@ -619,7 +587,7 @@ def doPreInstall(method, id, intf, instPath, dir):
     # on the children
     while 1:
         try:
-            method.mergeFullHeaders(id.hdList)
+            method.mergeFullHeaders(id.grpset.hdrlist)
         except FileCopyException:
             method.unmountCD()
             intf.messageWindow(_("Error"),
@@ -635,7 +603,7 @@ def doPreInstall(method, id, intf, instPath, dir):
 	f = open(instPath + "/etc/mtab", "w+")
 	f.close()
 
-    if method.systemMounted (id.fsset, instPath, id.hdList.selected()):
+    if method.systemMounted (id.fsset, instPath):
 	id.fsset.umountFilesystems(instPath)
 	return DISPATCH_BACK
 
@@ -714,8 +682,9 @@ def doInstall(method, id, intf, instPath):
 
     l = []
 
-    for p in id.hdList.selected():
-	l.append(p)
+    for p in id.grpset.hdrlist.values():
+        if p.isSelected():
+            l.append(p)
     l.sort(sortPackages)
 
     progress = intf.progressWindow(_("Processing"),
@@ -749,19 +718,22 @@ def doInstall(method, id, intf, instPath):
 
     i = 0
     for p in l:
-	ts.addInstall(p.h, p.h, how)
+	ts.addInstall(p.hdr, p.hdr, how)
 	total = total + 1
 	totalSize = totalSize + (p[rpm.RPMTAG_SIZE] / 1024)
         i = i + 1
         progress.set(i)
 
     progress.pop()
-    
-    if not id.hdList.preordered():
+
+    depcheck = DependencyChecker(id.grpset)
+    if not id.grpset.hdrlist.preordered():
 	log ("WARNING: not all packages in hdlist had order tag")
         # have to call ts.check before ts.order() to set up the alIndex
-        ts.check()
+        ts.check(depcheck.callback)
         ts.order()
+    else:
+        ts.check(depcheck.callback)
 
     if upgrade:
 	logname = '/root/upgrade.log'
@@ -837,11 +809,6 @@ def doInstall(method, id, intf, instPath):
 	nodeneeded = {}
 	size = 12
 
-	# XXX
-	nodeprob = -1
-	if rpm.__dict__.has_key ("RPMPROB_DISKNODES"):
-	    nodeprob = rpm.RPMPROB_DISKNODES
-
 	for (descr, (type, mount, need)) in problems:
             log("(%s, (%s, %s, %s))" %(descr, type, mount, need))
             if mount and mount.startswith(instPath):
@@ -949,16 +916,19 @@ def doInstall(method, id, intf, instPath):
                         "this version but NOT installed:\n"))
         
     lines = []
-    for p in id.hdList.packages.values ():
-        if not p.selected:
-            lines.append("%s-%s-%s.%s.rpm\n" %
-                         (p.h[rpm.RPMTAG_NAME],
-                          p.h[rpm.RPMTAG_VERSION],
-                          p.h[rpm.RPMTAG_RELEASE],
-                          p.h[rpm.RPMTAG_ARCH]))
-    lines.sort()
     for line in lines:
         instLog.write(line)
+        lines = []
+        for p in id.grpset.hdrlist.values():
+            if not p.isSelected():
+                lines.append("%s-%s-%s.%s.rpm\n" %
+                             (p.h[rpm.RPMTAG_NAME],
+                              p.h[rpm.RPMTAG_VERSION],
+                              p.h[rpm.RPMTAG_RELEASE],
+                              p.h[rpm.RPMTAG_ARCH]))
+        lines.sort()
+        for line in lines:
+            instLog.write(line)
     instLog.close ()
 
     id.instProgress = None
@@ -985,7 +955,7 @@ def doPostInstall(method, id, intf, instPath):
 	if not upgrade:
 	    w.set(1)
 
-	    copyExtraModules(instPath, id.comps, id.extraModules)
+	    copyExtraModules(instPath, id.grpset, id.extraModules)
 
 	    w.set(2)
 
@@ -1043,9 +1013,9 @@ def doPostInstall(method, id, intf, instPath):
                     pass
 
                 argv = [ "/usr/sbin/kudzu", "-q" ]
-                if id.hdList.has_key("kernel"):
-                    ver = "%s-%s" %(id.hdList["kernel"][rpm.RPMTAG_VERSION],
-                                    id.hdList["kernel"][rpm.RPMTAG_RELEASE])
+                if id.grpset.hdrlist.has_key("kernel"):
+                    ver = "%s-%s" %(id.grpset.hdrlist["kernel"][rpm.RPMTAG_VERSION],
+                                    id.grpset.hdrlist["kernel"][rpm.RPMTAG_RELEASE])
                     argv.extend(["-k", ver])
                 
                 devnull = os.open("/dev/null", os.O_RDWR)
@@ -1188,8 +1158,8 @@ def migrateXinetd(instPath, instLog):
 			   stdout = logfile, stderr = logfile)
     os.close(logfile)
 
-def copyExtraModules(instPath, comps, extraModules):
-    kernelVersions = comps.kernelVersionList()
+def copyExtraModules(instPath, grpset, extraModules):
+    kernelVersions = grpset.kernelVersionList()
 
     for (path, subdir, name) in extraModules:
         if not path:
@@ -1283,49 +1253,34 @@ def betaNagScreen(intf, dir):
 	    break
 
 # FIXME: this is a kind of poor way to do this, but it will work for now
-def selectLanguageSupportGroups(comps, langSupport):
+def selectLanguageSupportGroups(grpset, langSupport):
     sup = langSupport.supported
     if len(sup) == 0:
         sup = langSupport.getAllSupported()
 
-    for group in comps.compsxml.groups.values():
+    for group in grpset.groups.values():
+        xmlgrp = grpset.compsxml.groups[group.basename]
+        langs = []
         for name in sup:
             try:
                 lang = langSupport.langInfoByName[name][0]
-                langs = language.expandLangs(lang)
+                langs.extend(language.expandLangs(lang))
             except:
                 continue
-            if group.langonly in langs:
-                if not comps.compsDict.has_key(group.name):
-                    log("Where did the %s component go?"
-                        %(group.name,))
+            
+        if group.langonly is not None and group.langonly in langs:
+            group.select()
+            for package in xmlgrp.pkgConditionals.keys():
+                req = xmlgrp.pkgConditionals[package]
+                if not grpset.hdrlist.has_key(package):
+                    log("Missing %s which is in a langsupport conditional" %(package,))
                     continue
-                comps.compsDict[group.name].select()
-                for package in group.pkgConditionals.keys():
-                    req = group.pkgConditionals[package]
-                    if not comps.packages.has_key(package):
-                        log("Missing %s which is in a langsupport conditional" %(package,))
-                        continue
-                    if not comps.compsxml.packages.has_key(req):
-                        log("Missing %s which is required by %s in a langsupport group" %(req, package))
-                        continue
-                    # add to the deps in the dependencies structure --
-                    # this will take care of if we're ever added as a dep
-                    comps.compsxml.packages[req].dependencies.append(package)
-                    # also add to components as needed
-                    # if the req is PKGTYPE_MANDATORY, then just add to the
-                    # depsDict.  if the req is PKGTYPE_DEFAULT, add it
-                    # as DEFAULT
-                    pkg = comps.packages[package]
-                    reqp = comps.packages[req]
-                    for comp in comps.packages[req].comps:
-                        if comp.newpkgDict.has_key(reqp):
-                            if comp.newpkgDict[reqp][0] == PKGTYPE_MANDATORY:
-                                comp.addDependencyPackage(pkg)
-                                comp.updateDependencyCountForAddition(pkg)
-                            else:
-                                comp.addPackage(pkg, PKGTYPE_DEFAULT)
-                        elif comp.depsDict.has_key(req):
-                            comp.addDependencyPackage(pkg)
-                            comp.updateDependencyCountForAddition(pkg)
-    comps.updateSelections()
+                # add to the deps in the dependencies structure for the
+                # package.  this should take care of whenever we're
+                # selected
+                grpset.hdrlist[req].addDeps([package])
+                if grpset.hdrlist[req].isSelected():
+                    grpset.hdrlist[package].select()
+                    sys.stdout.flush()
+                    grpset.hdrlist[package].usecount += grpset.hdrlist[req].usecount - 1
+                    group.selectDeps([package], uses = grpset.hdrlist[req].usecount - 1)
diff --git a/partitions.py b/partitions.py
index 7780145a8..88f8d59d7 100644
--- a/partitions.py
+++ b/partitions.py
@@ -109,6 +109,12 @@ class Partitions:
                     if part.fs_type and part.fs_type.name == "linux-swap":
                         # XXX this is a hack
                         format = 1
+
+                    # FIXME: we don't handle ptype being None very well, so
+                    # just say it's foreign.  Should probably fix None
+                    # handling instead some day.
+                    if ptype is None:
+                        ptype = fsset.fileSystemTypeGet("foreign")
                     
                 start = part.geom.start
                 end = part.geom.end
diff --git a/scripts/mk-images.i386 b/scripts/mk-images.i386
index e2e3993e1..9bfe18c60 100644
--- a/scripts/mk-images.i386
+++ b/scripts/mk-images.i386
@@ -95,7 +95,7 @@ FSMODS="msdos vfat ext3 reiserfs jfs"
 SECSTAGE="agpgart raid0 raid1 raid5 lvm-mod $FSMODS $IDEMODS $SCSIMODS $LATEUSBMODS st parport_pc parport"
 
 BTERMMODULES="vga16fb"
-COMMONMODULES="vfat nfs $USBMODS $BTERMMODULES"
+COMMONMODULES="vfat nfs floppy $USBMODS $BTERMMODULES"
 LOCALMODULES="$COMMONMODULES aic7xxx megaraid ncr53c8xx 
 	     sym53c8xx $IDEMODS $SCSIMODS"
 NETWORKMODULES="$COMMONMODULES 3c59x 
diff --git a/scripts/mk-images.ia64 b/scripts/mk-images.ia64
index b9ab64172..90a6738dc 100644
--- a/scripts/mk-images.ia64
+++ b/scripts/mk-images.ia64
@@ -2,7 +2,8 @@
 USBMODS="usb-uhci usb-ohci hid keybdev"
 LATEUSBMODS="mousedev"
 
-SECSTAGE="nfs fat vfat raid0 raid1 raid5 ext3 $LATEUSBMODS"
+COMMONMODULES="nfs fat vfat cramfs floppy"
+SECSTAGE="nfs fat vfat raid0 raid1 raid5 lvm-mod ext3 $LATEUSBMODS"
 NETMODULES="3c59x acenic bcm5700 e100 e1000 eepro100 hamachi sk98lin starfire sunhme tulip yellowfin tg3"
 SCSIMODULES="sd_mod sr_mod scsi_mod DAC960 cciss cpqarray aic7xxx aic7xxx_mod megaraid qla1280 qla2200 qla2300 sym53c8xx sym53c8xx_2 mptscsih mptbase ips"
 IDEMODULES="ide-mod ide-probe-mod ide-disk ide-cd"
@@ -39,7 +40,7 @@ makeBootImages() {
 	--initrdflags '--initrdto $TOPDESTPATH/images/ramdisk.img \
 		     	    --initrdsize 8192 \
 			    --loaderbin loader \
-			    --modules "nfs fat vfat cramfs $USBMODS $NETMODULES $SCSIMODULES $IDEMODULES"' 
+			    --modules "$COMMONMODULES $USBMODS $NETMODULES $SCSIMODULES $IDEMODULES"' 
 
     # now make a boot iso
     mkdir -p $TOPDESTPATH/images/isopath
diff --git a/scripts/mk-images.ppc b/scripts/mk-images.ppc
index 0844de063..9ba290b72 100644
--- a/scripts/mk-images.ppc
+++ b/scripts/mk-images.ppc
@@ -1,14 +1,13 @@
-COMMONMODULES="nfs fat vfat cramfs loop"
+COMMONMODULES="nfs fat vfat cramfs loop floppy"
 FSMODS="msdos vfat ext3 reiserfs jfs"
 IDEMODS="ide-cd"
 SCSIMODS="sd_mod sr_mod st"
 LATEUSBMODS="mousedev usb-storage"
 SECSTAGE="raid0 raid1 raid5 lvm-mod $FSMODS $IDEMODS $SCSIMODS $LATEUSBMODS"
-# need yellowfin for IBM?
 NETMODULES="sungem tg3 ne2k-pci 3c59x 8139too
-	   de4x5 acenic pcnet32 tulip natsemi eepro100 airport"
+	   de4x5 acenic pcnet32 tulip natsemi e100 e1000 airport"
 
-SCSIMODULES="advansys aic7xxx initio sym53c8xx"
+SCSIMODULES="$SCSIMODS advansys aic7xxx initio sym53c8xx"
 ISERIESMODULES="veth viodasd viocd"
 
 # images we only want on the CD (usually for space reasons)
@@ -27,7 +26,7 @@ makeBootImages() {
 	makeinitrd --initrdto $TOPDESTPATH/ppc/chrp/ramdisk.image.gz \
 	    --initrdsize 8192 \
 	    --loaderbin loader \
-	    --modules "$COMMONMODULES $NETMODULES $SCSIMODULES $IDEMODULES $ISOMODULES"
+	    --modules "$COMMONMODULES $NETMODULES $SCSIMODULES $SCSIMODS $IDEMODS $ISOMODULES"
 
 	mkdir -p $TOPDESTPATH/etc $TOPDESTPATH/ppc/chrp
 	cp $KERNELROOT/boot/vmlinux-*pseries* $TOPDESTPATH/ppc/chrp/vmlinux
@@ -53,7 +52,7 @@ makeBootImages() {
 	makeinitrd --initrdto $TOPDESTPATH/ppc/iSeries/ramdisk.image.gz \
 	    --initrdsize 8192 \
 	    --loaderbin loader \
-	    --modules "$COMMONMODULES $NETMODULES $SCSIMODULES $IDEMODULES $ISOMODULES $ISERIESMODULES"
+	    --modules "$COMMONMODULES $NETMODULES $SCSIMODULES $IDEMODS $ISOMODULES $ISERIESMODULES"
 
 	cp $KERNELROOT/boot/vmlinux-*iseries* $TOPDESTPATH/ppc/iSeries/vmlinux
 	cp $KERNELROOT/boot/System.map-*iseries* $TOPDESTPATH/ppc/iSeries/System.map
@@ -66,13 +65,13 @@ makeBootImages() {
     # makeinitrd --initrdto $TOPDESTPATH/images/ramdisk.image.gz \
     #            --initrdsize 8192 \
     #            --loaderbin loader \
-    #            --modules "nfs fat vfat cramfs $NETMODULES $SCSIMODULES $IDEMODULES $ISOMODULES"
+    #            --modules "nfs fat vfat cramfs $NETMODULES $SCSIMODULES $IDEMODS $ISOMODULES"
     fi
 }
 
 makeSecondStage() {
-    makeinstimage "netstg" "$SECSTAGE $SCSIMODULES $IDEMODULES"
-    makeinstimage "hdstg" "$SECSTAGE $NETMODULES $IDEMODULES"
-    makemainmodules "$SECSTAGE $NETMODULES $SCSIMODULES $IDEMODULES"
+    makeinstimage "netstg" "$SECSTAGE $SCSIMODULES $IDEMODS"
+    makeinstimage "hdstg" "$SECSTAGE $NETMODULES $IDEMODS"
+    makemainmodules "$SECSTAGE $NETMODULES $SCSIMODULES $IDEMODS"
     makemainimage "stage2" "cramfs"
 }
diff --git a/scripts/mk-images.s390 b/scripts/mk-images.s390
index 9bada5f3e..821447a96 100644
--- a/scripts/mk-images.s390
+++ b/scripts/mk-images.s390
@@ -430,7 +430,7 @@ fi
 IDEMODS=""
 SCSIMODS=""
 
-SECSTAGE="$IDEMODS $SCSIMODS raid0 raid1 raid5"
+SECSTAGE="$IDEMODS $SCSIMODS raid0 raid1 raid5 lvm-mod"
 
 COMMONMODULES="loop cramfs dasd_diag_mod dasd_eckd_mod dasd_fba_mod dasd_mod tape390 isofs ext3"
 LOCALMODULES="$COMMONMODULES tape390 $IDEMODS $SCSIMODS"
diff --git a/scripts/mk-images.x86_64 b/scripts/mk-images.x86_64
index dd8571acd..46143980e 100644
--- a/scripts/mk-images.x86_64
+++ b/scripts/mk-images.x86_64
@@ -40,7 +40,7 @@ FSMODS="msdos vfat ext3 reiserfs"
 SECSTAGE="agpgart raid0 raid1 raid5 lvm-mod $FSMODS $IDEMODS $SCSIMODS $LATEUSBMODS st parport_pc parport"
 
 BTERMMODULES="vga16fb"
-COMMONMODULES="vfat loop cramfs $USBMODS $BTERMMODULES"
+COMMONMODULES="vfat loop cramfs floppy $USBMODS $BTERMMODULES"
 LOCALMODULES="$COMMONMODULES aic7xxx megaraid ncr53c8xx 
 	     sym53c8xx $IDEMODS $SCSIMODS"
 NETWORKMODULES="$COMMONMODULES nfs 3c59x 
diff --git a/scripts/pkgorder b/scripts/pkgorder
index 85e72cd1c..91cb0cd5a 100755
--- a/scripts/pkgorder
+++ b/scripts/pkgorder
@@ -19,11 +19,11 @@ log.handler = anaconda_log
 
 rpmFD = None
 
-import comps
+import hdrlist
 
 def cmpHeaderByName(h1, h2):
-    n1 = string.lower(h1['name'])
-    n2 = string.lower(h2['name'])
+    n1 = string.lower(h1.nevra())
+    n2 = string.lower(h2.nevra())
 
     if n1 < n2:
 	return -1
@@ -68,20 +68,14 @@ disc2Dir = distDir + "-disc2"
 # pull in the hdlist
 f = distDir + "/RedHat/base/hdlist"
 try:
-    hdlist = comps.HeaderListFromFile(f, noscore = 1)
+    hdlist = hdrlist.HeaderListFromFile(f)
     hdlist.mergeFullHeaders(distDir + "/RedHat/base/hdlist2")    
 except rpm.error:
     print "Failed to read header list", f
     sys.exit(1)
 # and read the comps file
-comps = comps.ComponentSet("file://%s/RedHat/base/comps.xml" %(distDir,),
-                           hdlist, arch = arch, matchAllLang = 0)
-
-# FIXME: HACK SO THAT PPC TREES WILL SPLIT.  MUST BE REMOVED
-# !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-import iutil
-if iutil.getArch() == "ppc" and hdlist.packages.has_key("kernel"):
-    del hdlist.packages["kernel"]
+grpset = hdrlist.groupSetFromCompsFile("file://%s/RedHat/base/comps.xml"
+                                       %(distDir,), hdlist)
 
 # work out the order we'd like to install everything in
 pkgOrder = []
@@ -93,112 +87,75 @@ for package in hdlist.keys():
         not package.startswith("kernel-doc") and
         not package.startswith("kernel-source") and
         not package.startswith("kernel-debug")):
-        hdlist[package].selected = 1
-        pkgOrder.append(hdlist[package].h)
-        pkgHash[hdlist[package].h] = None
+        hdlist[package].select()
+        pkgOrder.append(hdlist[package].nevra())
+        pkgHash[hdlist[package].name] = None
 
 # Tier 1 language packages get priority.
 tier1langs = ("en:en_US:de:de_DE:es:es_ES:fr:fr_FR:it:it_IT:ja:ja_JP:"
               "ko:ko_KR:zh:zh_CN:zh_TW:pt:pt_BR:en_GB:en_CA")
 
-# Form a dictionary of _all_ the components, even sub comps
-compsDict = {}
-subComps = {}
-for h in hdlist.keys():
-    hdlist[h].selected = 0
-    for comp in hdlist[h].comps:
-        compsDict[comp.name] = comp
-
-# make a list of all the names of all the components.
-allComps = compsDict.values()
-
-# go through all our toplevel components and add children to it.
-for comp in comps:
-    compsDict[comp.name] = comp
-    subComps[comp] = []
-    for c in allComps:
-        if isParent(comp, c):
-            subComps[comp].append(c)
-#print subComps
-#print compsDict
 
+grpids = grpset.groups.keys()
+grpids.sort()
+    
 # FIXME: this is a hack to get things we want to be first on the CDs earlier
 # in a more perfect world, we'd read the installclasses to do this
-complist = ["Core", "Base", "Text-based Internet", "Web Server",
-            "Windows File Server", "Printing Support",
-            "Dialup Networking Support", "Server Configuration Tools",
-            "Administration Tools"]
+complist = ["core", "base", "text-internet", "web-server",
+            "smb-server", "printing", "dialup", "server-cfg",
+            "admin-tools"]
 # now let's pull in all of workstation common
-if comps.has_key("Workstation Common"):
-    comp = comps["Workstation Common"]
-    complist.append("Workstation Common")
-    for name in comp.includes:
+if grpset.groups.has_key("workstation-common"):
+    comp = grpset.groups["workstation-common"]
+    complist.append("workstation-common")
+    for name in comp.groupreqs:
         if name not in complist:
             complist.append(name)
 # a couple more that make sense to have early
-complist.extend(["GNOME Desktop Environment", "Emacs", "Development Tools",
-                 "Development Libraries", "X Software Development",
-                 "GNOME Software Development", "KDE Desktop Environment",
-                 "KDE Software Development"])
+complist.extend(["gnome-desktop", "emacs", "development-tools",
+                 "development-libs", "x-software-development",
+                 "gnome-software-development", "kde-desktop",
+                 "kde-software-development"])
         
 latelangs = []
-for name in comps:
-    if comp.name in complist:
+for id in grpids:
+    if id in complist:
         continue
-    if ((comp.lang is not None) and
-        (string.find(tier1langs, comp.lang) == -1)):
-        latelangs.append(comp.name)
+    if ((grpset.groups[id].langonly is not None) and
+        (tier1langs.find(grpset.groups[id].langonly) == -1)):
+        latelangs.append(id)
     else:
-        complist.append(comp.name)
+        complist.append(id)
 complist.extend(latelangs)
 
 # for each comp, staring with base, list the packages
 # in alphabetical order.
-for name in complist:
-    if not comps.has_key(name):
+for id in complist:
+    if not grpset.groups.has_key(id):
         continue
-    comp = comps[name]
+    group = grpset.groups[id]
     list = []
 
-    # don't update the hdlist selection state yet, we're going to do
-    # a lot of toggling here.
-    comps.freeze()
-    # make sure all the components are off
-    for n in compsDict.values():
-        n.unselect ()
-
-    # turn on this component, and anything that this component needs
-    # to have on in order to be on.
-    selectComp(comp)
-    if comp.conditionalKey:
-    	selectComp(comps[comp.conditionalKey])
-
-    # Do the same for each subcomponent
-    for c in subComps[comp]:
-        selectComp(c)
-        if c.conditionalKey:
-            selectComp(compsDict[c.conditionalKey])
-    # update the hdlist selection states
-    comps.thaw()
+    group.select()
 
     # append what got turned on to our order.
-
-    for p in hdlist.selected():
-        list.append(p.h)
+    for p in hdlist.pkgs.values():
+        if p.isSelected():
+            list.append(p)
     list.sort(cmpHeaderByName)
     for item in list:
-        if not pkgHash.has_key (item):
-            pkgOrder.append(item)
-            pkgHash[item] = None
+        if not pkgHash.has_key (item.name):
+            pkgOrder.append(item.nevra())
+            pkgHash[item.name] = None
 
 # add all of the packages that haven't been added yet.
 list = []
-for p in hdlist.packages.values():
-    if not pkgHash.has_key (p.h):
-        list.append(p.h)
+for p in hdlist.pkgs.values():
+    if not pkgHash.has_key (p.name):
+        list.append(p)
 list.sort(cmpHeaderByName)
 for item in list:
-    pkgOrder.append(item)
+    pkgOrder.append(item.nevra())
 
 # Now set up rpm to run the transaction deporder
 testpath = '/tmp/pkgorder-' + str (os.getpid ())
@@ -209,7 +166,7 @@ ts.setVSFlags(~(rpm.RPMVSF_NORSA|rpm.RPMVSF_NODSA))
 ts.setFlags(rpm.RPMTRANS_FLAG_NOMD5|rpm.RPMTRANS_FLAG_ANACONDA)
 for h in pkgOrder:
     #print "in:", h[1000000]
-    ts.addInstall(h, h, 'i')
+    ts.addInstall(hdlist[h].hdr, hdlist[h].hdr, 'i')
 pkgOrder = []
 
 # we have to run ts.check() before ts.order() now to set up the
diff --git a/textw/packages_text.py b/textw/packages_text.py
index f1cd40e86..b972dd572 100644
--- a/textw/packages_text.py
+++ b/textw/packages_text.py
@@ -39,27 +39,27 @@ class PackageGroupWindow:
 
 	label.setText(self.size(comps))
 
-    def __call__(self, screen, comps, langSupport, instClass, dispatch):
-	origSelection = comps.getSelectionState()
+    def __call__(self, screen, grpset, langSupport, instClass, dispatch):
+	origSelection = grpset.getSelectionState()
 
         ct = CheckboxTree(height = 8, scroll = 1)
-        for comp in comps:
-            if not comp.hidden:
-                ct.append(comp.name, comp, comp.isSelected(justManual = 1))
+        for group in grpset.groups.values():
+            if not group.hidden:
+                ct.append(group.name, group, group.isSelected(justManual = 1))
 
         cb = Checkbox (_("Select individual packages"), 
 			    not dispatch.stepInSkipList("indivpackage"))
         bb = ButtonBar (screen, (TEXT_OK_BUTTON, TEXT_BACK_BUTTON))
-	la = Label(self.size(comps))
+	la = Label(self.size(grpset))
 
-	ct.setCallback(self.updateSize, (la, comps, ct))
+	ct.setCallback(self.updateSize, (la, grpset, ct))
 
         g = GridFormHelp (screen, _("Package Group Selection"), 
 			  "packagetree", 1, 4)
 
         g.add (la, 0, 0, (0, 0, 0, 1), anchorLeft = 1)
         g.add (ct, 0, 1, (0, 0, 0, 1))
-        g.add (cb, 0, 2, (0, 0, 0, 1))
+#        g.add (cb, 0, 2, (0, 0, 0, 1))
         g.add (bb, 0, 3, growx = 1)
 
         result = g.runOnce()
@@ -67,7 +67,7 @@ class PackageGroupWindow:
         rc = bb.buttonPressed (result)
 
         if rc == TEXT_BACK_CHECK:
-	    comps.setSelectionState(origSelection)
+	    grpset.setSelectionState(origSelection)
             return INSTALL_BACK
 
 	if cb.selected():
diff --git a/urlinstall.py b/urlinstall.py
index a3d8f4fb8..ce8d640c0 100644
--- a/urlinstall.py
+++ b/urlinstall.py
@@ -13,7 +13,7 @@
 # Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 #
 
-from comps import ComponentSet, HeaderList
+from hdrlist import groupSetFromCompsFile, HeaderList
 from installmethod import InstallMethod, FileCopyException
 import os
 import rpm
@@ -90,7 +90,7 @@ class UrlInstallMethod(InstallMethod):
 	if fname is None:
 	    fname = self.baseUrl + '/RedHat/base/comps.xml'
 	    log("Comps not in update dirs, using %s",fname)
-	return ComponentSet(fname, hdlist)
+        return groupSetFromCompsFile(fname, hdlist)
 
     def getFilename(self, h, timer, callback=None):
 
diff --git a/utils/genhdlist.c b/utils/genhdlist.c
index 826c438b1..a952b7f12 100644
--- a/utils/genhdlist.c
+++ b/utils/genhdlist.c
@@ -485,6 +485,7 @@ int main(int argc, const char ** argv) {
 	    strcpy (depOrder[numpkgs], b);
 	    numpkgs++;
 	}
+        depOrder[numpkgs] = NULL;  /* end with a null */
     }
 
     requireTable = htNewTable(1000);