You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
tde-guidance/mountconfig/MicroHAL.py

889 lines
38 KiB

#!/usr/bin/python
###########################################################################
# MicroHAL.py - #
# ------------------------------ #
# begin : Tue Oct 30 2004 #
# copyright : (C) 2004 by Simon Edwards #
# email : simon@simonzone.com #
# #
###########################################################################
# #
# This program is free software; you can redistribute it and/or modify #
# it under the terms of the GNU General Public License as published by #
# the Free Software Foundation; either version 2 of the License, or #
# (at your option) any later version. #
# #
###########################################################################
import os
import os.path
from SimpleCommandRunner import *
############################################################################
class MicroHAL__(object):
# Major device numbers for Linux block devices that support partitions.
partitionblockdevs = [
3, # IDE harddisks
8, # SCSI disks
13, # 8-bit MFM/RLL/IDE controller
14, # BIOS harddrive callback support {2.6}
21, # Acorn MFM hard drive interface
22, # Second IDE hard disk/CD-ROM interface
28, # ACSI disk (68k/Atari)
33, # Third IDE hard disk/CD-ROM interface
34, # Fourth IDE hard disk/CD-ROM interface
36, # MCA ESDI hard disk
44, # Flash Translation Layer (FTL) filesystems
45, # Parallel port IDE disk devices
48, # Mylex DAC960 PCI RAID controller; first controller
49, # Mylex DAC960 PCI RAID controller; second controller
50, # Mylex DAC960 PCI RAID controller; third controller
51, # Mylex DAC960 PCI RAID controller; fourth controller
52, # Mylex DAC960 PCI RAID controller; fifth controller
53, # Mylex DAC960 PCI RAID controller; sixth controller
54, # Mylex DAC960 PCI RAID controller; seventh controller
55, # Mylex DAC960 PCI RAID controller; eigth controller
56, # Fifth IDE hard disk/CD-ROM interface
57, # Sixth IDE hard disk/CD-ROM interface
65, # SCSI disk devices (16-31)
66, # SCSI disk devices (32-47)
67, # SCSI disk devices (48-63)
68, # SCSI disk devices (64-79)
69, # SCSI disk devices (80-95)
70, # SCSI disk devices (96-111)
71, # SCSI disk devices (112-127)
72, # Compaq Intelligent Drive Array, first controller
73, # Compaq Intelligent Drive Array, second controller
74, # Compaq Intelligent Drive Array, third controller
75, # Compaq Intelligent Drive Array, fourth controller
76, # Compaq Intelligent Drive Array, fifth controller
77, # Compaq Intelligent Drive Array, sixth controller
78, # Compaq Intelligent Drive Array, seventh controller
79, # Compaq Intelligent Drive Array, eigth controller
80, # I2O hard disk
81, # I2O hard disk
82, # I2O hard disk
83, # I2O hard disk
84, # I2O hard disk
85, # I2O hard disk
86, # I2O hard disk
87, # I2O hard disk
88, # Seventh IDE hard disk/CD-ROM interface
89, # Eighth IDE hard disk/CD-ROM interface
90, # Ninth IDE hard disk/CD-ROM interface
91, # Tenth IDE hard disk/CD-ROM interface
92, # PPDD encrypted disk driver
95, # IBM S/390 DASD block storage
101, # AMI HyperDisk RAID controller
102, # Compressed block device
104, # Compaq Next Generation Drive Array, first controller
105, # Compaq Next Generation Drive Array, second controller
106, # Compaq Next Generation Drive Array, third controller
107, # Compaq Next Generation Drive Array, fourth controller
108, # Compaq Next Generation Drive Array, fifth controller
109, # Compaq Next Generation Drive Array, sixth controller
110, # Compaq Next Generation Drive Array, seventh controller
111, # Compaq Next Generation Drive Array, eigth controller
112, # IBM iSeries virtual disk
114, # IDE BIOS powered software RAID interfaces such as the Promise Fastrak
128, # SCSI disk devices (128-143)
129, # SCSI disk devices (144-159)
130, # SCSI disk devices (160-175)
131, # SCSI disk devices (176-191)
132, # SCSI disk devices (192-207)
133, # SCSI disk devices (208-223)
134, # SCSI disk devices (224-239)
135, # SCSI disk devices (240-255)
136, # Mylex DAC960 PCI RAID controller; ninth controller
137, # Mylex DAC960 PCI RAID controller; tenth controller
138, # Mylex DAC960 PCI RAID controller; eleventh controller
139, # Mylex DAC960 PCI RAID controller; twelfth controller
140, # Mylex DAC960 PCI RAID controller; thirteenth controller
141, # Mylex DAC960 PCI RAID controller; fourteenth controller
142, # Mylex DAC960 PCI RAID controller; fifteenth controller
143, # Mylex DAC960 PCI RAID controller; sixteenth controller
160, # Promise SX8 8-port SATA Disks on First Controller
161 # Promise SX8 8-port SATA Disks on Second Controller
]
floppydevs = [
2, # Floppy disks
40 # Syquest EZ135 parallel port removable drive
]
cdromsdevs = [
11, # SCSI CD-ROM devices
12, # MSCDEX CD-ROM callback support {2.6}
15, # Sony CDU-31A/CDU-33A CD-ROM
16, # GoldStar CD-ROM
17, # Optics Storage CD-ROM
18, # Sanyo CD-ROM
20, # Hitachi CD-ROM (under development)
23, # Mitsumi proprietary CD-ROM
24, # Sony CDU-535 CD-ROM
25, # First Matsushita (Panasonic/SoundBlaster) CD-ROM
26, # Second Matsushita (Panasonic/SoundBlaster) CD-ROM
27, # Third Matsushita (Panasonic/SoundBlaster) CD-ROM
28, # Fourth Matsushita (Panasonic/SoundBlaster) CD-ROM
29, # Aztech/Orchid/Okano/Wearnes CD-ROM
30, # Philips LMS CM-205 CD-ROM
32, # Philips LMS CM-206 CD-ROM
41, # MicroSolutions BackPack parallel port CD-ROM
46, # Parallel port ATAPI CD-ROM devices
47, # Parallel port ATAPI disk devices
48, # Mylex DAC960 PCI RAID controller; first controller
113 # IBM iSeries virtual CD-ROM
]
burnerpacketdevs = [
97 # Packet writing for CD/DVD devices
]
# We provide a mapping between filesystems and kernelmodules, so filesystems
# that are built as modules can be loaded on demand. (In fact, mountconfig will
# load all filesystem modules needed to be able to mount all fstab entries.)
FilesystemProcDriver = [
# fstab name, /proc name, kernel module name
('auto','autofs','autofs4'),
('iso9660','iso9660','isofs'),
('nfs','nfsd','nfs')
]
############################################################################
def __init__(self):
self.devices = None
self.supportedfs = None
self.partitionsizelines = None
############################################################################
def getDevices(self):
if self.devices is None:
self.devices = []
# Scan through /sys/block for devices. Find out which disks are
# installed and should be shown in the listview. For real
# disks we put a 'group' in the listview and under the group
# we list the partitions, whether they are mounted or not.
# FIXME: Check if sysfs is mounted.
blockdevices = os.listdir("/sys/block")
blockdevices.sort()
for blockdevice in blockdevices:
# We are looking for block devices that represent hard disks or
# things that have partitions.
# Grab the major device number
fhandle = open(os.path.join("/sys/block",blockdevice,"dev"))
devnumbers = fhandle.read()
fhandle.close()
devnum = int(devnumbers.split(":")[0])
# Is it on our list of partition devices?
if devnum in MicroHAL.partitionblockdevs:
fulldevice = os.path.join("/dev",blockdevice)
# Check for removable devices.
fhandle = open(os.path.join("/sys/block",blockdevice,"removable"))
removable = fhandle.read().strip()=="1"
fhandle.close()
if not removable:
newdisk = Disk()
else:
if os.readlink(os.path.join("/sys/block",blockdevice,"device")).split(os.path.sep)[5].startswith("usb"):
newdisk = USBDisk()
else:
newdisk = RemovableDisk()
newdisk.dev = fulldevice
newdisk.major = devnum
newdisk.removable = removable
newdisk.modelname = self.getModelName(fulldevice)
if not removable or isinstance(newdisk, USBDisk):
# We have a not removable block device or a USB Disk here.
partitions = os.listdir(os.path.join("/sys/block",blockdevice))
partitions.sort()
i = 1
for partition in partitions:
# Look for a partitions device names and not the other
# stuff that lives in the directory.
if partition.startswith(blockdevice):
fullpartition = os.path.join("/dev",partition)
newpartition = Partition()
newpartition.dev = fullpartition
newpartition.size = self.getPartitionSize(fullpartition)
newpartition.num = i
newdisk.partitions.append(newpartition)
i += 1
self.devices.append(newdisk)
elif devnum in MicroHAL.cdromsdevs:
fulldevice = os.path.join("/dev",blockdevice)
newdisk = RemovableDisk()
newdisk.dev = fulldevice
newdisk.major = devnum
newdisk.modelname = self.getModelName(fulldevice)
self.devices.append(newdisk)
elif devnum in MicroHAL.burnerpacketdevs:
fulldevice = os.path.join("/dev",blockdevice)
newdisk = BurnerDisk(self)
newdisk.dev = fulldevice
newdisk.major = devnum
newdisk.modelname = self.getModelName(fulldevice)
self.devices.append(newdisk)
return self.devices[:]
############################################################################
def getPartitionSize(self,devicename):
partitionname = os.path.basename(devicename)
if self.partitionsizelines is None:
fhandle = open('/proc/partitions')
self.partitionsizelines = fhandle.readlines()
fhandle.close()
i = 0
for line in self.partitionsizelines:
if i>=2:
(major, minor, blocks, name) = line.split()
if name==partitionname:
blocks = int(blocks) # 1K blocks now.
if blocks<1024:
return str(blocks)+" Kb"
if blocks<1024*1024:
return str(round(float(blocks)/1024.0,1))+" Mb"
blocks /= 1024
if blocks<1024*1024:
return str(round(float(blocks)/1024.0,1))+" Gb"
blocks /= 1024
return str(round(float(blocks)/1024.0,1))+" Tb"
i += 1
return None
############################################################################
def getIDEModel(self,devname):
try:
fhandle = open(os.path.join("/proc/ide",os.path.basename(devname),"model"))
model = fhandle.read()
fhandle.close()
return model.strip()
except (OSError, IOError):
return None
############################################################################
def getSCSIModel(self,devname):
try:
fhandle_model = open(os.path.join("/sys/block",os.path.basename(devname),"device/model"))
fhandle_vendor = open(os.path.join("/sys/block",os.path.basename(devname),"device/vendor"))
model = fhandle_model.read()[:-1]
vendor = fhandle_vendor.read()[:-1]
fhandle_model.close()
fhandle_vendor.close()
except (OSError, IOError):
pass
if len(model) + len(vendor) == 0:
return None
return vendor + " " + model
############################################################################
def getModelName(self,devname):
modelname = self.getIDEModel(devname)
if modelname is None:
modelname = self.getSCSIModel(devname)
if modelname is None:
modelname = devname
return " '"+modelname+"'"
############################################################################
def getSupportedFileSystems(self):
if self.supportedfs is None:
if os.path.isfile("/proc/filesystems"):
fhandle = open("/proc/filesystems")
self.supportedfs = []
for fs in fhandle.readlines():
try:
self.supportedfs.append(fs.strip().split()[1])
except IndexError:
self.supportedfs.append(fs.strip().split()[0])
# The following filesystems aren't found there, but usually they are
# supported.
self.supportedfs.extend(('swap','shm'))
return self.supportedfs[:]
############################################################################
def isSupportedFileSystem(self,fs):
# Look up the /proc and kernel driver name for the given filesystem type.
module = fs
proc = fs
for entry in self.FilesystemProcDriver:
if entry[0]==fs:
proc = entry[1]
module = entry[2]
if proc not in self.getSupportedFileSystems():
# The filesystem is not supported by the running kernel,
# but it might be built as module, so we try to load that.
retval, msg = SimpleCommandRunner().run([b"/sbin/modprobe",module])
if retval > 0:
print(msg)
print("Couldn't load driver " + module + " for filesystem " + fs)
# Force refresh of list of supported filesystems
self.supportedfs = None
return proc in self.getSupportedFileSystems()
############################################################################
class Device(object):
def __init__(self):
self.dev = None
self.major = None
self.removable = None
self.uuid = None
self.label = None
def getDev(self):
return self.dev
def getMajor(self):
return self.major
def getName(self):
return self.dev
def getUUID(self):
if not self.uuid:
return ""
return self.uuid
def getLabel(self):
if not self.label:
return ""
return self.label
def isRemovable(self):
return self.removable
def __str__(self):
return "Name: %s, Device: %s, Major: %i, " % (self.getName(),
self.getDev(),
self.getMajor())
############################################################################
class Disk(Device):
def __init__(self):
super(Disk,self).__init__()
self.removable = False
self.partitions = []
self.modelname = None
self.iconname = "hi16-hdd"
def getModelName(self):
return self.modelname
def getName(self):
if self.getModelName():
return i18n("Disk ")+self.getModelName()
else:
return i18n("Unknown Disk")
def getPartitions(self):
return self.partitions[:]
def appendPartition(self,partition):
self.partitions.append(partition)
def cmpNum(a,b): return cmp(a.num,b.num)
self.partitions.sort(cmpNum)
def __str__(self):
x = Device.__str__(self) + "Partitions: ["
for part in self.partitions:
x += "["
x += str(part)
x += "], "
x += "],"
return x
############################################################################
class RemovableDisk(Disk):
def __init__(self):
super(RemovableDisk,self).__init__()
self.iconname = "hi16-cdrom"
self.removable = True
def getName(self):
return "Optical Disk "+self.getModelName()
############################################################################
class USBDisk(Disk):
def __init__(self):
super(USBDisk,self).__init__()
self.iconname = "hi16-usbpen"
self.removable = True
def getName(self):
return "Removable USB Disk "+self.getModelName()
############################################################################
class BurnerDisk(RemovableDisk):
def __init__(self):
super(BurnerDisk,self).__init__()
self.iconname = "hi16-burner"
def getName(self):
return "Burner "+self.modelname
############################################################################
class Floppy(Device):
def isRemovable(self):
return True
def getName(self):
return "Floppy"
############################################################################
class Partition(Device):
def __init__(self):
super(Partition,self).__init__()
self.num = None
self.size = None
self.iconname = "hi16-hdd"
def getName(self):
return str(self.num)+" Partition "+ self.getSize()
# A group item for all of the other kernel/system mount entries.
def getSize(self):
return self.size
def __str__(self):
return "Device: %s, Num: %i, Size: %s, Label: %s, UUID: %s" % (self.dev, self.num, self.getSize(),
self.getLabel(), self.getUUID())
############################################################################
class FakeSystemDevice(object):
def getName(self): return "System"
def getIconName(self): return "hi16-blockdevice"
############################################################################
class MicroHAL(object):
# Major device numbers for Linux block devices that support partitions.
partitionblockdevs = [
3, # IDE harddisks
8, # SCSI disks
13, # 8-bit MFM/RLL/IDE controller
14, # BIOS harddrive callback support {2.6}
21, # Acorn MFM hard drive interface
22, # Second IDE hard disk/CD-ROM interface
28, # ACSI disk (68k/Atari)
33, # Third IDE hard disk/CD-ROM interface
34, # Fourth IDE hard disk/CD-ROM interface
36, # MCA ESDI hard disk
44, # Flash Translation Layer (FTL) filesystems
45, # Parallel port IDE disk devices
48, # Mylex DAC960 PCI RAID controller; first controller
49, # Mylex DAC960 PCI RAID controller; second controller
50, # Mylex DAC960 PCI RAID controller; third controller
51, # Mylex DAC960 PCI RAID controller; fourth controller
52, # Mylex DAC960 PCI RAID controller; fifth controller
53, # Mylex DAC960 PCI RAID controller; sixth controller
54, # Mylex DAC960 PCI RAID controller; seventh controller
55, # Mylex DAC960 PCI RAID controller; eigth controller
56, # Fifth IDE hard disk/CD-ROM interface
57, # Sixth IDE hard disk/CD-ROM interface
65, # SCSI disk devices (16-31)
66, # SCSI disk devices (32-47)
67, # SCSI disk devices (48-63)
68, # SCSI disk devices (64-79)
69, # SCSI disk devices (80-95)
70, # SCSI disk devices (96-111)
71, # SCSI disk devices (112-127)
72, # Compaq Intelligent Drive Array, first controller
73, # Compaq Intelligent Drive Array, second controller
74, # Compaq Intelligent Drive Array, third controller
75, # Compaq Intelligent Drive Array, fourth controller
76, # Compaq Intelligent Drive Array, fifth controller
77, # Compaq Intelligent Drive Array, sixth controller
78, # Compaq Intelligent Drive Array, seventh controller
79, # Compaq Intelligent Drive Array, eigth controller
80, # I2O hard disk
81, # I2O hard disk
82, # I2O hard disk
83, # I2O hard disk
84, # I2O hard disk
85, # I2O hard disk
86, # I2O hard disk
87, # I2O hard disk
88, # Seventh IDE hard disk/CD-ROM interface
89, # Eighth IDE hard disk/CD-ROM interface
90, # Ninth IDE hard disk/CD-ROM interface
91, # Tenth IDE hard disk/CD-ROM interface
92, # PPDD encrypted disk driver
95, # IBM S/390 DASD block storage
101, # AMI HyperDisk RAID controller
102, # Compressed block device
104, # Compaq Next Generation Drive Array, first controller
105, # Compaq Next Generation Drive Array, second controller
106, # Compaq Next Generation Drive Array, third controller
107, # Compaq Next Generation Drive Array, fourth controller
108, # Compaq Next Generation Drive Array, fifth controller
109, # Compaq Next Generation Drive Array, sixth controller
110, # Compaq Next Generation Drive Array, seventh controller
111, # Compaq Next Generation Drive Array, eigth controller
112, # IBM iSeries virtual disk
114, # IDE BIOS powered software RAID interfaces such as the Promise Fastrak
128, # SCSI disk devices (128-143)
129, # SCSI disk devices (144-159)
130, # SCSI disk devices (160-175)
131, # SCSI disk devices (176-191)
132, # SCSI disk devices (192-207)
133, # SCSI disk devices (208-223)
134, # SCSI disk devices (224-239)
135, # SCSI disk devices (240-255)
136, # Mylex DAC960 PCI RAID controller; ninth controller
137, # Mylex DAC960 PCI RAID controller; tenth controller
138, # Mylex DAC960 PCI RAID controller; eleventh controller
139, # Mylex DAC960 PCI RAID controller; twelfth controller
140, # Mylex DAC960 PCI RAID controller; thirteenth controller
141, # Mylex DAC960 PCI RAID controller; fourteenth controller
142, # Mylex DAC960 PCI RAID controller; fifteenth controller
143, # Mylex DAC960 PCI RAID controller; sixteenth controller
160, # Promise SX8 8-port SATA Disks on First Controller
161 # Promise SX8 8-port SATA Disks on Second Controller
]
floppydevs = [
2, # Floppy disks
40 # Syquest EZ135 parallel port removable drive
]
cdromsdevs = [
11, # SCSI CD-ROM devices
12, # MSCDEX CD-ROM callback support {2.6}
15, # Sony CDU-31A/CDU-33A CD-ROM
16, # GoldStar CD-ROM
17, # Optics Storage CD-ROM
18, # Sanyo CD-ROM
20, # Hitachi CD-ROM (under development)
23, # Mitsumi proprietary CD-ROM
24, # Sony CDU-535 CD-ROM
25, # First Matsushita (Panasonic/SoundBlaster) CD-ROM
26, # Second Matsushita (Panasonic/SoundBlaster) CD-ROM
27, # Third Matsushita (Panasonic/SoundBlaster) CD-ROM
28, # Fourth Matsushita (Panasonic/SoundBlaster) CD-ROM
29, # Aztech/Orchid/Okano/Wearnes CD-ROM
30, # Philips LMS CM-205 CD-ROM
32, # Philips LMS CM-206 CD-ROM
41, # MicroSolutions BackPack parallel port CD-ROM
46, # Parallel port ATAPI CD-ROM devices
47, # Parallel port ATAPI disk devices
48, # Mylex DAC960 PCI RAID controller; first controller
113 # IBM iSeries virtual CD-ROM
]
burnerpacketdevs = [
97 # Packet writing for CD/DVD devices
]
# We provide a mapping between filesystems and kernelmodules, so filesystems
# that are built as modules can be loaded on demand. (In fact, mountconfig will
# load all filesystem modules needed to be able to mount all fstab entries.)
FilesystemProcDriver = [
# fstab name, /proc name, kernel module name
('auto','autofs','autofs4'),
('iso9660','iso9660','isofs'),
('nfs','nfsd','nfs')
]
############################################################################
def __init__(self):
self.devices = None
self.supportedfs = None
############################################################################
def getDevices(self):
if self.devices is None:
self.devices = []
retval, msg = SimpleCommandRunner().run([b"/usr/bin/lshal"])
if retval is None or retval > 0:
return []
partition_to_uid = {}
uid_to_disk = {}
READING_TOP = 0
READING_DEVICE = 1
state = READING_TOP
parsed_hash = None
current_uid = None
for line in msg.split('\n'):
if state==READING_TOP:
if line.startswith("udi ="):
parsed_hash = {}
current_uid = self._parseString(line[6:])
state = READING_DEVICE
elif state==READING_DEVICE:
if line=="" or not line.startswith(" "):
# Detect the end of this block of device data.
state = READING_TOP
if "info.category" in parsed_hash:
new_device = None
capabilities_string = " ".join(parsed_hash["info.capabilities"])
capabilities = self._parseStringList(capabilities_string)
category = self._parseString(' '.join(parsed_hash["info.category"]))
if category=="volume":
# Is it a volume?
is_disc = parsed_hash.get("volume.is_disc")
if is_disc is not None and is_disc[0]=='true':
continue
is_partition = parsed_hash.get("volume.is_partition")
if is_partition is not None:
is_partition = is_partition[0]
if is_partition=='true':
new_device = Partition()
new_device.num = int(parsed_hash["volume.partition.number"][0])
partition_to_uid[new_device] = current_uid
if "info.parent" in parsed_hash:
parent_uid = self._parseString(' '.join(parsed_hash["info.parent"]))
partition_to_uid[new_device] = parent_uid
else:
new_device = Disk()
uid_to_disk[current_uid] = new_device
if "volume.uuid" in parsed_hash:
new_device.uuid = self._parseString(' '.join(parsed_hash["volume.uuid"]))
if "volume.label" in parsed_hash:
new_device.label = self._parseString(parsed_hash["volume.label"][0])
# If HAL returns label beginning with '#', it usually means that the
# actual label contains an Unix path. So we replace '#' with '/'.
if len(new_device.label) and new_device.label[0]=='%':
new_device.label = new_device.label.replace('%', '/')
if "volume.size" in parsed_hash:
size = parsed_hash["volume.size"][0]
new_device.size = self.formatSizeBytes(int(size))
else:
new_device.size = "?"
# is it a storage device?
elif category=="storage":
storage_model = self._parseString(' '.join(parsed_hash["storage.model"]))
storage_removable = parsed_hash["storage.removable"][0]=="true"
if "storage.cdrom" in capabilities:
if "storage.cdrom.cdrw" in parsed_hash \
and parsed_hash["storage.cdrom.cdrw"][0]=="true":
new_device = BurnerDisk()
else:
new_device= RemovableDisk()
elif "storage.floppy" in capabilities:
new_device = FloppyDevice()
else:
if "storage.bus" in parsed_hash \
and self._parseString(' '.join(parsed_hash["storage.bus"]))=="usb":
new_device = USBDisk()
else:
new_device = Disk()
new_device.modelname = storage_model
uid_to_disk[current_uid] = new_device
else:
# Not interesting, skip it.
continue
# Handle the generic properties.
new_device.dev = self._parseString(' '.join(parsed_hash["block.device"]))
new_device.major = int(parsed_hash["block.major"][0])
self.devices.append(new_device)
else:
# Keep on accumulating info about this device.
parts = line.split()
parsed_hash[ parts[0] ] = parts[2:]
# Attach the partitions to thier devices.
for partition in list(partition_to_uid.keys()):
parent = partition_to_uid[partition]
if parent in list(uid_to_disk.keys()):
parent_device = uid_to_disk[parent]
parent_device.appendPartition(partition)
self.devices.remove(partition)
return self.devices[:]
############################################################################
def _parseStringList(self,source_string):
STATE_TOP = 0
STATE_STRING = 1
state = STATE_TOP
current_string = ""
string_list = []
for c in source_string:
if state==STATE_TOP:
if c=='}':
break
if c=="'":
state = STATE_STRING
else:
if c=="'":
state = STATE_TOP
string_list.append(current_string)
current_string = ""
else:
current_string += c
return string_list
############################################################################
def _parseString(self,source_string):
STATE_TOP = 0
STATE_STRING = 1
state = STATE_TOP
current_string = ""
for c in source_string:
if state==STATE_TOP:
if c=="'":
state = STATE_STRING
else:
if c=="'":
break
else:
current_string += c
return current_string
############################################################################
def formatSizeBytes(self,size):
if size<1024:
return str(size+" B")
if size<1024*1042:
return str(round(float(size)/1024.0,1))+" Kb"
size /= 1024
if size<1024*1024:
return str(round(float(size)/1024.0,1))+" Mb"
size /= 1024
if size<1024*1024:
return str(round(float(size)/1024.0,1))+" Gb"
size /= 1024
return str(round(float(size)/1024.0,1))+" Tb"
############################################################################
def getSupportedFileSystems(self):
if self.supportedfs is None:
if os.path.isfile("/proc/filesystems"):
fhandle = open("/proc/filesystems")
self.supportedfs = []
for fs in fhandle.readlines():
try:
self.supportedfs.append(fs.strip().split()[1])
except IndexError:
self.supportedfs.append(fs.strip().split()[0])
# The following filesystems aren't found there, but usually they are
# supported.
self.supportedfs.extend(('swap','shm'))
return self.supportedfs[:]
############################################################################
def isSupportedFileSystem(self,fs):
# Look up the /proc and kernel driver name for the given filesystem type.
module = fs
proc = fs
for entry in self.FilesystemProcDriver:
if entry[0]==fs:
proc = entry[1]
module = entry[2]
if proc not in self.getSupportedFileSystems():
# The filesystem is not supported by the running kernel,
# but it might be built as module, so we try to load that.
retval, msg = SimpleCommandRunner().run([b"/sbin/modprobe",module])
if retval > 0:
print(msg)
print("Couldn't load driver " + module + " for filesystem " + fs)
# Force refresh of list of supported filesystems
self.supportedfs = None
return proc in self.getSupportedFileSystems()
############################################################################
def getDeviceByLabel(self, label):
for device in self.getDevices():
if device.getLabel()==label:
return device
if isinstance(device,Disk):
for partition in device.getPartitions():
if partition.getLabel()==label:
return partition
return None
def getLabelByDevice(self, device):
for item in self.getDevices():
for partition in item.partitions:
if partition.dev==device:
return partition.label
print("No Label found for ",device)
return ""
def getUUIDByDevice(self, device):
for item in self.getDevices():
for partition in item.partitions:
#print partition, partition.getUUID()
if partition.dev==device:
return partition.uuid
print("No UUID found for ",device)
return ""
def getDeviceByUUID(self, uuid):
for device in self.getDevices():
if device.getUUID()==uuid:
return device
if isinstance(device,Disk):
for partition in device.getPartitions():
if partition.getUUID()==uuid:
return partition
return None
############################################################################
if __name__=='__main__':
hal = MicroHAL()
for item in hal.getDevices():
print((str(item)))
print()
#"""
for item in hal.getDevices():
for partition in item.partitions:
print(partition, partition.getLabel())
#"""
#realhal = RealHAL()
#for item in realhal.getDevices():
# print(str(item))
print()