Ertuğrul Erata
493 lines
15 KiB
Python
493 lines
15 KiB
Python
#!/usr/bin/python
|
||
# -*- coding: utf-8 -*-
|
||
|
||
import glob
|
||
import os
|
||
import sys
|
||
import subprocess
|
||
|
||
FSTAB = '/etc/fstab'
|
||
|
||
"""
|
||
Quick list is used for improving efficiency of the script.
|
||
Stores device names and uuids pairs for partitions so prevents multiple
|
||
communication with subprocesses.
|
||
"""
|
||
quickList = {}
|
||
|
||
FAIL_FSTAB = {
|
||
"en": "Unable to read '%s'.",
|
||
"tr": "'%s' okunamadı.",
|
||
"fr": "Impossible de lire '%s' .",
|
||
"es": "No posible leer '%s'.",
|
||
"de": "'%s' konnte nicht gelesen werden.",
|
||
"nl": "Kan '%s' niet lezen.",
|
||
}
|
||
|
||
FAIL_PATH = {
|
||
"en": "'%s' is not a valid mount point.",
|
||
"tr": "'%s' geçerli bir bağlama noktası değil.",
|
||
"fr": "'%s' n'est pas un point de montage valide.",
|
||
"es": "'%s' no es un punto de montaje válido.",
|
||
"de": "'%s' ist kein gültiger Mount-Punkt.",
|
||
"nl": "'%s' is geen geldig aankoppelpunt.",
|
||
}
|
||
|
||
FAIL_PATH_ALREADY_EXIST = {
|
||
"en": "'%s' is already being used by an entry.",
|
||
"tr": "'%s' zaten bir kayıt tarafından kullanılıyor.",
|
||
"fr": "'%s' est déjà utilisé par une entrée.",
|
||
"es": "Ya '%s' siendo utilizado por una entrada.",
|
||
"de": "'%s' wird bereits durch einen Eintrag verwendet.",
|
||
"nl": "'%s' bruges allerede af en post.",
|
||
}
|
||
|
||
FAIL_ENTRY = {
|
||
"en": "Device '%s' not found in entry list.",
|
||
"tr": "'%s' aygıtı listede bulunamadı.",
|
||
"fr": "Le matériel '%s' n'a pas été trouvé dans la liste.",
|
||
"es": "Dispositivo '%s' no encontrado en lista de entrada.",
|
||
"de": "Gerät '%s' ist nicht in der Liste eingetragen.",
|
||
"nl": "Apparaat '%s' is niet in invoerlijst gevonden.",
|
||
}
|
||
|
||
FAIL_ROOT = {
|
||
"en": "'%s' is mounted to root directory, operation cancelled.",
|
||
"tr": "'%s' diski kök dizine bağlı, işlem iptal edildi.",
|
||
"fr": "'%s' est monté sur le répertoire racine, opération annulée.",
|
||
"es": "'%s' está montado com root, operación cancelada.",
|
||
"de": "'%s' ist als Root gemounted, Vorgang abgebrochen.",
|
||
"nl": "'%s' is in root-map aangekoppeld, bewerking geannuleerd.",
|
||
}
|
||
|
||
FAIL_MOUNTED = {
|
||
"en": "'%s' is mounted to another directory, operation cancelled.",
|
||
"tr": "'%s' başka bir dizine bağlı, işlem iptal edildi.",
|
||
"fr": "'%s' est monté sur un autre répertoire, opération annulée.",
|
||
"es": "'%s' está montado en otro directorio, operación cancelada.",
|
||
"de": "'%s' ist schon auf einem anderen Mount-Punkt gemounted, Vorgang abgebrochen.",
|
||
"nl": "'%s' is in een andere map aangekoppeld, bewerking geannuleerd.",
|
||
}
|
||
|
||
FAIL_OPERATION = {
|
||
"en": "Operation failed:\n\n %s",
|
||
"tr": "İşlem başarısız:\n\n %s",
|
||
"fr": "L'opération a échoué : \n\n %s",
|
||
"es": "Operación fallada:\n\n %s",
|
||
"de": "Vorgang fehlerhaft:\n\n %s",
|
||
"nl": "Mislukte bewerking:\n\n %s",
|
||
}
|
||
|
||
class DMException(Exception):
|
||
pass
|
||
|
||
def parseFstab(fstab):
|
||
if not os.access(fstab, os.R_OK):
|
||
raise DMException, _(FAIL_FSTAB) % fstab
|
||
entries = []
|
||
for line in open(fstab):
|
||
line = line.strip()
|
||
# Check len(line) for empty lines.
|
||
if line.startswith('#') or len(line) == 0:
|
||
continue
|
||
line = line.replace('\t', ' ').split()
|
||
# Replace UUID value with device name after reading it from fstab
|
||
if line[0].startswith('UUID='):
|
||
line[0] = getPartitionNameByUUID(line[0])
|
||
entries.append(line)
|
||
elif line[0].startswith('LABEL='):
|
||
line[0] = getDeviceByLabel(line[0].replace('LABEL=', ''))
|
||
entries.append(line)
|
||
elif line[0].startswith('/dev/'):
|
||
entries.append(line)
|
||
return entries
|
||
|
||
def createPath(device, path):
|
||
real_path = path
|
||
if not os.path.exists(path) and os.path.exists(os.path.dirname(path)):
|
||
# Mount point does not exist, but parent directory does.
|
||
path = os.path.dirname(path)
|
||
if not os.path.ismount(path) and not os.path.islink(path) and os.path.isdir(path):
|
||
os.mkdir(real_path, 0755)
|
||
return True
|
||
else:
|
||
if os.path.ismount(path):
|
||
# Path is already mounted, allow user to use that mount point if it's already mounted
|
||
for _device, _path in getMounted():
|
||
if device == _device and _path == path:
|
||
return True
|
||
else:
|
||
if not os.path.islink(path) and os.path.isdir(path) and os.listdir(path) == []:
|
||
return True
|
||
return False
|
||
|
||
def getMounted():
|
||
parts = []
|
||
for line in open('/proc/mounts'):
|
||
if line.startswith('/dev/'):
|
||
device, path, other = line.split(" ", 2)
|
||
parts.append((device, path, ))
|
||
return parts
|
||
|
||
def getFSType(device):
|
||
if device.startswith('UUID='):
|
||
device = getPartitionNameByUUID(device)
|
||
cmd = "/sbin/blkid -s TYPE -o value %s" % device
|
||
proc = subprocess.Popen(cmd.split(), stdout=subprocess.PIPE)
|
||
return proc.communicate()[0].strip()
|
||
|
||
def getUUID(part):
|
||
"""
|
||
Finds UUID for the given partition.
|
||
"""
|
||
global quickList
|
||
if len(quickList) == 0:
|
||
fillQuickList()
|
||
return quickList[part]
|
||
|
||
def getPartitionNameByUUID(part):
|
||
"""
|
||
Finds name of the partition for the given UUId.
|
||
"""
|
||
global quickList
|
||
part = part.replace('UUID=', '')
|
||
if len(quickList) == 0:
|
||
fillQuickList()
|
||
for devName, uuid in quickList.items():
|
||
if uuid == part:
|
||
return devName
|
||
return ''
|
||
|
||
def fillQuickList():
|
||
"""
|
||
Fills the quick list.
|
||
"""
|
||
global quickList
|
||
cmd = "/sbin/blkid"
|
||
proc = subprocess.Popen(cmd.split(), stdout=subprocess.PIPE)
|
||
for line in proc.stdout:
|
||
line = line.replace(':', '').strip()
|
||
propList = line.split()
|
||
devName = label = uuid = fsType = ''
|
||
devName = propList[0]
|
||
for property in propList:
|
||
if property.startswith('UUID'):
|
||
uuid = property.replace('UUID=', '').replace('"', '')
|
||
quickList[devName] = uuid
|
||
|
||
def runCommand(cmd):
|
||
proc = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
|
||
err = proc.communicate()[1].strip()
|
||
if len(err):
|
||
fail(_(FAIL_OPERATION) % err)
|
||
|
||
# Disk.Manager methods
|
||
|
||
def isMounted(device):
|
||
"""
|
||
Searches the given partition in mounted devices. If partition is
|
||
mounted, returns mount point else returns none.
|
||
"""
|
||
for _device, _path in getMounted():
|
||
if device == _device:
|
||
return _path
|
||
return ''
|
||
|
||
def getDevices():
|
||
from pardus.diskutils import EDD
|
||
return EDD().blockDevices()
|
||
|
||
def getDeviceByLabel(label):
|
||
root = '/dev/disk/by-label'
|
||
path = os.path.join(root, label)
|
||
if os.access(path, os.R_OK):
|
||
return os.path.realpath(os.path.join(root, os.readlink(path)))
|
||
else:
|
||
return ''
|
||
|
||
def getDeviceParts(device):
|
||
if not os.path.exists(device):
|
||
return []
|
||
parts = []
|
||
for part in glob.glob("%s*" % device):
|
||
if not part == device and not getFSType(part) == "":
|
||
parts.append(part)
|
||
return parts
|
||
|
||
def getLabel(device):
|
||
"""
|
||
Finds label for the given partition.
|
||
"""
|
||
cmd = "/sbin/blkid -s LABEL -o value %s" % device
|
||
proc = subprocess.Popen(cmd.split(), stdout=subprocess.PIPE)
|
||
return proc.communicate()[0].strip()
|
||
|
||
def getPath(device):
|
||
"""
|
||
Gets partition name and determine a path for that partition.
|
||
"""
|
||
# If there is a entry record for this partition in fstab
|
||
# use path in there.
|
||
if device in listEntries():
|
||
path_, fsType_, options_ = getEntry(device)
|
||
return path_
|
||
path = '/media/'
|
||
label = getLabel(device)
|
||
# There may be partitions without a label
|
||
if not label:
|
||
if not os.path.exists(path+'disk'):
|
||
path = path+'disk'
|
||
elif not os.path.ismount(path+'disk'):
|
||
path = path+'disk'
|
||
else:
|
||
for i in range(1, len(getMounted())):
|
||
if not os.path.exists(path+'disk-'+str(i)):
|
||
path = path+'disk-'+str(i)
|
||
break
|
||
elif not os.path.ismount(path+'disk-'+str(i)):
|
||
path = path+'disk-'+str(i)
|
||
break
|
||
# Labels may be same
|
||
else:
|
||
if not os.path.exists(path+label):
|
||
path = path+label
|
||
elif not os.path.ismount(path+label):
|
||
path = path+label
|
||
else:
|
||
for i in range(1, len(getMounted())):
|
||
if not os.path.exists(path+label+'-'+str(i)):
|
||
path = path+label+'-'+str(i)
|
||
break
|
||
elif not os.path.ismount(path+label+'-'+str(i)):
|
||
path = path+label+'-'+str(i)
|
||
break
|
||
return path
|
||
|
||
def mount(device, path):
|
||
if not path:
|
||
path = getPath(device)
|
||
if not createPath(device, path):
|
||
# Can't create new path
|
||
fail(_(FAIL_PATH) % path)
|
||
elif device in [x[0] for x in getMounted()]:
|
||
# Device is mounted
|
||
fail(_(FAIL_MOUNTED) % device)
|
||
runCommand(['/bin/mount', device, path])
|
||
|
||
def umount(device):
|
||
for dev, path in getMounted():
|
||
if dev == device and path == "/":
|
||
fail(_(FAIL_ROOT) % device)
|
||
runCommand(['/bin/umount', device])
|
||
|
||
def listEntries():
|
||
try:
|
||
devices = [x[0] for x in parseFstab(FSTAB)]
|
||
return devices
|
||
except DMException:
|
||
return []
|
||
|
||
def listPaths():
|
||
"""
|
||
Return paths of the entries in fstab.
|
||
"""
|
||
try:
|
||
paths = [x[1] for x in parseFstab(FSTAB)]
|
||
return paths
|
||
except DMException:
|
||
return []
|
||
|
||
def isLabelRecord(device):
|
||
for line in open(FSTAB):
|
||
line = line.strip().replace('\t', ' ').split()
|
||
if line:
|
||
if line[0] == 'LABEL=' + getLabel(device):
|
||
return True
|
||
|
||
def addEntry(device, path, fsType, options):
|
||
path_own = False
|
||
if device in listEntries():
|
||
old_path, old_fsType, old_options = getEntry(device)
|
||
# Do not change root
|
||
if old_path == "/" and not old_path == path:
|
||
fail(_(FAIL_ROOT) % device)
|
||
# Who has that mount point? me?
|
||
if old_path == path:
|
||
path_own = True
|
||
else:
|
||
# If the path value already exist in fstab, cut the operation
|
||
if path in listPaths():
|
||
fail(_(FAIL_PATH_ALREADY_EXIST) % path)
|
||
old_path = None
|
||
if not createPath(device, path):
|
||
# Can't create new path
|
||
fail(_(FAIL_PATH) % path)
|
||
#elif device in [x[0] for x in getMounted()]:
|
||
# Device is mounted
|
||
#fail(_(FAIL_MOUNTED) % device)
|
||
partText = ''
|
||
# Before removing the entry check if it is a label record or uuid record
|
||
# Remove previous one to prevent duplicates
|
||
if old_path:
|
||
if isLabelRecord(device):
|
||
partText = 'LABEL='+getLabel(device)
|
||
else:
|
||
partText = 'UUID='+getUUID(device)
|
||
else:
|
||
partText = 'UUID='+getUUID(device)
|
||
# Add new entry
|
||
_options = []
|
||
for key, value in options.iteritems():
|
||
if value:
|
||
_options.append('%s=%s' % (key, value))
|
||
else:
|
||
_options.append(key)
|
||
if not file(FSTAB).read()[-1] == '\n':
|
||
file(FSTAB, 'a').write('\n')
|
||
_options = ','.join(_options)
|
||
|
||
addit = True
|
||
# If the partition is not already mounted the given path and,
|
||
# if the partition is not mounted anywhere, try to create a path
|
||
# and mount there.
|
||
if not path_own:
|
||
if not createPath(device, path):
|
||
addit = False
|
||
# Can't create new path
|
||
fail(_(FAIL_PATH) % path)
|
||
if not device in [x[0] for x in getMounted()]:
|
||
# Mount device
|
||
try:
|
||
mount(device, path)
|
||
except:
|
||
addit = False
|
||
raise
|
||
if addit:
|
||
# try to remove old entry before
|
||
if old_path:
|
||
removeEntry(device, silent=True)
|
||
if _options:
|
||
file(FSTAB, 'a').write('%s %s %s %s 0 0\n' % (partText, path, fsType, _options))
|
||
else:
|
||
file(FSTAB, 'a').write('%s %s %s defaults 0 0\n' % (partText, path, fsType))
|
||
# Notify clients
|
||
notify("Disk.Manager", "changed", ())
|
||
|
||
def getEntry(device):
|
||
entries = parseFstab(FSTAB)
|
||
for entry in entries:
|
||
if entry[0] == device:
|
||
_path, _fsType, _options, _dump, _pass = entry[1:]
|
||
options = {}
|
||
for part in _options.split(','):
|
||
if "=" in part:
|
||
key, value = part.split('=', 1)
|
||
options[key] = value
|
||
else:
|
||
options[part] = ""
|
||
return _path, _fsType, options
|
||
fail(_(FAIL_ENTRY) % device)
|
||
|
||
def removeEntry(device, silent=False):
|
||
if isMounted(device) == '/':
|
||
fail(_(FAIL_ROOT) % device)
|
||
if device not in listEntries():
|
||
return
|
||
newlines = []
|
||
for line in open(FSTAB):
|
||
line = line.strip()
|
||
if not len(line) == 0 and not (line.replace('\t', ' ').split()[0] == 'UUID='+getUUID(device) or line.replace('\t', ' ').split()[0] == 'LABEL='+getLabel(device) or line.replace('\t', ' ').split()[0] == device):
|
||
newlines.append(line)
|
||
file(FSTAB, 'w').write('\n'.join(newlines))
|
||
if not file(FSTAB).read()[-1] == '\n':
|
||
file(FSTAB, 'a').write('\n')
|
||
# Notify clients
|
||
if not silent:
|
||
notify("Disk.Manager", "changed", ())
|
||
|
||
|
||
import errno
|
||
from time import sleep
|
||
from fcntl import ioctl
|
||
|
||
# Path to sync executable
|
||
PATH_SYNC = '/bin/sync'
|
||
|
||
# Emulate required asm-generic/ioctl.h macros
|
||
_IOC_NRBITS = 8
|
||
_IOC_TYPEBITS = 8
|
||
_IOC_SIZEBITS = 14
|
||
_IOC_DIRBITS = 2
|
||
|
||
_IOC_NRMASK = ((1 << _IOC_NRBITS) - 1)
|
||
_IOC_TYPEMASK = ((1 << _IOC_TYPEBITS) - 1)
|
||
_IOC_SIZEMASK = ((1 << _IOC_SIZEBITS) - 1)
|
||
_IOC_DIRMASK = ((1 << _IOC_DIRBITS) - 1)
|
||
|
||
_IOC_NRSHIFT = 0
|
||
_IOC_TYPESHIFT = (_IOC_NRSHIFT + _IOC_NRBITS)
|
||
_IOC_SIZESHIFT = (_IOC_TYPESHIFT + _IOC_TYPEBITS)
|
||
_IOC_DIRSHIFT = (_IOC_SIZESHIFT + _IOC_SIZEBITS)
|
||
|
||
# Direction bits.
|
||
_IOC_NONE = 0
|
||
_IOC_WRITE = 1
|
||
_IOC_READ = 2
|
||
|
||
def _IOC(dir,type,nr,size):
|
||
return (((dir) << _IOC_DIRSHIFT) | \
|
||
(type << _IOC_TYPESHIFT) | \
|
||
((nr) << _IOC_NRSHIFT) | \
|
||
((size) << _IOC_SIZESHIFT))
|
||
|
||
def _IO(type, nr):
|
||
"""Note: type is specified in hex and nr in decimal."""
|
||
return _IOC(_IOC_NONE,(type),(nr),0)
|
||
|
||
def BLKRRPART():
|
||
"""Returns ioctl number for re-reading partition table."""
|
||
# Kernels >2.6.17 have BLKRRPART defined in include/linux/fs.h.
|
||
return _IO(0x12, 95)
|
||
# -------------------------------------------
|
||
|
||
def refreshPartitionTable(device):
|
||
"""Re-Read partition table on device."""
|
||
|
||
try:
|
||
fd = os.open(device, os.O_RDONLY)
|
||
except EnvironmentError, (error, strerror):
|
||
print 'Could not open device %s. Reason: %s.'%(device, strerror)
|
||
sys.exit(-1)
|
||
|
||
# Sync and wait for Sync to complete
|
||
os.system(PATH_SYNC)
|
||
sleep(2)
|
||
|
||
# Call required ioctl to re-read partition table
|
||
try:
|
||
ioctl(fd, BLKRRPART())
|
||
except EnvironmentError, (error, message):
|
||
# Attempt ioctl call twice in case an older kernel (1.2.x) is being used
|
||
os.system(PATH_SYNC)
|
||
sleep(2)
|
||
|
||
try:
|
||
ioctl(fd, BLKRRPART())
|
||
except EnvironmentError, (error, strerror):
|
||
print 'IOCTL Error: %s for device %s.'%(strerror, device)
|
||
sys.exit(-1)
|
||
|
||
print 'Successfully re-read partition table on device %s.'%(device)
|
||
# Sync file buffers
|
||
os.fsync(fd)
|
||
os.close(fd)
|
||
|
||
# Final sync
|
||
print "Syncing %s ... " % (device),
|
||
os.system(PATH_SYNC)
|
||
sleep(4) # for sync()
|
||
print "Done."
|
||
|
||
|
||
|