diskset moves to partedUtils

7 files changed, 488 insertions, 458 deletions

diff --git a/fsset.py b/fsset.py
index d9aa86ef9..15b261dc2 100644
--- a/fsset.py
+++ b/fsset.py
@@ -96,7 +96,7 @@ class LabelFactory:
         if self.labels == None:
 
             self.labels = {}
-            diskset = partitioning.DiskSet()            
+            diskset = partedUtils.DiskSet()            
             diskset.openDevices()
             diskset.stopAllRaid()
             diskset.startAllRaid()
@@ -1583,7 +1583,7 @@ def readFstab (path):
     # first, we look at all the disks on the systems and get any ext2/3
     # labels off of the filesystem.
     # temporary, to get the labels
-    diskset = partitioning.DiskSet()
+    diskset = partedUtils.DiskSet()
     diskset.openDevices()
     labels = diskset.getLabels()
 
diff --git a/instdata.py b/instdata.py
index 5fa793ca2..9cfa4e6a2 100644
--- a/instdata.py
+++ b/instdata.py
@@ -23,6 +23,7 @@ import users
 import fsset
 import bootloader
 import partitioning
+import partedUtils
 from flags import *
 
 from simpleconfig import SimpleConfigFile
@@ -62,7 +63,7 @@ class InstallData:
 	self.upgrade = Boolean()
         # XXX move fsset and/or diskset into Partitions object?
 	self.fsset.reset()
-        self.diskset = partitioning.DiskSet()
+        self.diskset = partedUtils.DiskSet()
         self.partitions = partitioning.Partitions()
         self.bootloader = bootloader.getBootloader()
         self.dependencies = []
diff --git a/iw/fdisk_gui.py b/iw/fdisk_gui.py
index 99e83703f..37ed6261d 100644
--- a/iw/fdisk_gui.py
+++ b/iw/fdisk_gui.py
@@ -29,7 +29,7 @@ class FDiskWindow (InstallWindow):
     def getNext(self):
         # reread partitions
         self.diskset.refreshDevices(self.intf)
-        partitioning.checkNoDisks(self.diskset, self.intf)
+        self.diskset.checkNoDisks(self.intf)
         self.partrequests.setFromDisk(self.diskset)
 
         return None
diff --git a/partedUtils.py b/partedUtils.py
index 5b4cd7631..66183a6f2 100644
--- a/partedUtils.py
+++ b/partedUtils.py
@@ -17,9 +17,14 @@
 """Helper functions for use when dealing with parted objects."""
 
 import parted
-import fsset
 import math
+import os, sys, string
 
+import fsset
+import iutil, isys
+import raid
+from log import log
+from flags import flags
 from partErrors import *
 from translate import _
 
@@ -196,6 +201,474 @@ def get_lvm_partitions(disk):
     return filter_partitions(disk, func)
 
 
+def getDefaultDiskType():
+    """Get the default partition table type for this architecture."""
+    if iutil.getArch() == "i386":
+        return parted.disk_type_get("msdos")
+    elif iutil.getArch() == "ia64":
+        return parted.disk_type_get("GPT")
+    elif iutil.getArch() == "s390":
+        return parted.disk_type_get("dasd")
+    else:
+        # XXX fix me for alpha at least
+        return parted.disk_type_get("msdos")
+
+archLabels = {'i386': ['msdos'],
+              'alpha': ['bsd'],
+              's390': ['dasd'],
+              'ia64': ['msdos', 'GPT']}
+
+def checkDiskLabel(disk, intf):
+    """Check that the disk label on disk is valid for this machine type."""
+    arch = iutil.getArch()
+    if arch in archLabels.keys():
+        if disk.type.name in archLabels[arch]:
+            return 0
+    else:
+        if disk.type.name == "msdos":
+            return 0
+
+    if intf:
+        rc = intf.messageWindow(_("Warning"),
+                       _("The partition table on device /dev/%s is of an "
+                         "unexpected type %s for your architecture.  To "
+                         "use this disk for installation of Red Hat Linux, "
+                         "it must be re-initialized causing the loss of "
+                         "ALL DATA on this drive.\n\n"
+                         "Would you like to initialize this drive?")
+                       % (disk.dev.path[5:], disk.type.name), type = "yesno")
+        if rc == 0:
+            return 1
+        else:
+            return -1
+    else:
+        return 1
+
+class DiskSet:
+    """The disks in the system."""
+
+    skippedDisks = []
+    mdList = []
+    def __init__ (self):
+        self.disks = {}
+
+    def startAllRaid(self):
+        """Start all of the raid devices associated with the DiskSet."""
+        driveList = []
+        origDriveList = self.driveList()
+        for drive in origDriveList:
+            if not drive in DiskSet.skippedDisks:
+                driveList.append(drive)
+        DiskSet.mdList.extend(raid.startAllRaid(driveList))
+
+    def stopAllRaid(self):
+        """Stop all of the raid devices associated with the DiskSet."""
+        raid.stopAllRaid(DiskSet.mdList)
+        while DiskSet.mdList:
+            DiskSet.mdList.pop()
+
+    def getLabels(self):
+        """Return a list of all of the labels used on partitions."""
+        labels = {}
+        
+        drives = self.disks.keys()
+        drives.sort()
+
+        for drive in drives:
+            disk = self.disks[drive]
+            func = lambda part: (part.is_active() and
+                                 not (part.get_flag(parted.PARTITION_RAID)
+                                      or part.get_flag(parted.PARTITION_LVM))
+                                 and part.fs_type
+                                 and (part.fs_type.name == "ext2"
+                                      or part.fs_type.name == "ext3"))
+            parts = filter_partitions(disk, func)
+            for part in parts:
+                node = get_partition_name(part)
+                label = isys.readExt2Label(node)
+                if label:
+                    labels[node] = label
+
+        for dev, devices, level, numActive in DiskSet.mdList:
+            label = isys.readExt2Label(dev)
+            if label:
+                labels[dev] = label
+
+        return labels
+
+    def findExistingRootPartitions(self, intf, mountpoint):
+        """Return a list of all of the partitions which look like a root fs."""
+        rootparts = []
+
+        self.startAllRaid()
+
+        for dev, devices, level, numActive in self.mdList:
+            (errno, msg) = (None, None)
+            found = 0
+            for fs in fsset.getFStoTry(dev):
+                try:
+                    isys.mount(dev, mountpoint, fs, readOnly = 1)
+                    found = 1
+                    break
+                except SystemError, (errno, msg):
+                    pass
+
+            if not found:
+                intf.messageWindow(_("Error"),
+                                   _("Error mounting filesystem "
+                                     "on %s: %s") % (dev, msg))
+                continue
+
+            if os.access (mountpoint + '/etc/fstab', os.R_OK):
+                rootparts.append ((dev, fs))
+            isys.umount(mountpoint)
+
+        self.stopAllRaid()
+
+        drives = self.disks.keys()
+        drives.sort()
+
+        for drive in drives:
+            disk = self.disks[drive]
+            part = disk.next_partition ()
+            while part:
+                if (part.is_active()
+                    and (part.get_flag(parted.PARTITION_RAID)
+                         or part.get_flag(parted.PARTITION_LVM))):
+                    # skip RAID and LVM partitions.
+                    # XXX check for raid superblocks on non-autoraid partitions
+                    #  (#32562)
+                    pass
+                elif part.fs_type and part.fs_type.name in fsset.getUsableLinuxFs():
+                    node = get_partition_name(part)
+		    try:
+			isys.mount(node, mountpoint, part.fs_type.name)
+		    except SystemError, (errno, msg):
+			intf.messageWindow(_("Error"),
+                                           _("Error mounting filesystem on "
+                                             "%s: %s") % (node, msg))
+                        part = disk.next_partition(part)
+			continue
+		    if os.access (mountpoint + '/etc/fstab', os.R_OK):
+			rootparts.append ((node, part.fs_type.name))
+		    isys.umount(mountpoint)
+                elif part.fs_type and (part.fs_type.name == "FAT"):
+                    node = get_partition_name(part)
+                    try:
+                        isys.mount(node, mountpoint, fstype = "vfat",
+                                   readOnly = 1)
+                    except:
+			log("failed to mount vfat filesystem on %s\n" 
+                            % node)
+                        part = disk.next_partition(part)
+			continue
+                        
+		    if os.access(mountpoint + '/redhat.img', os.R_OK):
+                        rootparts.append((node, "vfat"))
+
+		    isys.umount(mountpoint)
+                    
+                part = disk.next_partition(part)
+        return rootparts
+
+    def driveList (self):
+        """Return the list of drives on the system."""
+	drives = isys.hardDriveDict().keys()
+	drives.sort (isys.compareDrives)
+	return drives
+
+    def drivesByName (self):
+        """Return a dictionary of the drives on the system."""
+	return isys.hardDriveDict()
+
+    def addPartition (self, device, type, spec):
+        """Add a new partition to the device. - UNUSED."""
+        if not self.disks.has_key (device):
+            raise PartitioningError, ("unknown device passed to "
+                                      "addPartition: %s" % (device,))
+        disk = self.disks[device]
+
+        part = disk.next_partition ()
+        status = 0
+        while part:
+            if (part.type == parted.PARTITION_FREESPACE
+                and part.geom.length >= spec.size):
+                newp = disk.partition_new (type, spec.fs_type,
+                                           part.geom.start,
+                                           part.geom.start + spec.size)
+                constraint = disk.constraint_any ()
+                try:
+                    disk.add_partition (newp, constraint)
+                    status = 1
+                    break
+                except parted.error, msg:
+                    raise PartitioningError, msg
+            part = disk.next_partition (part)
+        if not status:
+            raise PartitioningError, ("Not enough free space on %s to create "
+                                      "new partition" % (device,))
+        return newp
+    
+    def deleteAllPartitions (self):
+        """Delete all partitions from all disks. - UNUSED."""
+        for disk in self.disks.values():
+            disk.delete_all ()
+
+    def savePartitions (self):
+        """Write the partition tables out to the disks."""
+        for disk in self.disks.values():
+            disk.write()
+            del disk
+        self.refreshDevices()
+
+    def refreshDevices (self, intf = None, initAll = 0, zeroMbr = 0):
+        """Reread the state of the disks as they are on disk."""
+        self.disks = {}
+        self.openDevices(intf, initAll, zeroMbr)
+
+    def closeDevices (self):
+        """Close all of the disks which are open."""
+        for disk in self.disks.keys():
+            del self.disks[disk]
+
+    def dasdFmt (self, intf = None, drive = None):
+        "Format dasd devices (s390)."""
+        w = intf.progressWindow (_("Initializing"),
+                             _("Please wait while formatting drive %s...\n"
+                               ) % (drive,), 100)
+        try:
+            isys.makeDevInode(drive, '/tmp/' + drive)
+        except:
+            pass
+
+        argList = [ "/sbin/dasdfmt",
+                    "-y",
+                    "-b", "4096",
+                    "-d", "cdl",
+                    "-P",
+                    "-f",
+                    "/tmp/%s" % drive]
+        
+        fd = os.open("/dev/null", os.O_RDWR | os.O_CREAT | os.O_APPEND)
+        p = os.pipe()
+        childpid = os.fork()
+        if not childpid:
+            os.close(p[0])
+            os.dup2(p[1], 1)
+            os.dup2(fd, 2)
+            os.close(p[1])
+            os.close(fd)
+            os.execv(argList[0], argList)
+            log("failed to exec %s", argList)
+            sys.exit(1)
+			    
+        os.close(p[1])
+
+        num = ''
+        sync = 0
+        s = 'a'
+        while s:
+            try:
+                s = os.read(p[0], 1)
+                os.write(fd, s)
+
+                if s != '\n':
+                    try:
+                        num = num + s
+                    except:
+                        pass
+                else:
+                    if num:
+                        val = string.split(num)
+                        if (val[0] == 'cyl'):
+                            # printf("cyl %5d of %5d |  %3d%%\n",
+                            val = int(val[5][:-1])
+                            w and w.set(val)
+                            # sync every 10%
+                            if sync + 10 <= val:
+                                isys.sync()
+                                sync = val
+                    num = ''
+            except OSError, args:
+                (errno, str) = args
+                if (errno != 4):
+                    raise IOError, args
+
+        try:
+            (pid, status) = os.waitpid(childpid, 0)
+        except OSError, (num, msg):
+            print __name__, "waitpid:", msg
+            
+        os.close(fd)
+
+        w and w.pop()
+        
+        isys.flushDriveDict()
+            
+        if os.WIFEXITED(status) and (os.WEXITSTATUS(status) == 0):
+            return 0
+
+        return 1
+
+    def openDevices (self, intf = None, initAll = 0, zeroMbr = 0):
+        """Open the disks on the system and skip unopenable devices."""
+        if self.disks:
+            return
+        for drive in self.driveList ():
+            if drive in DiskSet.skippedDisks and not initAll:
+                continue
+            deviceFile = isys.makeDevInode(drive)
+            if isys.driveIsRemovable(drive) and not flags.expert:
+                DiskSet.skippedDisks.append(drive)
+                continue
+            try:
+                dev = parted.PedDevice.get (deviceFile)
+            except parted.error, msg:
+                DiskSet.skippedDisks.append(drive)
+                continue
+            if initAll and not flags.test:
+                try:
+                    dev.disk_create(getDefaultDiskType())
+                    disk = parted.PedDisk.open(dev)
+                    self.disks[drive] = disk
+                except parted.error, msg:
+                    DiskSet.skippedDisks.append(drive)
+                continue
+                
+            try:
+                disk = parted.PedDisk.open(dev)
+                self.disks[drive] = disk
+            except parted.error, msg:
+                recreate = 0
+                if zeroMbr:
+                    log("zeroMBR was set and invalid partition table found "
+                        "on %s" % (dev.path[5:]))
+                    recreate = 1
+                elif not intf:
+                    DiskSet.skippedDisks.append(drive)
+                    continue
+                else:
+                    rc = intf.messageWindow(_("Warning"),
+                             _("The partition table on device %s was unreadable. "
+                               "To create new partitions it must be initialized, "
+                               "causing the loss of ALL DATA on this drive.\n\n"
+                               "Would you like to initialize this drive?")
+                                           % (drive,), type = "yesno")
+                    if rc == 0:
+                        DiskSet.skippedDisks.append(drive)
+                        continue
+                    else:
+                        recreate = 1
+
+                if recreate == 1 and not flags.test:
+                    if iutil.getArch() == "s390":
+                        if (self.dasdFmt(intf, drive)):
+                            DiskSet.skippedDisks.append(drive)
+                            continue
+                    else:                    
+                        try:
+                            dev.disk_create(getDefaultDiskType())
+                        except parted.error, msg:
+                            DiskSet.skippedDisks.append(drive)
+                            continue
+                    try:
+                        disk = parted.PedDisk.open(dev)
+                        self.disks[drive] = disk
+                    except parted.error, msg:
+                        DiskSet.skippedDisks.append(drive)
+                        continue
+
+            # check that their partition table is valid for their architecture
+            ret = checkDiskLabel(disk, intf)
+            if ret == 1:
+                DiskSet.skippedDisks.append(drive)
+                continue
+            elif ret == -1:
+                if iutil.getArch() == "s390":
+                    if (self.dasdFmt(intf, drive)):
+                        DiskSet.skippedDisks.append(drive)
+                        continue                    
+                else:
+                    try:
+                        dev.disk_create(getDefaultDiskType())
+                    except parted.error, msg:
+                        DiskSet.skippedDisks.append(drive)
+                        continue
+                try:
+                    disk = parted.PedDisk.open(dev)
+                    self.disks[drive] = disk
+                except parted.error, msg:
+                    DiskSet.skippedDisks.append(drive)
+                    continue
+
+    def partitionTypes (self):
+        """Return list of (partition, partition type) tuples for all parts."""
+        rc = []
+        drives = self.disks.keys()
+        drives.sort()
+
+        for drive in drives:
+            disk = self.disks[drive]
+            part = disk.next_partition ()
+            while part:
+                if part.type in (parted.PARTITION_PRIMARY,
+                                 parted.PARTITION_LOGICAL):
+                    device = get_partition_name(part)
+                    if part.fs_type:
+                        ptype = part.fs_type.name
+                    else:
+                        ptype = None
+                    rc.append((device, ptype))
+                part = disk.next_partition (part)
+      
+        return rc
+
+    def diskState (self):
+        """Print out current disk state.  DEBUG."""
+        rc = ""
+        for disk in self.disks.values():
+            rc = rc + ("%s: %s length %ld, maximum "
+                       "primary partitions: %d\n" %
+                       (disk.dev.path,
+                        disk.dev.model,
+                        disk.dev.length,
+                        disk.max_primary_partition_count))
+
+            part = disk.next_partition()
+            if part:
+                rc = rc + ("Device    Type         Filesystem   Start      "
+                           "End        Length        Flags\n")
+                rc = rc + ("------    ----         ----------   -----      "
+                           "---        ------        -----\n")
+            while part:
+                if not part.type & parted.PARTITION_METADATA:
+                    device = ""
+                    fs_type_name = ""
+                    if part.num > 0:
+                        device = get_partition_name(part)
+                    if part.fs_type:
+                        fs_type_name = part.fs_type.name
+                    partFlags = get_flags (part)
+                    rc = rc + ("%-9s %-12s %-12s %-10ld %-10ld %-10ld %7s\n"
+                               % (device, part.type_name, fs_type_name,
+                              part.geom.start, part.geom.end, part.geom.length,
+                              partFlags))
+                part = disk.next_partition(part)
+        return rc
+
+    def checkNoDisks(self, intf):
+        """Check that there are valid disk devices."""
+        if len(self.disks.keys()) == 0:
+            intf.messageWindow(_("No Drives Found"),
+                               _("An error has occurred - no valid devices were "
+                                 "found on which to create new filesystems. "
+                                 "Please check your hardware for the cause "
+                                 "of this problem."))
+            sys.exit(0)
+
+    
+
+
 
 # XXX is this all of the possibilities?
 dosPartitionTypes = [ 1, 6, 11, 12, 14, 15 ]
diff --git a/partitioning.py b/partitioning.py
index 2b50ed155..b0488d053 100644
--- a/partitioning.py
+++ b/partitioning.py
@@ -86,17 +86,18 @@ def get_raid_devices(requests):
     return raidRequests
 
 def register_raid_device(mdname, newdevices, newlevel, newnumActive):
-    for dev, devices, level, numActive in DiskSet.mdList:
+    for dev, devices, level, numActive in partedUtils.DiskSet.mdList:
         if mdname == dev:
             if (devices != newdevices or level != newlevel or
                 numActive != newnumActive):
                 raise ValueError, "%s is already in the mdList!" % (mdname,)
             else:
                 return
-    DiskSet.mdList.append((mdname, newdevices[:], newlevel, newnumActive))
+    partedUtils.DiskSet.mdList.append((mdname, newdevices[:], newlevel,
+                                       newnumActive))
 
 def lookup_raid_device(mdname):
-    for dev, devices, level, numActive in DiskSet.mdList:
+    for dev, devices, level, numActive in partedUtils.DiskSet.mdList:
         if mdname == dev:
             return (dev, devices, level, numActive)
     raise KeyError, "md device not found"
@@ -621,48 +622,6 @@ def deleteAllLogicalPartitions(part, requests):
             delete = DeleteSpec(drive, partition.geom.start, partition.geom.end)
             requests.addDelete(delete)
 
-# get the default partition table type for our architecture
-def getDefaultDiskType():
-    if iutil.getArch() == "i386":
-        return parted.disk_type_get("msdos")
-    elif iutil.getArch() == "ia64":
-        return parted.disk_type_get("GPT")
-    elif iutil.getArch() == "s390":
-        return parted.disk_type_get("dasd")
-    else:
-        # XXX fix me for alpha at least
-        return parted.disk_type_get("msdos")
-
-archLabels = {'i386': ['msdos'],
-              'alpha': ['bsd'],
-              's390': ['dasd'],
-              'ia64': ['msdos', 'GPT']}
-
-def checkDiskLabel(disk, intf):
-    arch = iutil.getArch()
-    if arch in archLabels.keys():
-        if disk.type.name in archLabels[arch]:
-            return 0
-    else:
-        if disk.type.name == "msdos":
-            return 0
-
-    if intf:
-        rc = intf.messageWindow(_("Warning"),
-                       _("The partition table on device /dev/%s is of an "
-                         "unexpected type %s for your architecture.  To "
-                         "use this disk for installation of Red Hat Linux, "
-                         "it must be re-initialized causing the loss of "
-                         "ALL DATA on this drive.\n\n"
-                         "Would you like to initialize this drive?")
-                       % (disk.dev.path[5:], disk.type.name), type = "yesno")
-        if rc == 0:
-            return 1
-        else:
-            return -1
-    else:
-        return 1
-
 class DeleteSpec:
     def __init__(self, drive, start, end):
         self.drive = drive
@@ -1284,410 +1243,6 @@ class Partitions:
 
             f.write("#raid %s\n" % (string.join(args)))
 
-class DiskSet:
-    skippedDisks = []
-    mdList = []
-    def __init__ (self):
-        self.disks = {}
-
-    def startAllRaid(self):
-        driveList = []
-        origDriveList = self.driveList()
-        for drive in origDriveList:
-            if not drive in DiskSet.skippedDisks:
-                driveList.append(drive)
-        DiskSet.mdList.extend(raid.startAllRaid(driveList))
-
-    def stopAllRaid(self):
-        raid.stopAllRaid(DiskSet.mdList)
-        while DiskSet.mdList:
-            DiskSet.mdList.pop()
-
-    def getLabels(self):
-        labels = {}
-        
-        drives = self.disks.keys()
-        drives.sort()
-
-        for drive in drives:
-            disk = self.disks[drive]
-            func = lambda part: (part.is_active() and
-                                 not (part.get_flag(parted.PARTITION_RAID)
-                                      or part.get_flag(parted.PARTITION_LVM))
-                                 and part.fs_type
-                                 and (part.fs_type.name == "ext2"
-                                      or part.fs_type.name == "ext3"))
-            parts = partedUtils.filter_partitions(disk, func)
-            for part in parts:
-                node = partedUtils.get_partition_name(part)
-                label = isys.readExt2Label(node)
-                if label:
-                    labels[node] = label
-
-        for dev, devices, level, numActive in DiskSet.mdList:
-            label = isys.readExt2Label(dev)
-            if label:
-                labels[dev] = label
-
-        return labels
-
-    def findExistingRootPartitions(self, intf, mountpoint):
-        rootparts = []
-
-        self.startAllRaid()
-
-        for dev, devices, level, numActive in self.mdList:
-            (errno, msg) = (None, None)
-            found = 0
-            for fs in fsset.getFStoTry(dev):
-                try:
-                    isys.mount(dev, mountpoint, fs, readOnly = 1)
-                    found = 1
-                    break
-                except SystemError, (errno, msg):
-                    pass
-
-            if not found:
-                intf.messageWindow(_("Error"),
-                                   _("Error mounting filesystem "
-                                     "on %s: %s") % (dev, msg))
-                continue
-
-            if os.access (mountpoint + '/etc/fstab', os.R_OK):
-                rootparts.append ((dev, fs))
-            isys.umount(mountpoint)
-
-        self.stopAllRaid()
-
-        drives = self.disks.keys()
-        drives.sort()
-
-        for drive in drives:
-            disk = self.disks[drive]
-            part = disk.next_partition ()
-            while part:
-                if (part.is_active()
-                    and (part.get_flag(parted.PARTITION_RAID)
-                         or part.get_flag(parted.PARTITION_LVM))):
-                    # skip RAID and LVM partitions.
-                    # XXX check for raid superblocks on non-autoraid partitions
-                    #  (#32562)
-                    pass
-                elif part.fs_type and part.fs_type.name in fsset.getUsableLinuxFs():
-                    node = partedUtils.get_partition_name(part)
-		    try:
-			isys.mount(node, mountpoint, part.fs_type.name)
-		    except SystemError, (errno, msg):
-			intf.messageWindow(_("Error"),
-                                           _("Error mounting filesystem on "
-                                             "%s: %s") % (node, msg))
-                        part = disk.next_partition(part)
-			continue
-		    if os.access (mountpoint + '/etc/fstab', os.R_OK):
-			rootparts.append ((node, part.fs_type.name))
-		    isys.umount(mountpoint)
-                elif part.fs_type and (part.fs_type.name == "FAT"):
-                    node = partedUtils.get_partition_name(part)
-                    try:
-                        isys.mount(node, mountpoint, fstype = "vfat",
-                                   readOnly = 1)
-                    except:
-			log("failed to mount vfat filesystem on %s\n" 
-                            % node)
-                        part = disk.next_partition(part)
-			continue
-                        
-		    if os.access(mountpoint + '/redhat.img', os.R_OK):
-                        rootparts.append((node, "vfat"))
-
-		    isys.umount(mountpoint)
-                    
-                part = disk.next_partition(part)
-        return rootparts
-
-    def driveList (self):
-	drives = isys.hardDriveDict().keys()
-	drives.sort (isys.compareDrives)
-	return drives
-
-    def drivesByName (self):
-	return isys.hardDriveDict()
-
-    def addPartition (self, device, type, spec):
-        if not self.disks.has_key (device):
-            raise PartitioningError, ("unknown device passed to "
-                                      "addPartition: %s" % (device,))
-        disk = self.disks[device]
-
-        part = disk.next_partition ()
-        status = 0
-        while part:
-            if (part.type == parted.PARTITION_FREESPACE
-                and part.geom.length >= spec.size):
-                newp = disk.partition_new (type, spec.fs_type,
-                                           part.geom.start,
-                                           part.geom.start + spec.size)
-                constraint = disk.constraint_any ()
-                try:
-                    disk.add_partition (newp, constraint)
-                    status = 1
-                    break
-                except parted.error, msg:
-                    raise PartitioningError, msg
-            part = disk.next_partition (part)
-        if not status:
-            raise PartitioningError, ("Not enough free space on %s to create "
-                                      "new partition" % (device,))
-        return newp
-    
-    def deleteAllPartitions (self):
-        for disk in self.disks.values():
-            disk.delete_all ()
-
-    def savePartitions (self):
-        for disk in self.disks.values():
-            disk.write()
-            del disk
-        self.refreshDevices()
-
-    def refreshDevices (self, intf = None, initAll = 0, zeroMbr = 0):
-        self.disks = {}
-        self.openDevices(intf, initAll, zeroMbr)
-
-    def closeDevices (self):
-        for disk in self.disks.keys():
-            del self.disks[disk]
-
-    def dasdFmt (self, intf = None, drive = None):
-        w = intf.progressWindow (_("Initializing"),
-                             _("Please wait while formatting drive %s...\n"
-                               ) % (drive,), 100)
-        try:
-            isys.makeDevInode(drive, '/tmp/' + drive)
-        except:
-            pass
-
-        argList = [ "/sbin/dasdfmt",
-                    "-y",
-                    "-b", "4096",
-                    "-d", "cdl",
-                    "-P",
-                    "-f",
-                    "/tmp/%s" % drive]
-        
-        fd = os.open("/dev/null", os.O_RDWR | os.O_CREAT | os.O_APPEND)
-        p = os.pipe()
-        childpid = os.fork()
-        if not childpid:
-            os.close(p[0])
-            os.dup2(p[1], 1)
-            os.dup2(fd, 2)
-            os.close(p[1])
-            os.close(fd)
-            os.execv(argList[0], argList)
-            log("failed to exec %s", argList)
-            sys.exit(1)
-			    
-        os.close(p[1])
-
-        num = ''
-        sync = 0
-        s = 'a'
-        while s:
-            try:
-                s = os.read(p[0], 1)
-                os.write(fd, s)
-
-                if s != '\n':
-                    try:
-                        num = num + s
-                    except:
-                        pass
-                else:
-                    if num:
-                        val = string.split(num)
-                        if (val[0] == 'cyl'):
-                            # printf("cyl %5d of %5d |  %3d%%\n",
-                            val = int(val[5][:-1])
-                            w and w.set(val)
-                            # sync every 10%
-                            if sync + 10 <= val:
-                                isys.sync()
-                                sync = val
-                    num = ''
-            except OSError, args:
-                (errno, str) = args
-                if (errno != 4):
-                    raise IOError, args
-
-        try:
-            (pid, status) = os.waitpid(childpid, 0)
-        except OSError, (num, msg):
-            print __name__, "waitpid:", msg
-            
-        os.close(fd)
-
-        w and w.pop()
-        
-        isys.flushDriveDict()
-            
-        if os.WIFEXITED(status) and (os.WEXITSTATUS(status) == 0):
-            return 0
-
-        return 1
-
-    def openDevices (self, intf = None, initAll = 0, zeroMbr = 0):
-        if self.disks:
-            return
-        for drive in self.driveList ():
-            if drive in DiskSet.skippedDisks and not initAll:
-                continue
-            deviceFile = isys.makeDevInode(drive)
-            if isys.driveIsRemovable(drive) and not flags.expert:
-                DiskSet.skippedDisks.append(drive)
-                continue
-            try:
-                dev = parted.PedDevice.get (deviceFile)
-            except parted.error, msg:
-                DiskSet.skippedDisks.append(drive)
-                continue
-            if initAll and not flags.test:
-                try:
-                    dev.disk_create(getDefaultDiskType())
-                    disk = parted.PedDisk.open(dev)
-                    self.disks[drive] = disk
-                except parted.error, msg:
-                    DiskSet.skippedDisks.append(drive)
-                continue
-                
-            try:
-                disk = parted.PedDisk.open(dev)
-                self.disks[drive] = disk
-            except parted.error, msg:
-                recreate = 0
-                if zeroMbr:
-                    log("zeroMBR was set and invalid partition table found "
-                        "on %s" % (dev.path[5:]))
-                    recreate = 1
-                elif not intf:
-                    DiskSet.skippedDisks.append(drive)
-                    continue
-                else:
-                    rc = intf.messageWindow(_("Warning"),
-                             _("The partition table on device %s was unreadable. "
-                               "To create new partitions it must be initialized, "
-                               "causing the loss of ALL DATA on this drive.\n\n"
-                               "Would you like to initialize this drive?")
-                                           % (drive,), type = "yesno")
-                    if rc == 0:
-                        DiskSet.skippedDisks.append(drive)
-                        continue
-                    else:
-                        recreate = 1
-
-                if recreate == 1 and not flags.test:
-                    if iutil.getArch() == "s390":
-                        if (self.dasdFmt(intf, drive)):
-                            DiskSet.skippedDisks.append(drive)
-                            continue
-                    else:                    
-                        try:
-                            dev.disk_create(getDefaultDiskType())
-                        except parted.error, msg:
-                            DiskSet.skippedDisks.append(drive)
-                            continue
-                    try:
-                        disk = parted.PedDisk.open(dev)
-                        self.disks[drive] = disk
-                    except parted.error, msg:
-                        DiskSet.skippedDisks.append(drive)
-                        continue
-
-            # check that their partition table is valid for their architecture
-            ret = checkDiskLabel(disk, intf)
-            if ret == 1:
-                DiskSet.skippedDisks.append(drive)
-                continue
-            elif ret == -1:
-                if iutil.getArch() == "s390":
-                    if (self.dasdFmt(intf, drive)):
-                        DiskSet.skippedDisks.append(drive)
-                        continue                    
-                else:
-                    try:
-                        dev.disk_create(getDefaultDiskType())
-                    except parted.error, msg:
-                        DiskSet.skippedDisks.append(drive)
-                        continue
-                try:
-                    disk = parted.PedDisk.open(dev)
-                    self.disks[drive] = disk
-                except parted.error, msg:
-                    DiskSet.skippedDisks.append(drive)
-                    continue
-
-    def partitionTypes (self):
-        rc = []
-        drives = self.disks.keys()
-        drives.sort()
-
-        for drive in drives:
-            disk = self.disks[drive]
-            part = disk.next_partition ()
-            while part:
-                if part.type in (parted.PARTITION_PRIMARY,
-                                 parted.PARTITION_LOGICAL):
-                    device = partedUtils.get_partition_name(part)
-                    if part.fs_type:
-                        ptype = part.fs_type.name
-                    else:
-                        ptype = None
-                    rc.append((device, ptype))
-                part = disk.next_partition (part)
-      
-        return rc
-
-    def diskState (self):
-        rc = ""
-        for disk in self.disks.values():
-            rc = rc + ("%s: %s length %ld, maximum "
-                       "primary partitions: %d\n" %
-                       (disk.dev.path,
-                        disk.dev.model,
-                        disk.dev.length,
-                        disk.max_primary_partition_count))
-
-            part = disk.next_partition()
-            if part:
-                rc = rc + ("Device    Type         Filesystem   Start      "
-                           "End        Length        Flags\n")
-                rc = rc + ("------    ----         ----------   -----      "
-                           "---        ------        -----\n")
-            while part:
-                if not part.type & parted.PARTITION_METADATA:
-                    device = ""
-                    fs_type_name = ""
-                    if part.num > 0:
-                        device = partedUtils.get_partition_name(part)
-                    if part.fs_type:
-                        fs_type_name = part.fs_type.name
-                    flags = partedUtils.get_flags (part)
-                    rc = rc + ("%-9s %-12s %-12s %-10ld %-10ld %-10ld %7s\n"
-                               % (device, part.type_name, fs_type_name,
-                              part.geom.start, part.geom.end, part.geom.length,
-                              flags))
-                part = disk.next_partition(part)
-        return rc
-
-def checkNoDisks(diskset, intf):
-    if len(diskset.disks.keys()) == 0:
-        intf.messageWindow(_("No Drives Found"),
-                           _("An error has occurred - no valid devices were "
-                             "found on which to create new filesystems. "
-                             "Please check your hardware for the cause "
-                             "of this problem."))
-        sys.exit(0)
-
 def partitionObjectsInitialize(diskset, partitions, dir, intf):
     if iutil.getArch() == "s390":
         partitions.useAutopartitioning = 0
@@ -1701,7 +1256,7 @@ def partitionObjectsInitialize(diskset, partitions, dir, intf):
     diskset.refreshDevices(intf, partitions.reinitializeDisks,
                            partitions.zeroMbr)
 
-    checkNoDisks(diskset, intf)
+    diskset.checkNoDisks(intf)
 
     partitions.setFromDisk(diskset)
 
diff --git a/textw/fdisk_text.py b/textw/fdisk_text.py
index 1b0cc4ee0..7f9e75631 100644
--- a/textw/fdisk_text.py
+++ b/textw/fdisk_text.py
@@ -66,7 +66,7 @@ class fdiskPartitionWindow:
 
 
         diskset.refreshDevices(intf)
-        partitioning.checkNoDisks(diskset, intf)
+        diskset.checkNoDisks(intf)
         partrequests.setFromDisk(diskset)
 
         if button == TEXT_BACK_CHECK:
diff --git a/upgrade.py b/upgrade.py
index 68f7a337b..4b42e913c 100644
--- a/upgrade.py
+++ b/upgrade.py
@@ -20,6 +20,7 @@ import time
 import rpm
 import sys
 import os.path
+import partedUtils
 from flags import flags
 from fsset import *
 from partitioning import *
@@ -36,7 +37,7 @@ def findRootParts(intf, id, dir, chroot):
 def findExistingRoots(intf, id, chroot):
     if not flags.setupFilesystems: return [(chroot, 'ext2')]
 
-    diskset = DiskSet()
+    diskset = partedUtils.DiskSet()
     diskset.openDevices()
     
     win = intf.waitWindow(_("Searching"),
@@ -51,7 +52,7 @@ def mountRootPartition(intf, rootInfo, oldfsset, instPath, allowDirty = 0,
 		       raiseErrors = 0):
     (root, rootFs) = rootInfo
 
-    diskset = DiskSet()
+    diskset = partedUtils.DiskSet()
     diskset.openDevices()
     diskset.startAllRaid()