Move tsort, platform, and baseudev into storage.

Merge baseudev into storage.udev.

28 files changed, 201 insertions, 268 deletions

diff --git a/anaconda b/anaconda
index 2bfd7ab90..9ad9844d4 100755
--- a/anaconda
+++ b/anaconda
@@ -983,7 +983,7 @@ if __name__ == "__main__":
 
     if anaconda.rescue:
         from pyanaconda.rescue import doRescue
-        doRescue(anaconda.rescue_mount, ksdata, anaconda.platform)
+        doRescue(anaconda.rescue_mount, ksdata)
 
 
     networkInitialize(ksdata)
diff --git a/pyanaconda/__init__.py b/pyanaconda/__init__.py
index 0b8119b87..4767080d8 100644
--- a/pyanaconda/__init__.py
+++ b/pyanaconda/__init__.py
@@ -63,7 +63,6 @@ class Anaconda(object):
         self._network = None
         self.opts = None
         self._payload = None
-        self._platform = None
         self.proxy = None
         self.proxyUsername = None
         self.proxyPassword = None
@@ -87,7 +86,7 @@ class Anaconda(object):
     @property
     def bootloader(self):
         if not self._bootloader:
-            self._bootloader = get_bootloader(self.platform)
+            self._bootloader = get_bootloader()
 
         return self._bootloader
 
@@ -141,14 +140,6 @@ class Anaconda(object):
         return self._payload
 
     @property
-    def platform(self):
-        if not self._platform:
-            from pyanaconda import platform
-            self._platform = platform.getPlatform()
-
-        return self._platform
-
-    @property
     def protected(self):
         import stat
 
@@ -165,7 +156,7 @@ class Anaconda(object):
     def storage(self):
         if not self._storage:
             import storage
-            self._storage = storage.Storage(data=self.ksdata, platform=self.platform)
+            self._storage = storage.Storage(data=self.ksdata)
 
         return self._storage
 
diff --git a/pyanaconda/baseudev.py b/pyanaconda/baseudev.py
deleted file mode 100644
index cd8d0168e..000000000
--- a/pyanaconda/baseudev.py
+++ /dev/null
@@ -1,95 +0,0 @@
-# udev.py
-# Python module for querying the udev database for device information.
-#
-# Copyright (C) 2009  Red Hat, Inc.
-#
-# This copyrighted material is made available to anyone wishing to use,
-# modify, copy, or redistribute it subject to the terms and conditions of
-# the GNU General Public License v.2, or (at your option) any later version.
-# This program is distributed in the hope that it will be useful, but WITHOUT
-# ANY WARRANTY expressed or implied, including the implied warranties of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General
-# Public License for more details.  You should have received a copy of the
-# GNU General Public License along with this program; if not, write to the
-# Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
-# 02110-1301, USA.  Any Red Hat trademarks that are incorporated in the
-# source code or documentation are not subject to the GNU General Public
-# License and may only be used or replicated with the express permission of
-# Red Hat, Inc.
-#
-# Red Hat Author(s): Dave Lehman <dlehman@redhat.com>
-#                    Chris Lumens <clumens@redhat.com>
-#
-
-import iutil
-import os
-
-import pyudev
-global_udev = pyudev.Udev()
-
-import logging
-log = logging.getLogger("storage")
-
-def udev_enumerate_devices(deviceClass="block"):
-    devices = global_udev.enumerate_devices(subsystem=deviceClass)
-    return [path[4:] for path in devices]
-
-def udev_get_device(sysfs_path):
-    if not os.path.exists("/sys%s" % sysfs_path):
-        log.debug("%s does not exist" % sysfs_path)
-        return None
-
-    # XXX we remove the /sys part when enumerating devices,
-    # so we have to prepend it when creating the device
-    dev = global_udev.create_device("/sys" + sysfs_path)
-
-    if dev:
-        dev["name"] = dev.sysname
-        dev["sysfs_path"] = sysfs_path
-
-        # now add in the contents of the uevent file since they're handy
-        dev = udev_parse_uevent_file(dev)
-
-    return dev
-
-def udev_get_devices(deviceClass="block"):
-    udev_settle()
-    entries = []
-    for path in udev_enumerate_devices(deviceClass):
-        entry = udev_get_device(path)
-        if entry:
-            entries.append(entry)
-    return entries
-
-def udev_parse_uevent_file(dev):
-    path = os.path.normpath("/sys/%s/uevent" % dev['sysfs_path'])
-    if not os.access(path, os.R_OK):
-        return dev
-
-    with open(path) as f:
-        for line in f.readlines():
-            (key, equals, value) = line.strip().partition("=")
-            if not equals:
-                continue
-
-            dev[key] = value
-
-    return dev
-
-def udev_settle():
-    # wait maximal 300 seconds for udev to be done running blkid, lvm,
-    # mdadm etc. This large timeout is needed when running on machines with
-    # lots of disks, or with slow disks
-    argv = ["settle", "--timeout=300"]
-
-    iutil.execWithRedirect("udevadm", argv)
-
-def udev_trigger(subsystem=None, action="add", name=None):
-    argv = ["trigger", "--action=%s" % action]
-    if subsystem:
-        argv.append("--subsystem-match=%s" % subsystem)
-    if name:
-        argv.append("--sysname-match=%s" % name)
-
-    iutil.execWithRedirect("udevadm", argv)
-    udev_settle()
diff --git a/pyanaconda/bootloader.py b/pyanaconda/bootloader.py
index b3a60ff69..4d7d38fdf 100644
--- a/pyanaconda/bootloader.py
+++ b/pyanaconda/bootloader.py
@@ -36,7 +36,7 @@ from pyanaconda.constants import *
 from pyanaconda.storage.errors import StorageError
 from pyanaconda.storage.fcoe import fcoe
 import pyanaconda.network
-from pyanaconda import platform as _platform
+from pyanaconda.storage import platform
 
 import gettext
 _ = lambda x: gettext.ldgettext("anaconda", x)
@@ -250,10 +250,7 @@ class BootLoader(object):
 
     _trusted_boot = False
 
-    def __init__(self, platform=None):
-        # pyanaconda.platform.Platform instance
-        self.platform = platform
-
+    def __init__(self):
         self.boot_args = Arguments()
         self.dracut_args = Arguments()
 
@@ -371,11 +368,11 @@ class BootLoader(object):
     #
     @property
     def disklabel_types(self):
-        return self.platform._disklabel_types
+        return platform.platform._disklabel_types
 
     @property
     def device_descriptions(self):
-        return self.platform.bootStage1ConstraintDict["descriptions"]
+        return platform.platform.bootStage1ConstraintDict["descriptions"]
 
     #
     # constraint checking for target devices
@@ -556,7 +553,7 @@ class BootLoader(object):
         self.errors = []
         self.warnings = []
         valid = True
-        constraint = self.platform.bootStage1ConstraintDict
+        constraint = platform.platform.bootStage1ConstraintDict
 
         if device is None:
             return False
@@ -699,7 +696,7 @@ class BootLoader(object):
                                      desc=self.stage2_description):
             valid = False
 
-        non_linux_format_types = self.platform._non_linux_format_types
+        non_linux_format_types = platform.platform._non_linux_format_types
         if non_linux and \
            not self._is_valid_format(device,
                                      format_types=non_linux_format_types):
@@ -982,8 +979,8 @@ class GRUB(BootLoader):
 
     packages = ["grub"]
 
-    def __init__(self, platform=None):
-        super(GRUB, self).__init__(platform=platform)
+    def __init__(self):
+        super(GRUB, self).__init__()
         self.encrypted_password = ""
 
     #
@@ -1365,8 +1362,8 @@ class GRUB2(GRUB):
         else:
             return ["ext4", "ext3", "ext2", "btrfs", "xfs"]
 
-    def __init__(self, platform=None):
-        super(GRUB2, self).__init__(platform=platform)
+    def __init__(self):
+        super(GRUB2, self).__init__()
         self.boot_args.add("$([ -x /usr/sbin/rhcrashkernel-param ] && "\
                            "/usr/sbin/rhcrashkernel-param || :)")
 
@@ -1607,8 +1604,8 @@ class EFIGRUB(GRUB2):
     def _config_dir(self):
         return "efi/EFI/%s" % (self.efi_dir,)
 
-    def __init__(self, platform=None):
-        super(EFIGRUB, self).__init__(platform=platform)
+    def __init__(self):
+        super(EFIGRUB, self).__init__()
         self.efi_dir = 'BOOT'
 
     def efibootmgr(self, *args, **kwargs):
@@ -2003,8 +2000,8 @@ class ZIPL(BootLoader):
     image_label_attr = "short_label"
     preserve_args = ["cio_ignore"]
 
-    def __init__(self, platform=None):
-        super(ZIPL, self).__init__(platform=platform)
+    def __init__(self):
+        super(ZIPL, self).__init__()
         self.stage1_name = None
 
     #
@@ -2193,22 +2190,22 @@ class UBOOT(BootLoader):
 
 
 # every platform that wants a bootloader needs to be in this dict
-bootloader_by_platform = {_platform.X86: GRUB2,
-                          _platform.EFI: EFIGRUB,
-                          _platform.MacEFI: MacEFIGRUB,
-                          _platform.PPC: GRUB2,
-                          _platform.IPSeriesPPC: IPSeriesGRUB2,
-                          _platform.NewWorldPPC: MacYaboot,
-                          _platform.S390: ZIPL,
-                          _platform.Sparc: SILO,
-                          _platform.ARM: UBOOT,
-                          _platform.omapARM: UBOOT}
-
-def get_bootloader(platform):
-    platform_name = platform.__class__.__name__
-    cls = bootloader_by_platform.get(platform.__class__, BootLoader)
+bootloader_by_platform = {platform.X86: GRUB2,
+                          platform.EFI: EFIGRUB,
+                          platform.MacEFI: MacEFIGRUB,
+                          platform.PPC: GRUB2,
+                          platform.IPSeriesPPC: IPSeriesGRUB2,
+                          platform.NewWorldPPC: MacYaboot,
+                          platform.S390: ZIPL,
+                          platform.Sparc: SILO,
+                          platform.ARM: UBOOT,
+                          platform.omapARM: UBOOT}
+
+def get_bootloader():
+    platform_name = platform.platform.__class__.__name__
+    cls = bootloader_by_platform.get(platform.platform.__class__, BootLoader)
     log.info("bootloader %s on %s platform" % (cls.__name__, platform_name))
-    return cls(platform)
+    return cls()
 
 
 # anaconda-specific functions
diff --git a/pyanaconda/installclass.py b/pyanaconda/installclass.py
index 2e817f225..888d0810c 100644
--- a/pyanaconda/installclass.py
+++ b/pyanaconda/installclass.py
@@ -32,6 +32,7 @@ from constants import *
 from product import *
 from storage.partspec import *
 from storage.devicelibs import swap
+from storage.platform import platform
 
 import gettext
 _ = lambda x: gettext.ldgettext("anaconda", x)
@@ -105,7 +106,7 @@ class BaseInstallClass(object):
                                  size=500, grow=True, requiredSpace=50*1024,
                                  btr=True, lv=True, encrypted=True)]
 
-        bootreqs = storage.platform.setDefaultPartitioning()
+        bootreqs = platform.setDefaultPartitioning()
         if bootreqs:
             autorequests.extend(bootreqs)
 
diff --git a/pyanaconda/kickstart.py b/pyanaconda/kickstart.py
index a723039b1..0d5da2893 100644
--- a/pyanaconda/kickstart.py
+++ b/pyanaconda/kickstart.py
@@ -43,7 +43,6 @@ import shlex
 import sys
 import urlgrabber
 import pykickstart.commands as commands
-from storage.devices import *
 from pyanaconda.storage import arch
 from pyanaconda import keyboard
 from pyanaconda import ntp
diff --git a/pyanaconda/packaging/__init__.py b/pyanaconda/packaging/__init__.py
index d184c6a21..75ea61f93 100644
--- a/pyanaconda/packaging/__init__.py
+++ b/pyanaconda/packaging/__init__.py
@@ -55,6 +55,7 @@ from pyanaconda.errors import *
 from pyanaconda.storage.errors import StorageError
 from pyanaconda.storage import util
 from pyanaconda.storage import arch
+from pyanaconda.storage.platform import platform
 #from pyanaconda.progress import progress
 
 from pyanaconda.product import productName, productVersion
@@ -655,8 +656,8 @@ class PackagePayload(Payload):
 
         # most ARM systems use platform-specific kernels
         if arch.isARM():
-            if self.storage.platform.armMachine is not None:
-                kernels = ["kernel-%s" % self.storage.platform.armMachine]
+            if platform.armMachine is not None:
+                kernels = ["kernel-%s" % platform.armMachine]
 
         return kernels
 
@@ -717,7 +718,6 @@ if __name__ == "__main__":
     import os
     import sys
     import pyanaconda.storage as _storage
-    import pyanaconda.platform as _platform
     from pykickstart.version import makeVersion
     from pyanaconda.packaging.yumpayload import YumPayload
 
@@ -731,9 +731,8 @@ if __name__ == "__main__":
     #ksdata.method.url = "http://husky/install/f17/os/"
     #ksdata.method.url = "http://dl.fedoraproject.org/pub/fedora/linux/development/17/x86_64/os/"
 
-    # set up storage and platform
-    platform = _platform.getPlatform()
-    storage = _storage.Storage(data=ksdata, platform=platform)
+    # set up storage
+    storage = _storage.Storage(data=ksdata)
     storage.reset()
 
     # set up the payload
diff --git a/pyanaconda/rescue.py b/pyanaconda/rescue.py
index 3a37570e4..9b3be6d52 100644
--- a/pyanaconda/rescue.py
+++ b/pyanaconda/rescue.py
@@ -191,7 +191,7 @@ def runShell(screen = None, msg=""):
     if screen:
         screen.finish()
 
-def doRescue(rescue_mount, ksdata, platform):
+def doRescue(rescue_mount, ksdata):
     import storage
 
     for file in [ "services", "protocols", "group", "joe", "man.config",
@@ -242,7 +242,7 @@ def doRescue(rescue_mount, ksdata, platform):
 
             break
 
-    sto = storage.Storage(ksdata, platform)
+    sto = storage.Storage(ksdata)
     storage.storageInitialize(sto, ksdata, [])
     roots = storage.findExistingInstallations(sto.devicetree)
 
diff --git a/pyanaconda/storage/__init__.py b/pyanaconda/storage/__init__.py
index f6cd38096..bc973e3cd 100644
--- a/pyanaconda/storage/__init__.py
+++ b/pyanaconda/storage/__init__.py
@@ -41,7 +41,6 @@ import nss.nss
 import parted
 
 from pykickstart.constants import *
-from pyanaconda import tsort
 
 from storage_log import log_method_call
 from errors import *
@@ -69,6 +68,7 @@ import dasd
 import util
 import arch
 from flags import flags
+from platform import platform as _platform
 
 import shelve
 import contextlib
@@ -278,17 +278,14 @@ class StorageDiscoveryConfig(object):
         self.zeroMbr = ksdata.zerombr.zerombr
 
 class Storage(object):
-    def __init__(self, data=None, platform=None):
+    def __init__(self, data=None):
         """ Create a Storage instance.
 
             Keyword Arguments:
 
                 data        -   a pykickstart Handler instance
-                platform    -   a Platform instance
-
         """
         self.data = data
-        self.platform = platform
         self._bootloader = None
 
         self.config = StorageDiscoveryConfig()
@@ -784,9 +781,6 @@ class Storage(object):
                 - Needs some error handling
 
         """
-        if not hasattr(self.platform, "diskLabelTypes"):
-            raise StorageError("can't clear partitions without platform data")
-
         # Sort partitions by descending partition number to minimize confusing
         # things like multiple "destroy sda5" actions due to parted renumbering
         # partitions. This can still happen through the UI but it makes sense to
@@ -842,10 +836,7 @@ class Storage(object):
         destroy_action = ActionDestroyFormat(disk)
         self.devicetree.registerAction(destroy_action)
 
-        if self.platform:
-            labelType = self.platform.bestDiskLabelType(disk)
-        else:
-            labelType = None
+        labelType = _platform.bestDiskLabelType(disk)
 
         # create a new disklabel on the disk
         newLabel = getFormat("disklabel", device=disk.path,
@@ -1049,7 +1040,7 @@ class Storage(object):
             if fmt:
                 mountpoint = getattr(fmt, "mountpoint", None)
 
-                kwargs["weight"] = self.platform.weight(mountpoint=mountpoint,
+                kwargs["weight"] = _platform.weight(mountpoint=mountpoint,
                                                         fstype=fmt.type)
 
 
@@ -1569,7 +1560,7 @@ class Storage(object):
             #
             # check that GPT boot disk on BIOS system has a BIOS boot partition
             #
-            if self.platform.weight(fstype="biosboot") and \
+            if _platform.weight(fstype="biosboot") and \
                stage1 and stage1.isDisk and \
                getattr(stage1.format, "labelType", None) == "gpt":
                 missing = True
@@ -1645,8 +1636,7 @@ class Storage(object):
     @property
     def packages(self):
         pkgs = set()
-        if self.platform:
-            pkgs.update(self.platform.packages)
+        pkgs.update(_platform.packages)
 
         if self.bootloader:
             pkgs.update(self.bootloader.packages)
@@ -1691,9 +1681,8 @@ class Storage(object):
 
     @property
     def bootloader(self):
-        if self._bootloader is None and self.platform is not None and \
-           flags.installer_mode:
-            self._bootloader = get_bootloader(self.platform)
+        if self._bootloader is None and flags.installer_mode:
+            self._bootloader = get_bootloader()
 
         return self._bootloader
 
diff --git a/pyanaconda/storage/dasd.py b/pyanaconda/storage/dasd.py
index abf97b90f..bd3d4debc 100644
--- a/pyanaconda/storage/dasd.py
+++ b/pyanaconda/storage/dasd.py
@@ -26,7 +26,7 @@ from pyanaconda.storage.devices import deviceNameToDiskByPath
 from pyanaconda.storage import util
 from pyanaconda.storage import arch
 from . import ROOT_PATH
-from pyanaconda.baseudev import udev_trigger
+from .udev import udev_trigger
 
 import logging
 log = logging.getLogger("storage")
diff --git a/pyanaconda/storage/devicetree.py b/pyanaconda/storage/devicetree.py
index 0a5e7cdb5..f0d49f727 100644
--- a/pyanaconda/storage/devicetree.py
+++ b/pyanaconda/storage/devicetree.py
@@ -41,8 +41,8 @@ import devicelibs.loop
 import devicelibs.edd
 from udev import *
 import util
-from pyanaconda import platform
-from pyanaconda import tsort
+from platform import platform
+import tsort
 from flags import flags
 from storage_log import log_method_call, log_method_return
 import parted
@@ -97,8 +97,6 @@ class DeviceTree(object):
         self.dasd = dasd
         self.mpathFriendlyNames = getattr(conf, "mpathFriendlyNames", True)
 
-        self.platform = platform.getPlatform()
-
         self.diskImages = {}
         images = getattr(conf, "diskImages", {})
         if images:
@@ -1064,7 +1062,7 @@ class DeviceTree(object):
 
         # we're going to pass the "best" disklabel type into the DiskLabel
         # constructor, but it only has meaning for non-existent disklabels.
-        labelType = self.platform.bestDiskLabelType(device)
+        labelType = platform.bestDiskLabelType(device)
 
         try:
             format = getFormat("disklabel",
diff --git a/pyanaconda/storage/fcoe.py b/pyanaconda/storage/fcoe.py
index 22c6258b2..8e8e301e6 100644
--- a/pyanaconda/storage/fcoe.py
+++ b/pyanaconda/storage/fcoe.py
@@ -19,7 +19,7 @@
 
 import os
 from . import util
-from pyanaconda.baseudev import udev_settle
+from .udev import udev_settle
 #from pyanaconda import isys
 from . import ROOT_PATH
 import logging
diff --git a/pyanaconda/storage/formats/biosboot.py b/pyanaconda/storage/formats/biosboot.py
index 861b59190..c3aef8d2b 100644
--- a/pyanaconda/storage/formats/biosboot.py
+++ b/pyanaconda/storage/formats/biosboot.py
@@ -23,6 +23,7 @@
 from parted import PARTITION_BIOS_GRUB
 
 from ..errors import *
+from .. import platform
 from . import DeviceFormat, register_device_format
 
 class BIOSBoot(DeviceFormat):
@@ -53,8 +54,7 @@ class BIOSBoot(DeviceFormat):
 
     @property
     def supported(self):
-        from pyanaconda import platform
-        return isinstance(platform.getPlatform(), platform.X86)
+        return isinstance(platform.platform, platform.X86)
 
 register_device_format(BIOSBoot)
 
diff --git a/pyanaconda/storage/formats/fs.py b/pyanaconda/storage/formats/fs.py
index 1d355c3be..b472e8727 100644
--- a/pyanaconda/storage/formats/fs.py
+++ b/pyanaconda/storage/formats/fs.py
@@ -35,6 +35,7 @@ import selinux
 from ..errors import *
 from . import DeviceFormat, register_device_format
 from .. import util
+from .. import platform
 from ..flags import flags
 from parted import fileSystemType
 from ..storage_log import log_method_call
@@ -975,9 +976,7 @@ class EFIFS(FATFS):
 
     @property
     def supported(self):
-        from pyanaconda import platform
-        p = platform.getPlatform()
-        return (isinstance(p, platform.EFI) and
+        return (isinstance(platform.platform, platform.EFI) and
                 self.utilsAvailable)
 
 register_device_format(EFIFS)
@@ -1210,8 +1209,7 @@ class AppleBootstrapFS(HFS):
 
     @property
     def supported(self):
-        from pyanaconda import platform
-        return (isinstance(platform.getPlatform(), platform.NewWorldPPC)
+        return (isinstance(platform.platform, platform.NewWorldPPC)
                 and self.utilsAvailable)
 
 register_device_format(AppleBootstrapFS)
diff --git a/pyanaconda/storage/formats/prepboot.py b/pyanaconda/storage/formats/prepboot.py
index 884aa8fc4..dd2cf8c82 100644
--- a/pyanaconda/storage/formats/prepboot.py
+++ b/pyanaconda/storage/formats/prepboot.py
@@ -21,6 +21,7 @@
 #
 
 from ..errors import *
+from .. import platform
 from . import DeviceFormat, register_device_format
 from parted import PARTITION_PREP
 import os
@@ -80,8 +81,7 @@ class PPCPRePBoot(DeviceFormat):
 
     @property
     def supported(self):
-        from pyanaconda import platform
-        return isinstance(platform.getPlatform(), platform.IPSeriesPPC)
+        return isinstance(platform.platform, platform.IPSeriesPPC)
 
 register_device_format(PPCPRePBoot)
 
diff --git a/pyanaconda/storage/partitioning.py b/pyanaconda/storage/partitioning.py
index 64aa250eb..243c62b80 100644
--- a/pyanaconda/storage/partitioning.py
+++ b/pyanaconda/storage/partitioning.py
@@ -721,9 +721,6 @@ def doPartitioning(storage):
             None
 
     """
-    if not hasattr(storage.platform, "diskLabelTypes"):
-        raise StorageError(_("can't allocate partitions without platform data"))
-
     disks = storage.partitioned
     if storage.config.exclusiveDisks:
         disks = [d for d in disks if d.name in storage.config.exclusiveDisks]
diff --git a/pyanaconda/platform.py b/pyanaconda/storage/platform.py
index 39b49ece2..5221a3065 100644
--- a/pyanaconda/platform.py
+++ b/pyanaconda/storage/platform.py
@@ -21,13 +21,13 @@
 #
 import os
 import logging
-log = logging.getLogger("anaconda")
+log = logging.getLogger("storage")
 
 import parted
 
-from pyanaconda.storage import arch
-
-from flags import flags
+from . import arch
+from .flags import flags
+from .partspec import PartSpec
 
 import gettext
 _ = lambda x: gettext.ldgettext("anaconda", x)
@@ -70,6 +70,9 @@ class Platform(object):
             self._disklabel_types.remove("gpt")
             self._disklabel_types.insert(0, "gpt")
 
+    def __call__(self):
+        return self
+
     @property
     def diskLabelTypes(self):
         """A list of valid disklabel types for this architecture."""
@@ -128,13 +131,12 @@ class Platform(object):
     @property
     def packages (self):
         _packages = self._packages
-        if flags.cmdline.get('fips', None) == '1':
+        if flags.boot_cmdline.get('fips', None) == '1':
             _packages.append('dracut-fips')
         return _packages
 
     def setDefaultPartitioning(self):
         """Return the default platform-specific partitioning information."""
-        from storage.partspec import PartSpec
         return [PartSpec(mountpoint="/boot",
                          size=500, weight=self.weight(mountpoint="/boot"))]
 
@@ -165,7 +167,6 @@ class X86(Platform):
 
     def setDefaultPartitioning(self):
         """Return the default platform-specific partitioning information."""
-        from storage.partspec import PartSpec
         ret = Platform.setDefaultPartitioning(self)
         ret.append(PartSpec(fstype="biosboot", size=1,
                             weight=self.weight(fstype="biosboot")))
@@ -194,7 +195,6 @@ class EFI(Platform):
     _non_linux_format_types = ["vfat", "ntfs", "hpfs"]
 
     def setDefaultPartitioning(self):
-        from storage.partspec import PartSpec
         ret = Platform.setDefaultPartitioning(self)
         ret.append(PartSpec(mountpoint="/boot/efi", fstype="efi", size=20,
                             maxSize=200,
@@ -217,7 +217,6 @@ class MacEFI(EFI):
     _packages = ["mactel-boot"]
 
     def setDefaultPartitioning(self):
-        from storage.partspec import PartSpec
         ret = Platform.setDefaultPartitioning(self)
         ret.append(PartSpec(mountpoint="/boot/efi", fstype="hfs+", size=20,
                             maxSize=200,
@@ -240,7 +239,6 @@ class IPSeriesPPC(PPC):
     _disklabel_types = ["msdos"]
 
     def setDefaultPartitioning(self):
-        from storage.partspec import PartSpec
         ret = PPC.setDefaultPartitioning(self)
         ret.append(PartSpec(fstype="prepboot", size=4,
                             weight=self.weight(fstype="prepboot")))
@@ -263,7 +261,6 @@ class NewWorldPPC(PPC):
     _non_linux_format_types = ["hfs", "hfs+"]
 
     def setDefaultPartitioning(self):
-        from storage.partspec import PartSpec
         ret = Platform.setDefaultPartitioning(self)
         ret.append(PartSpec(fstype="appleboot", size=1, maxSize=1,
                             weight=self.weight(fstype="appleboot")))
@@ -296,7 +293,6 @@ class S390(Platform):
 
     def setDefaultPartitioning(self):
         """Return the default platform-specific partitioning information."""
-        from storage.partspec import PartSpec
         return [PartSpec(mountpoint="/boot", size=500,
                          weight=self.weight(mountpoint="/boot"), lv=True,
                          singlePV=True)]
@@ -354,7 +350,6 @@ class omapARM(ARM):
 
     def setDefaultPartitioning(self):
         """Return the ARM-OMAP platform-specific partitioning information."""
-        from storage.partspec import PartSpec
         ret = [PartSpec(mountpoint="/boot/uboot", fstype="vfat",
                         size=20, maxSize=200, grow=True,
                         weight=self.weight(fstype="vfat", mountpoint="/boot/uboot"))]
@@ -409,3 +404,6 @@ def getPlatform():
             return ARM()
     else:
         raise SystemError, "Could not determine system architecture."
+
+global platform
+platform = getPlatform()
diff --git a/pyanaconda/pyudev.py b/pyanaconda/storage/pyudev.py
index 705b93d80..705b93d80 100644
--- a/pyanaconda/pyudev.py
+++ b/pyanaconda/storage/pyudev.py
diff --git a/pyanaconda/tsort.py b/pyanaconda/storage/tsort.py
index 52a871f56..52a871f56 100644
--- a/pyanaconda/tsort.py
+++ b/pyanaconda/storage/tsort.py
diff --git a/pyanaconda/storage/udev.py b/pyanaconda/storage/udev.py
index cb9601b1e..f8ba09c9b 100644
--- a/pyanaconda/storage/udev.py
+++ b/pyanaconda/storage/udev.py
@@ -1,7 +1,7 @@
 # udev.py
 # Python module for querying the udev database for device information.
 #
-# Copyright (C) 2009  Red Hat, Inc.
+# Copyright (C) 2009, 2013  Red Hat, Inc.
 #
 # This copyrighted material is made available to anyone wishing to use,
 # modify, copy, or redistribute it subject to the terms and conditions of
@@ -18,6 +18,7 @@
 # Red Hat, Inc.
 #
 # Red Hat Author(s): Dave Lehman <dlehman@redhat.com>
+#                    Chris Lumens <clumens@redhat.com>
 #
 
 import os
@@ -25,11 +26,75 @@ import re
 
 import util
 from errors import *
-from pyanaconda.baseudev import *
+
+import pyudev
+global_udev = pyudev.Udev()
 
 import logging
 log = logging.getLogger("storage")
 
+def udev_enumerate_devices(deviceClass="block"):
+    devices = global_udev.enumerate_devices(subsystem=deviceClass)
+    return [path[4:] for path in devices]
+
+def udev_get_device(sysfs_path):
+    if not os.path.exists("/sys%s" % sysfs_path):
+        log.debug("%s does not exist" % sysfs_path)
+        return None
+
+    # XXX we remove the /sys part when enumerating devices,
+    # so we have to prepend it when creating the device
+    dev = global_udev.create_device("/sys" + sysfs_path)
+
+    if dev:
+        dev["name"] = dev.sysname
+        dev["sysfs_path"] = sysfs_path
+
+        # now add in the contents of the uevent file since they're handy
+        dev = udev_parse_uevent_file(dev)
+
+    return dev
+
+def udev_get_devices(deviceClass="block"):
+    udev_settle()
+    entries = []
+    for path in udev_enumerate_devices(deviceClass):
+        entry = udev_get_device(path)
+        if entry:
+            entries.append(entry)
+    return entries
+
+def udev_parse_uevent_file(dev):
+    path = os.path.normpath("/sys/%s/uevent" % dev['sysfs_path'])
+    if not os.access(path, os.R_OK):
+        return dev
+
+    with open(path) as f:
+        for line in f.readlines():
+            (key, equals, value) = line.strip().partition("=")
+            if not equals:
+                continue
+
+            dev[key] = value
+
+    return dev
+
+def udev_settle():
+    # wait maximal 300 seconds for udev to be done running blkid, lvm,
+    # mdadm etc. This large timeout is needed when running on machines with
+    # lots of disks, or with slow disks
+    util.run_program(["udevadm", "settle", "--timeout=300"])
+
+def udev_trigger(subsystem=None, action="add", name=None):
+    argv = ["trigger", "--action=%s" % action]
+    if subsystem:
+        argv.append("--subsystem-match=%s" % subsystem)
+    if name:
+        argv.append("--sysname-match=%s" % name)
+
+    util.run_program(["udevadm"] + argv)
+    udev_settle()
+
 def udev_resolve_devspec(devspec):
     if not devspec:
         return None
diff --git a/pyanaconda/ui/gui/spokes/storage.py b/pyanaconda/ui/gui/spokes/storage.py
index 9aa510f87..a91d30242 100644
--- a/pyanaconda/ui/gui/spokes/storage.py
+++ b/pyanaconda/ui/gui/spokes/storage.py
@@ -53,6 +53,7 @@ from pyanaconda.ui.gui.utils import enlightbox, gtk_call_once, gtk_thread_wait
 from pyanaconda.kickstart import doKickstartStorage
 from pyanaconda.storage.size import Size
 from pyanaconda.storage.errors import StorageError
+from pyanaconda.storage.platform import platform
 from pyanaconda.threads import threadMgr, AnacondaThread
 from pyanaconda.product import productName
 from pyanaconda.flags import flags
@@ -668,7 +669,7 @@ class StorageSpoke(NormalSpoke, StorageChecker):
         # any of the free space to be useful.
         disk_labels = set([disk.format.labelType for disk in disks \
                                                  if hasattr(disk.format, "labelType")])
-        platform_labels = set(self.storage.platform.diskLabelTypes)
+        platform_labels = set(platform.diskLabelTypes)
         if disk_labels and platform_labels.isdisjoint(disk_labels):
             disk_free = 0
             fs_free = 0
diff --git a/pyanaconda/ui/gui/tools/run-spoke.py b/pyanaconda/ui/gui/tools/run-spoke.py
index 2a16ab843..92173e747 100755
--- a/pyanaconda/ui/gui/tools/run-spoke.py
+++ b/pyanaconda/ui/gui/tools/run-spoke.py
@@ -30,7 +30,6 @@ from pyanaconda.installclass import DefaultInstall
 from pyanaconda.storage import Storage
 from pyanaconda.threads import initThreading
 from pyanaconda.packaging.yumpayload import YumPayload
-from pyanaconda.platform import getPlatform
 from pykickstart.version import makeVersion
 
 # Don't worry with fcoe, iscsi, dasd, any of that crud.
@@ -89,9 +88,8 @@ if not spokeClass:
 
 print "Running %s %s from %s" % (spokeText, spokeClass, spokeModule)
 
-platform = getPlatform()
 ksdata = makeVersion()
-storage = Storage(data=ksdata, platform=platform)
+storage = Storage(data=ksdata)
 storage.reset()
 instclass = DefaultInstall()
 
diff --git a/pyanaconda/ui/tui/tools/run-text-spoke.py b/pyanaconda/ui/tui/tools/run-text-spoke.py
index b542fcb8b..bc132f885 100755
--- a/pyanaconda/ui/tui/tools/run-text-spoke.py
+++ b/pyanaconda/ui/tui/tools/run-text-spoke.py
@@ -16,7 +16,6 @@ from pyanaconda.installclass import DefaultInstall
 from pyanaconda.storage import Storage
 from pyanaconda.threads import initThreading
 from pyanaconda.packaging.yumpayload import YumPayload
-from pyanaconda.platform import getPlatform
 from pykickstart.version import makeVersion
 from pyanaconda.ui.tui.simpleline import App
 from pyanaconda.ui.tui import YesNoDialog
@@ -79,9 +78,8 @@ if not spokeClass:
 
 print "Running %s %s from %s" % (spokeText, spokeClass, spokeModule)
 
-platform = getPlatform()
 ksdata = makeVersion()
-storage = Storage(data=ksdata, platform=platform)
+storage = Storage(data=ksdata)
 storage.reset()
 instclass = DefaultInstall()
 app = App("TEST HARNESS", yes_or_no_question = YesNoDialog)
diff --git a/tests/kickstart_test/commands_test.py b/tests/kickstart_test/commands_test.py
index 6fce53cd9..feb71325e 100644
--- a/tests/kickstart_test/commands_test.py
+++ b/tests/kickstart_test/commands_test.py
@@ -40,14 +40,14 @@ class CommandVersionTestCase(TestCase):
             'pyanaconda.storage.devicelibs.lvm',
             'pyanaconda.storage.iscsi',
             'pyanaconda.storage.fcoe',
+            'pyanaconda.storage.udev',
             'pyanaconda.storage.zfcp',
             'iutil',
             'constants',
             'flags',
             'anaconda_log',
             'parted',
-            'block',
-            'baseudev'])
+            'block'])
 
         import pyanaconda.anaconda_log
         pyanaconda.anaconda_log.init()
diff --git a/tests/pyanaconda_test/Makefile.am b/tests/pyanaconda_test/Makefile.am
index cd9b1890a..889d867e5 100644
--- a/tests/pyanaconda_test/Makefile.am
+++ b/tests/pyanaconda_test/Makefile.am
@@ -25,7 +25,6 @@ ANACDIR = $(top_builddir)/pyanaconda
 TESTS_ENVIRONMENT = PYTHONPATH=$(top_builddir)/tests:$(ANACDIR)/isys/.libs:$(ANACDIR):$(top_builddir)
 
 TESTS = backend_test.py \
-    baseudev_test.py \
     bootloader_test.py \
     cmdline_test.py \
     desktop_test.py \
diff --git a/tests/storage_test/storagetestcase.py b/tests/storage_test/storagetestcase.py
index 428913725..8e5df1db4 100644
--- a/tests/storage_test/storagetestcase.py
+++ b/tests/storage_test/storagetestcase.py
@@ -44,7 +44,7 @@ class StorageTestCase(TestCase):
         pyanaconda.iutil.execWithRedirect = Mock()
         pyanaconda.iutil.execWithCapture = Mock()
         pyanaconda.iutil.execWithPulseProgress = Mock()
-        pyanaconda.baseudev = Mock()
+        pyanaconda.storage.udev = Mock()
 
         self.anaconda = Mock()
         self.setUpStorage()
diff --git a/tests/tsort_test.py b/tests/storage_test/tsort_test.py
index d16ee7635..cb96997bf 100644
--- a/tests/tsort_test.py
+++ b/tests/storage_test/tsort_test.py
@@ -1,33 +1,33 @@
 
 import unittest
-import pyanaconda.tsort
+import pyanaconda.storage.tsort
 
 class TopologicalSortTestCase(unittest.TestCase):
     def runTest(self):
         items = [1, 2, 3, 4, 5]
         edges = [(5, 4), (4, 3), (3, 2), (2, 1)]
-        graph = pyanaconda.tsort.create_graph(items, edges)
+        graph = pyanaconda.storage.tsort.create_graph(items, edges)
         self._tsortTest(graph)
 
         edges = [(5, 4), (2, 3), (1, 5)]
-        graph = pyanaconda.tsort.create_graph(items, edges)
+        graph = pyanaconda.storage.tsort.create_graph(items, edges)
         self._tsortTest(graph)
 
         edges = [(5, 4), (4, 3), (3, 2), (2, 1), (3, 5)]
-        graph = pyanaconda.tsort.create_graph(items, edges)
-        self.failUnlessRaises(pyanaconda.tsort.CyclicGraphError,
-                              pyanaconda.tsort.tsort,
+        graph = pyanaconda.storage.tsort.create_graph(items, edges)
+        self.failUnlessRaises(pyanaconda.storage.tsort.CyclicGraphError,
+                              pyanaconda.storage.tsort.tsort,
                               graph)
 
         edges = [(5, 4), (4, 3), (3, 2), (2, 1), (2, 3)]
-        graph = pyanaconda.tsort.create_graph(items, edges)
-        self.failUnlessRaises(pyanaconda.tsort.CyclicGraphError,
-                              pyanaconda.tsort.tsort,
+        graph = pyanaconda.storage.tsort.create_graph(items, edges)
+        self.failUnlessRaises(pyanaconda.storage.tsort.CyclicGraphError,
+                              pyanaconda.storage.tsort.tsort,
                               graph)
 
         items = ['a', 'b', 'c', 'd']
         edges = [('a', 'c'), ('c', 'b')]
-        graph = pyanaconda.tsort.create_graph(items, edges)
+        graph = pyanaconda.storage.tsort.create_graph(items, edges)
         self._tsortTest(graph)
 
     def _tsortTest(self, graph):
@@ -40,7 +40,7 @@ class TopologicalSortTestCase(unittest.TestCase):
             return True
 
         try:
-            order = pyanaconda.tsort.tsort(graph)
+            order = pyanaconda.storage.tsort.tsort(graph)
         except Exception as e:
             self.fail(e)
 
diff --git a/tests/pyanaconda_test/baseudev_test.py b/tests/storage_test/udev_test.py
index 4dd422b88..5d48279b4 100644
--- a/tests/pyanaconda_test/baseudev_test.py
+++ b/tests/storage_test/udev_test.py
@@ -3,22 +3,22 @@
 import mock
 import os
 
-class BaseudevTest(mock.TestCase):
+class UdevTest(mock.TestCase):
 
     def setUp(self):
         self.setupModules(["_isys", "block", "ConfigParser"])
         self.fs = mock.DiskIO()
 
-        import pyanaconda.baseudev
-        pyanaconda.baseudev.os = mock.Mock()
-        pyanaconda.baseudev.log = mock.Mock()
-        pyanaconda.baseudev.open = self.fs.open
+        import pyanaconda.storage.udev
+        pyanaconda.storage.udev.os = mock.Mock()
+        pyanaconda.storage.udev.log = mock.Mock()
+        pyanaconda.storage.udev.open = self.fs.open
 
     def tearDown(self):
         self.tearDownModules()
 
     def udev_enumerate_devices_test(self):
-        import pyanaconda.baseudev
+        import pyanaconda.storage.udev
         ENUMERATE_LIST = [
             '/sys/devices/pci0000:00/0000:00:1f.2/host0/target0:0:0/0:0:0:0/block/sda',
             '/sys/devices/virtual/block/loop0',
@@ -28,8 +28,8 @@ class BaseudevTest(mock.TestCase):
             '/sys/devices/virtual/block/dm-0',
         ]
 
-        pyanaconda.baseudev.global_udev.enumerate_devices = mock.Mock(return_value=ENUMERATE_LIST)
-        ret = pyanaconda.baseudev.udev_enumerate_devices()
+        pyanaconda.storage.udev.global_udev.enumerate_devices = mock.Mock(return_value=ENUMERATE_LIST)
+        ret = pyanaconda.storage.udev.udev_enumerate_devices()
         self.assertEqual(set(ret),
             set(['/devices/pci0000:00/0000:00:1f.2/host0/target0:0:0/0:0:0:0/block/sda',
             '/devices/virtual/block/loop0', '/devices/virtual/block/loop1',
@@ -38,7 +38,7 @@ class BaseudevTest(mock.TestCase):
         )
 
     def udev_get_device_1_test(self):
-        import pyanaconda.baseudev
+        import pyanaconda.storage.udev
 
         class Device(object):
             def __init__(self):
@@ -61,55 +61,55 @@ class BaseudevTest(mock.TestCase):
             def __setitem__(self, key, value):
                 self.dict[key] = value
 
-        pyanaconda.baseudev.os.path.exists.return_value = True
+        pyanaconda.storage.udev.os.path.exists.return_value = True
         DEV_PATH = '/devices/virtual/block/loop1'
         dev = Device()
-        pyanaconda.baseudev.global_udev = mock.Mock()
-        pyanaconda.baseudev.global_udev.create_device.return_value = dev
-        pyanaconda.baseudev.udev_parse_uevent_file = mock.Mock(return_value=dev)
+        pyanaconda.storage.udev.global_udev = mock.Mock()
+        pyanaconda.storage.udev.global_udev.create_device.return_value = dev
+        pyanaconda.storage.udev.udev_parse_uevent_file = mock.Mock(return_value=dev)
 
-        ret = pyanaconda.baseudev.udev_get_device(DEV_PATH)
+        ret = pyanaconda.storage.udev.udev_get_device(DEV_PATH)
         self.assertTrue(isinstance(ret, Device))
         self.assertEqual(ret['name'], ret.sysname)
         self.assertEqual(ret['sysfs_path'], DEV_PATH)
-        self.assertTrue(pyanaconda.baseudev.udev_parse_uevent_file.called)
+        self.assertTrue(pyanaconda.storage.udev.udev_parse_uevent_file.called)
 
     def udev_get_device_2_test(self):
-        import pyanaconda.baseudev
-        pyanaconda.baseudev.os.path.exists.return_value = False
-        ret = pyanaconda.baseudev.udev_get_device('')
+        import pyanaconda.storage.udev
+        pyanaconda.storage.udev.os.path.exists.return_value = False
+        ret = pyanaconda.storage.udev.udev_get_device('')
         self.assertEqual(ret, None)
 
     def udev_get_device_3_test(self):
-        import pyanaconda.baseudev
-        pyanaconda.baseudev.os.path.exists.return_value = True
-        pyanaconda.baseudev.global_udev = mock.Mock()
-        pyanaconda.baseudev.global_udev.create_device.return_value = None
-        ret = pyanaconda.baseudev.udev_get_device('')
+        import pyanaconda.storage.udev
+        pyanaconda.storage.udev.os.path.exists.return_value = True
+        pyanaconda.storage.udev.global_udev = mock.Mock()
+        pyanaconda.storage.udev.global_udev.create_device.return_value = None
+        ret = pyanaconda.storage.udev.udev_get_device('')
         self.assertEqual(ret, None)
 
     def udev_get_devices_test(self):
-        import pyanaconda.baseudev
-        pyanaconda.baseudev.udev_settle = mock.Mock()
+        import pyanaconda.storage.udev
+        pyanaconda.storage.udev.udev_settle = mock.Mock()
         DEVS = \
             ['/devices/pci0000:00/0000:00:1f.2/host0/target0:0:0/0:0:0:0/block/sda',
             '/devices/virtual/block/loop0', '/devices/virtual/block/loop1',
             '/devices/virtual/block/ram0', '/devices/virtual/block/ram1',
             '/devices/virtual/block/dm-0']
-        pyanaconda.baseudev.udev_enumerate_devices = mock.Mock(return_value=DEVS)
-        pyanaconda.baseudev.udev_get_device = lambda x: x
-        ret = pyanaconda.baseudev.udev_get_devices()
+        pyanaconda.storage.udev.udev_enumerate_devices = mock.Mock(return_value=DEVS)
+        pyanaconda.storage.udev.udev_get_device = lambda x: x
+        ret = pyanaconda.storage.udev.udev_get_devices()
         self.assertEqual(ret, DEVS)
 
     def udev_parse_uevent_file_1_test(self):
-        import pyanaconda.baseudev
-        pyanaconda.baseudev.os.path.normpath = os.path.normpath
-        pyanaconda.baseudev.os.access.return_value = True
+        import pyanaconda.storage.udev
+        pyanaconda.storage.udev.os.path.normpath = os.path.normpath
+        pyanaconda.storage.udev.os.access.return_value = True
 
         FILE_CONTENT = "MAJOR=7\nMINOR=1\nDEVNAME=loop1\nDEVTYPE=disk\n"
         self.fs.open('/sys/devices/virtual/block/loop1/uevent', 'w').write(FILE_CONTENT)
         dev = {'sysfs_path': '/devices/virtual/block/loop1'}
-        ret = pyanaconda.baseudev.udev_parse_uevent_file(dev)
+        ret = pyanaconda.storage.udev.udev_parse_uevent_file(dev)
         self.assertEqual(ret,
             {'sysfs_path': '/devices/virtual/block/loop1',
             'DEVNAME': 'loop1',
@@ -118,22 +118,22 @@ class BaseudevTest(mock.TestCase):
             'MINOR': '1'})
 
     def udev_parse_uevent_file_2_test(self):
-        import pyanaconda.baseudev
-        pyanaconda.baseudev.os.path.normpath = os.path.normpath
-        pyanaconda.baseudev.os.access.return_value = False
+        import pyanaconda.storage.udev
+        pyanaconda.storage.udev.os.path.normpath = os.path.normpath
+        pyanaconda.storage.udev.os.access.return_value = False
 
         dev = {'sysfs_path': '/devices/virtual/block/loop1'}
-        ret = pyanaconda.baseudev.udev_parse_uevent_file(dev)
+        ret = pyanaconda.storage.udev.udev_parse_uevent_file(dev)
         self.assertEqual(ret, {'sysfs_path': '/devices/virtual/block/loop1'})
 
     def udev_settle_test(self):
-        import pyanaconda.baseudev
-        pyanaconda.baseudev.iutil = mock.Mock()
-        pyanaconda.baseudev.udev_settle()
-        self.assertTrue(pyanaconda.baseudev.iutil.execWithRedirect.called)
+        import pyanaconda.storage.udev
+        pyanaconda.storage.udev.util = mock.Mock()
+        pyanaconda.storage.udev.udev_settle()
+        self.assertTrue(pyanaconda.storage.udev.util.run_program.called)
 
     def udev_trigger_test(self):
-        import pyanaconda.baseudev
-        pyanaconda.baseudev.iutil = mock.Mock()
-        pyanaconda.baseudev.udev_trigger()
-        self.assertTrue(pyanaconda.baseudev.iutil.execWithRedirect.called)
+        import pyanaconda.storage.udev
+        pyanaconda.storage.udev.util = mock.Mock()
+        pyanaconda.storage.udev.udev_trigger()
+        self.assertTrue(pyanaconda.storage.udev.util.run_program.called)