Attachment 157973 Details for Bug 242294 – Test for fsset sorting problem.

Test for fsset sorting problem.

fsset-test.py (text/plain), 12.98 KB, created by Jeffrey Hutzelman on 2007-06-27 00:52:40 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Jeffrey Hutzelman

Created: 2007-06-27 00:52:40 UTC

Size: 12.98 KB

patch

obsolete

>#
># fsset.py: filesystem management
>#
># Matt Wilson <msw@redhat.com>
>#
># Copyright 2001-2006 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 string
>
>fileSystemTypes = {}
>
>def fileSystemTypeGet(key):
>    return fileSystemTypes[key]
>
>def fileSystemTypeRegister(klass):
>    fileSystemTypes[klass.getName()] = klass
>
>def fileSystemTypeGetTypes():
>    return fileSystemTypes.copy()
>
>def devify(device):
>    if device in ["proc", "devpts", "sysfs", "tmpfs"]:
>        return device
>    elif device == "sys":
>        return "sysfs"
>    elif device == "shm":
>        return "tmpfs"
>    elif device != "none" and device[0] != '/':
>        return "/dev/" + device
>    else:
>        return device
>
>class FileSystemType:
>    kernelFilesystems = {}
>    def __init__(self):
>        self.checked = 0
>        self.name = ""
>        self.maxSizeMB = 8 * 1024 * 1024
>        self.defaultOptions = "defaults"
>        self.extraFormatArgs = []
>        self.maxLabelChars = 16
>
>    def getName(self, quoted = 0):
>        """Return the name of the filesystem.  Set quoted to 1 if this
>        should be quoted (ie, it's not for display)."""
>        if quoted:
>            if self.name.find(" ") != -1:
>                return "\"%s\"" %(self.name,)
>        return self.name
>
>    def isChecked(self):
>        return self.checked
>
>    def getDefaultOptions(self, mountpoint):
>        return self.defaultOptions
>
>
>class extFileSystem(FileSystemType):
>    def __init__(self):
>        FileSystemType.__init__(self)
>        self.checked = 1
>        self.maxSizeMB = 8 * 1024 * 1024
>
>class ext2FileSystem(extFileSystem):
>    def __init__(self):
>        extFileSystem.__init__(self)
>        self.name = "ext2"
>
>fileSystemTypeRegister(ext2FileSystem())
>
>class ext3FileSystem(extFileSystem):
>    def __init__(self):
>        extFileSystem.__init__(self)
>        self.name = "ext3"
>        self.extraFormatArgs = [ "-j" ]
>
>
>fileSystemTypeRegister(ext3FileSystem())
>
>class raidMemberDummyFileSystem(FileSystemType):
>    def __init__(self):
>        FileSystemType.__init__(self)
>        self.checked = 0
>        self.name = "software RAID"
>        self.maxSizeMB = 8 * 1024 * 1024
>
>
>fileSystemTypeRegister(raidMemberDummyFileSystem())
>
>class lvmPhysicalVolumeDummyFileSystem(FileSystemType):
>    def __init__(self):
>        FileSystemType.__init__(self)
>        self.checked = 0
>        self.name = "physical volume (LVM)"
>        self.maxSizeMB = 8 * 1024 * 1024
>
>fileSystemTypeRegister(lvmPhysicalVolumeDummyFileSystem())
>
>class lvmVolumeGroupDummyFileSystem(FileSystemType):
>    def __init__(self):
>        FileSystemType.__init__(self)
>        self.checked = 0
>        self.name = "volume group (LVM)"
>        self.maxSizeMB = 8 * 1024 * 1024
>
>fileSystemTypeRegister(lvmVolumeGroupDummyFileSystem())
>
>class swapFileSystem(FileSystemType):
>    enabledSwaps = {}
>
>    def __init__(self):
>        FileSystemType.__init__(self)
>        self.name = "swap"
>        self.maxSizeMB = 8 * 1024 * 1024
>        self.maxLabelChars = 15
>
>
>fileSystemTypeRegister(swapFileSystem())
>
>
>class PsudoFileSystem(FileSystemType):
>    def __init__(self, name):
>        FileSystemType.__init__(self)
>        self.checked = 0
>        self.name = name
>
>class ProcFileSystem(PsudoFileSystem):
>    def __init__(self):
>        PsudoFileSystem.__init__(self, "proc")
>
>fileSystemTypeRegister(ProcFileSystem())
>
>class SysfsFileSystem(PsudoFileSystem):
>    def __init__(self):
>        PsudoFileSystem.__init__(self, "sysfs")
>
>fileSystemTypeRegister(SysfsFileSystem())
>
>class DevptsFileSystem(PsudoFileSystem):
>    def __init__(self):
>        PsudoFileSystem.__init__(self, "devpts")
>        self.defaultOptions = "gid=5,mode=620"
>
>fileSystemTypeRegister(DevptsFileSystem())
>
>class DevshmFileSystem(PsudoFileSystem):
>    def __init__(self):
>        PsudoFileSystem.__init__(self, "tmpfs")
>
>fileSystemTypeRegister(DevshmFileSystem())
>
>class FileSystemSet:
>    def __init__(self):
>        self.mountcount = 0
>        self.reset()
>
>    def reset (self):
>        self.entries = []
>        proc = FileSystemSetEntry(Device(device="proc"), '/proc',
>                                  fileSystemTypeGet("proc"))
>        self.add(proc)
>        sys = FileSystemSetEntry(Device(device="sys"), '/sys',
>                                 fileSystemTypeGet("sysfs"))
>        self.add(sys)
>        pts = FileSystemSetEntry(Device(device="devpts"), '/dev/pts',
>                                 fileSystemTypeGet("devpts"), "gid=5,mode=620")
>        self.add(pts)
>        shm = FileSystemSetEntry(Device(device="shm"), '/dev/shm',
>                                 fileSystemTypeGet("tmpfs"))
>        self.add(shm)
>
>    def add (self, newEntry):
>        # Should object A be sorted after object B?  Take mountpoints and
>        # device names into account so bind mounts are sorted correctly.
>        def comesAfter (a, b):
>            mntA = a.mountpoint
>            mntB = b.mountpoint
>            devA = a.device.getDevice()
>            devB = b.device.getDevice()
>
>            if not mntB or not devB:
>                return True
>            if not mntA or not devA:
>                return False
>
>            if (mntA.startswith(mntB) and mntA != mntB) or (devA.startswith(mntB) and devA != devB):
>                return True
>            else:
>                return False
>
>        # Remove preexisting duplicate entries - pseudo filesystems are
>        # duplicate if they have the same filesystem type as an existing one.
>        # Otherwise, they have to have the same device and mount point
>        # (required to check for bind mounts).
>        for existing in self.entries:
>            if (isinstance (newEntry.fsystem, PsudoFileSystem) and existing.fsystem.getName() == newEntry.fsystem.getName()) or (existing.device.getDevice() == newEntry.device.getDevice() and existing.mountpoint == newEntry.mountpoint):
>                self.remove(existing)
>
>        insertAt = 0
>
>        # Special case for /.
>        if newEntry.mountpoint == "/":
>            self.entries.insert(insertAt, newEntry)
>            return
>
>        # doesn't matter where these get added, so just put them at the end
>        if not newEntry.mountpoint or not newEntry.mountpoint.startswith("/") or self.entries == []:
>            self.entries.append(newEntry)
>            return
>
>        for entry in self.entries:
>            if comesAfter(newEntry, entry):
>                insertAt = self.entries.index(entry)+1
>
>        self.entries.insert(insertAt, newEntry)
>
>    def add_fixed (self, newEntry):
>        # Should object A be sorted after object B?  Take mountpoints and
>        # device names into account so bind mounts are sorted correctly.
>        def comesAfter (a, b):
>            mntA = a.mountpoint
>            mntB = b.mountpoint
>            devA = a.device.getDevice()
>            devB = b.device.getDevice()
>
>            if not mntB:
>                return False
>            if mntA and mntA != mntB and mntA.startswith(mntB):
>                return True
>            if devA and devA != mntB and devA.startswith(mntB):
>                return True
>            return False
>
>        # Remove preexisting duplicate entries - pseudo filesystems are
>        # duplicate if they have the same filesystem type as an existing one.
>        # Otherwise, they have to have the same device and mount point
>        # (required to check for bind mounts).
>        for existing in self.entries:
>            if (isinstance (newEntry.fsystem, PsudoFileSystem) and existing.fsystem.getName() == newEntry.fsystem.getName()) or (existing.device.getDevice() == newEntry.device.getDevice() and existing.mountpoint == newEntry.mountpoint):
>                self.remove(existing)
>
>        insertAt = 0
>
>        # Special case for /.
>        if newEntry.mountpoint == "/":
>            self.entries.insert(insertAt, newEntry)
>            return
>
>        # doesn't matter where these get added, so just put them at the end
>        if not newEntry.mountpoint or not newEntry.mountpoint.startswith("/") or self.entries == []:
>            self.entries.append(newEntry)
>            return
>
>        for entry in self.entries:
>            if comesAfter(newEntry, entry):
>                insertAt = self.entries.index(entry)+1
>
>        self.entries.insert(insertAt, newEntry)
>    def remove (self, entry):
>        self.entries.remove(entry)
>
>    def getEntryByMountPoint(self, mount):
>        for entry in self.entries:
>            if entry.mountpoint == mount:
>                return entry
>        return None
>
>    def getEntryByDeviceName(self, dev):
>        for entry in self.entries:
>            if entry.device.getDevice() == dev:
>                return entry
>        return None
>
>    def copy (self):
>        new = FileSystemSet()
>        for entry in self.entries:
>            new.add (entry)
>        return new
>    
>    def fstab (self):
>	format = "%-23s %-23s %-7s %-15s %d %d\n"
>        fstab = ""
>        for entry in self.entries:
>            if entry.mountpoint:
>                if entry.getLabel():
>                    device = "LABEL=%s" % (entry.getLabel(),)
>                else:
>                    device = devify(entry.device.getDevice())
>                fstab = fstab + entry.device.getComment()
>                fstab = fstab + format % (device, entry.mountpoint,
>                                          entry.fsystem.getName(),
>                                          entry.options, entry.fsck,
>                                          entry.order)
>        return fstab
>
>
>
>class FileSystemSetEntry:
>    def __init__ (self, device, mountpoint,
>                  fsystem=None, options=None,
>                  origfsystem=None, migrate=0,
>                  order=-1, fsck=-1, format=0,
>                  badblocks = 0, bytesPerInode=4096):
>        if not fsystem:
>            fsystem = fileSystemTypeGet("ext2")
>        self.device = device
>        self.mountpoint = mountpoint
>        self.fsystem = fsystem
>        self.origfsystem = origfsystem
>        if options:
>            self.options = options
>        else:
>            self.options = fsystem.getDefaultOptions(mountpoint)
>        self.options += device.getDeviceOptions()
>        self.mountcount = 0
>        self.label = None
>        if fsck == -1:
>            self.fsck = fsystem.isChecked()
>        else:
>            self.fsck = fsck
>        if order == -1:
>            if mountpoint == '/':
>                self.order = 1
>            elif self.fsck:
>                self.order = 2
>            else:
>                self.order = 0
>        else:
>            self.order = order
>        self.bytesPerInode = bytesPerInode
>
>    def setFileSystemType(self, fstype):
>        self.fsystem = fstype
>        
>    def getMountPoint(self):
>	return self.mountpoint
>        
>    def isMounted (self):
>        return self.mountcount > 0
>
>    def getLabel (self):
>        return self.label
>
>    def __str__(self):
>        if not self.mountpoint:
>            mntpt = "None"
>        else:
>            mntpt = self.mountpoint
>            
>        str = ("fsentry -- device: %(device)s   mountpoint: %(mountpoint)s\n"
>               "  fsystem: %(fsystem)s\n"
>               "  ismounted: %(mounted)s  options: '%(options)s'\n"
>               "  bytesPerInode: %(bytesPerInode)s label: %(label)s\n"%
>               {"device": self.device.getDevice(), "mountpoint": mntpt,
>                "fsystem": self.fsystem.getName(),
>                "mounted": self.mountcount, "options": self.options,
>                "bytesPerInode": self.bytesPerInode, "label": self.label})
>        return str
>        
>
>class Device:
>    def __init__(self, device = "none"):
>        self.device = device
>        self.deviceOptions = ""
>
>    def getComment (self):
>        return ""
>
>    def getDevice (self, asBoot = 0):
>        return self.device
>
>    def setupDevice (self, chroot='/', devPrefix='/tmp'):
>        return self.device
>
>    def getName(self):
>        return self.__class__.__name__
>
>    def getDeviceOptions(self):
>        return self.deviceOptions
>
>class PartitionDevice(Device):
>    def __init__(self, device = "none"):
>      Device.__init__(self, device)
>
>class VolumeGroupDevice(Device):
>    def __init__(self):
>      Device.__init__(self, "none")
>
>fsset = FileSystemSet()
>fsset2 = FileSystemSet()
>
>def addit2(dev, mtpt, fs):
>  fsset.add(FileSystemSetEntry(dev,  mtpt, fs))
>  fsset2.add_fixed(FileSystemSetEntry(dev, mtpt, fs))
>
>def addit(devname, mtpt, fsname):
>  addit2(Device(device=devname), mtpt, fileSystemTypeGet(fsname))
>
>addit('/dev/VolGroup00/LogVol00', '/',                  'ext3')
>addit('/dev/VolGroup00/LogVol04', 'swap',               'swap')
>addit('/dev/sda1',                '/boot',              'ext3')
>addit('/dev/VolGroup00/LogVol03', '/var/cache/openafs', 'ext2')
>addit2(VolumeGroupDevice(), None, None)
>addit2(PartitionDevice(),   None, fileSystemTypeGet("physical volume (LVM)"))
>addit('/dev/VolGroup00/LogVol01', '/usr0',              'ext3')
>addit('/dev/VolGroup00/LogVol02', '/var',               'ext3')
>
>print "Bad:\n", fsset.fstab()
>print "Good:\n", fsset2.fstab()

Actions: View

Attachments on bug 242294: 157973 | 157974