update partition-tool
deleted: new_partition/finddisk.sh new file: new_partition/interface_partition.py deleted: new_partition/list-devices deleted: new_partition/new_partition.py deleted: new_partition/parted_devices modified: new_partition/parted_devices.py new file: new_partition/partition_data.py
This commit is contained in:
Peng Zhihui
@@ -1,95 +0,0 @@
|
||||
#!/bin/bash
|
||||
|
||||
finddisks() {
|
||||
workdir="$PWD"
|
||||
cd /sys/block
|
||||
# ide devices
|
||||
for dev in $(ls | egrep '^hd'); do
|
||||
if [ "$(cat $dev/device/media)" = "disk" ]; then
|
||||
echo -e "/dev/$dev$3"
|
||||
fi
|
||||
done
|
||||
#scsi/sata devices, and virtio blockdevices (/dev/vd*)
|
||||
for dev in $(ls | egrep '^[sv]d'); do
|
||||
# TODO: what is the significance of 5? ASKDEV
|
||||
if ! [ "$(cat $dev/device/type)" = "5" ]; then
|
||||
echo -e "/dev/$dev$3"
|
||||
fi
|
||||
done
|
||||
# cciss controllers
|
||||
if [ -d /dev/cciss ] ; then
|
||||
cd /dev/cciss
|
||||
for dev in $(ls | egrep -v 'p'); do
|
||||
echo -e "/dev/cciss/$dev$3"
|
||||
done
|
||||
fi
|
||||
# Smart 2 controllers
|
||||
if [ -d /dev/ida ] ; then
|
||||
cd /dev/ida
|
||||
for dev in $(ls | egrep -v 'p'); do
|
||||
echo -e "/dev/ida/$dev$3"
|
||||
done
|
||||
fi
|
||||
cd "$workdir"
|
||||
}
|
||||
|
||||
findblockdevices() {
|
||||
workdir="$PWD"
|
||||
for devpath in $(finddisks)
|
||||
do
|
||||
disk=$(echo $devpath | sed 's|.*/||')
|
||||
echo -e "/dev/$disk$3"
|
||||
cd /sys/block/$disk
|
||||
for part in $disk*
|
||||
do
|
||||
# check if not already assembled to a raid device. TODO: what is the significance of the 5? ASKDEV
|
||||
if ! [ "$(grep $part /proc/mdstat 2>/dev/null)" -o "$(fstype 2>/dev/null </dev/$part | grep lvm2)" -o "$(sfdisk -c /dev/$disk $(echo $part | sed -e "s#$disk##g") 2>/dev/null | grep "5")" ]
|
||||
then
|
||||
if [ -d $part ]
|
||||
then
|
||||
echo -e "/dev/$part$3"
|
||||
fi
|
||||
fi
|
||||
done
|
||||
done
|
||||
# include any mapped devices
|
||||
for devpath in $(ls /dev/mapper 2>/dev/null | grep -v control)
|
||||
do
|
||||
echo -e "/dev/mapper/$devpath$3"
|
||||
done
|
||||
# include any raid md devices
|
||||
for devpath in $(ls -d /dev/md* 2>/dev/null| grep '[0-9]' 2>/dev/null)
|
||||
do
|
||||
if grep -qw $(echo $devpath /proc/mdstat | sed -e 's|/dev/||g')
|
||||
then
|
||||
echo -e "$devpath$3"
|
||||
fi
|
||||
done
|
||||
# inlcude cciss controllers
|
||||
if [ -d /dev/cciss ]
|
||||
then
|
||||
cd /dev/cciss
|
||||
for dev in $(ls | egrep 'p')
|
||||
do
|
||||
echo -e "/dev/cciss/$dev$3"
|
||||
done
|
||||
fi
|
||||
# inlcude Smart 2 controllers
|
||||
if [ -d /dev/ida ]
|
||||
then
|
||||
cd /dev/ida
|
||||
for dev in $(ls | egrep 'p')
|
||||
do
|
||||
echo -e "/dev/ida/$dev$3"
|
||||
done
|
||||
fi
|
||||
|
||||
cd "$workdir"
|
||||
}
|
||||
|
||||
#findblockdevices |grep -v [0-9]|while read f;\
|
||||
#do fdisk -l ${f} 2>/dev/null; done|\
|
||||
#grep "Disk /dev" |awk -F "," '{print $1}'|\
|
||||
#awk -F ":" '{print $1,$2}'
|
||||
|
||||
findblockdevices |grep -v [0-9]
|
||||
527
new_partition/interface_partition.py
Executable file
527
new_partition/interface_partition.py
Executable file
@@ -0,0 +1,527 @@
|
||||
#!/usr/bin/env python
|
||||
from snack import *
|
||||
import gettext, sys, os, re, string, time
|
||||
|
||||
import partition_data as p_d
|
||||
|
||||
screen = SnackScreen()
|
||||
screen.drawRootText(0, 0, "Welcome to Rocky Security OS")
|
||||
screen.pushHelpLine( (" F1-New F2-Delete F3-Boot F4-Raid F12-OK "))
|
||||
|
||||
global count
|
||||
count = 0
|
||||
def DEBUG():
|
||||
global count
|
||||
print 'debug' + str(count)
|
||||
count = count + 1
|
||||
|
||||
global base_unit
|
||||
base_unit = 'B'
|
||||
|
||||
# the origin unit is 's'
|
||||
#def pretty_unit(num):
|
||||
# if num*0.5*1.024 < 10*1000:
|
||||
# # < 10M unit is kB
|
||||
# num_pretty = num*0.5*1.024
|
||||
# unit = 'kB'
|
||||
# elif num*0.5*1.024 < 10*1000*1000:
|
||||
# # < 10G unit is MB
|
||||
# num_pretty = num*0.5*1.024/1000
|
||||
# unit = 'MB'
|
||||
# elif num*0.5*1.024 < 10000000000:
|
||||
# # < 10T unit is GB
|
||||
# num_pretty = num*0.5*1.024/1000/1000
|
||||
# unit = 'GB'
|
||||
# return str("%.0f" %num_pretty) + unit
|
||||
#
|
||||
#def unit_to_s(num):
|
||||
# if re.search('kB', num):
|
||||
# # unit kB to s
|
||||
# num_s = num/1.024*2
|
||||
# elif re.search('MB', num):
|
||||
# # unit MB to s
|
||||
# num_s = num/1000/1.024*2
|
||||
# elif re.search('GB', num):
|
||||
# # unit GB to s
|
||||
# num_s = num/1000/1000/1.024*2
|
||||
# return num_s
|
||||
|
||||
#the origin unit is 'byte'
|
||||
def pretty_unit(num):
|
||||
num = int(num)
|
||||
global num_pretty
|
||||
global unit_pretty
|
||||
if num < 1000:
|
||||
# < 1k unit is B
|
||||
num_pretty = num
|
||||
unit_pretty = 'B'
|
||||
elif num/1000 < 10*1000:
|
||||
# < 10M unit is kB
|
||||
num_pretty = num/1000
|
||||
unit_pretty = 'kB'
|
||||
elif num/1000/1000 < 10*1000:
|
||||
# < 10G unit is MB
|
||||
num_pretty = num/1000/1000
|
||||
unit_pretty = 'MB'
|
||||
elif num/1000/1000/1000 < 10*1000:
|
||||
# < 10T unit is GB
|
||||
num_pretty = num/1000/1000/1000
|
||||
unit_pretty = 'GB'
|
||||
return str("%.1f" %num_pretty) + unit_pretty
|
||||
|
||||
def unit_to_byte(num_unit):
|
||||
#num = int(filter(str.isdigit, str(num_unit)))
|
||||
# because int('10.0') error
|
||||
num = int(float(get_size_num(str(num_unit))))
|
||||
if re.search('kB', num_unit):
|
||||
# unit kB to byte
|
||||
num_byte = num*1000
|
||||
elif re.search('MB', num_unit):
|
||||
# unit MB to byte
|
||||
num_byte = num*1000*1000
|
||||
elif re.search('GB', num_unit):
|
||||
# unit GB to byte
|
||||
num_byte = num*1000*1000*1000
|
||||
return num_byte
|
||||
|
||||
def sort_partition(dev):
|
||||
list_partition = []
|
||||
list_partition_sorted = []
|
||||
for partition in p_d.Partition.dict[dev]['partition'].keys():
|
||||
list_partition.append(partition)
|
||||
list_partition_sorted.append(partition)
|
||||
print list_partition
|
||||
for partition in list_partition:
|
||||
sn = p_d.Partition.dict[dev]['partition'][partition]['sn']
|
||||
list_partition_sorted[int(sn)-1] = partition
|
||||
return list_partition_sorted
|
||||
|
||||
def showPartitionWindow():
|
||||
global clb
|
||||
global bb
|
||||
bb = ButtonBar (screen, (("New", "new", "F1"),("Delete", "delete", "F2"),("Boot", "boot", "F3"),\
|
||||
("Raid", "raid", "F4"),("OK", "ok", "F12"),("Cancel", "cancel"),))
|
||||
|
||||
clb = CListbox(height=10, cols=6,
|
||||
col_widths=[19,11,11,11,10,12],
|
||||
scroll=1, returnExit = 1,
|
||||
width=85, col_pad=2,
|
||||
col_labels=['Device', 'Start', 'End', 'Size', 'Type', 'Flags'],
|
||||
col_label_align=[CENTER,CENTER,CENTER,CENTER,CENTER,CENTER])
|
||||
|
||||
for dev in sorted(p_d.Partition.dict.keys()):
|
||||
# dev: /dev/sda dev_name: sda; dev: /dev/cciss/c0d0 dev_name:cciss/c0d0
|
||||
dev_name = dev.split('/dev/')[1]
|
||||
partition_table = p_d.Partition.dict[dev]['partition_table']
|
||||
dev_size = p_d.Partition.dict[dev]['disk_size']
|
||||
#dev_size_pretty = pretty_unit(filter(str.isdigit, dev_size))
|
||||
|
||||
clb.append(["%s" %(dev),"","","","",""], \
|
||||
"dev:%s:%s" %(dev,dev_size), [LEFT, RIGHT, RIGHT, RIGHT, LEFT, LEFT])
|
||||
|
||||
if partition_table == None:
|
||||
continue
|
||||
|
||||
list_partition_all_sorted = p_d.sort_partitions(p_d.Partition.dict, dev, "all")
|
||||
for partition in list_partition_all_sorted:
|
||||
start = p_d.Partition.dict[dev]['partition'][partition]['start']
|
||||
end = p_d.Partition.dict[dev]['partition'][partition]['end']
|
||||
size = p_d.Partition.dict[dev]['partition'][partition]['size']
|
||||
ptype = p_d.Partition.dict[dev]['partition'][partition]['type']
|
||||
flags = p_d.Partition.dict[dev]['partition'][partition]['flags']
|
||||
|
||||
try:
|
||||
if int(filter(str.isdigit, start)) < 2000000 and \
|
||||
int(filter(str.isdigit, size)) < 2000000:
|
||||
continue
|
||||
except:
|
||||
pass
|
||||
|
||||
start_pretty = pretty_unit(filter(str.isdigit, str(start)))
|
||||
end_pretty = pretty_unit(filter(str.isdigit, str(end)))
|
||||
size_pretty = pretty_unit(filter(str.isdigit, str(size)))
|
||||
|
||||
# pretty free space partition
|
||||
if re.search('free', partition):
|
||||
partition_pretty = 'Free Space'
|
||||
else:
|
||||
partition_pretty = partition
|
||||
|
||||
clb.append([" %s" %(partition_pretty),"%s" %(start_pretty),"%s" %(end_pretty),"%s" %(size_pretty),"%s" %(ptype),"%s" %(flags)],\
|
||||
"partition:%s:%s:%s:%s:%s:%s:%s" %(partition, dev, size, start, end, partition_table, size_pretty),\
|
||||
[LEFT, RIGHT, RIGHT, RIGHT, LEFT, LEFT])
|
||||
|
||||
sg = Grid(2, 3)
|
||||
sg.setField(bb, 0, 1, anchorLeft = 1)
|
||||
g = Grid(1, 3)
|
||||
g.setField(clb, 0, 0)
|
||||
g.setField(sg, 0, 2)
|
||||
g.place(1, 1)
|
||||
screen.gridWrappedWindow(g, "Partitioning")
|
||||
f = Form()
|
||||
f.add(bb)
|
||||
f.add(clb)
|
||||
f.addHotKey("F1")
|
||||
f.addHotKey("F2")
|
||||
f.addHotKey("F3")
|
||||
f.addHotKey("F4")
|
||||
f.addHotKey("F12")
|
||||
|
||||
global res
|
||||
res =f.run()
|
||||
screen.refresh
|
||||
|
||||
def get_size_num(size):
|
||||
if re.search('kB', size):
|
||||
size_num = size.split('kB')[0]
|
||||
elif re.search('MB', size):
|
||||
size_num = size.split('MB')[0]
|
||||
elif re.search('GB', size):
|
||||
size_num = size.split('GB')[0]
|
||||
return size_num
|
||||
|
||||
def show_error(tips):
|
||||
g21 = GridForm(screen, "Error", 1, 2)
|
||||
g21.add(Label("%s." %(tips)), 0, 0)
|
||||
g21.add(Button("OK"), 0, 1)
|
||||
g21.runOnce()
|
||||
|
||||
def check_size_set(size, maxsize):
|
||||
if size == "":
|
||||
return ("Must specify a value")
|
||||
try:
|
||||
if float(size) > float(maxsize):
|
||||
return ("Requested value is too large")
|
||||
except:
|
||||
return ("Requested value is not an number")
|
||||
|
||||
def count_primary_extended(dev):
|
||||
count_primary = 0
|
||||
count_extended = 0
|
||||
for p in p_d.sort_partitions(p_d.Partition.dict, dev):
|
||||
if p_d.Partition.dict[dev]['partition'][p]['type'] == 'primary':
|
||||
count_primary += 1
|
||||
if p_d.Partition.dict[dev]['partition'][p]['type'] == 'extended':
|
||||
count_extended += 1
|
||||
return (count_primary, count_extended)
|
||||
|
||||
def get_extended_start_end(dev):
|
||||
extended_start = ''
|
||||
extended_end = ''
|
||||
for p in p_d.sort_partitions(p_d.Partition.dict, dev):
|
||||
if p_d.Partition.dict[dev]['partition'][p]['type'] == 'extended':
|
||||
extended_start = p_d.Partition.dict[dev]['partition'][p]['start']
|
||||
extended_end = p_d.Partition.dict[dev]['partition'][p]['end']
|
||||
return (extended_start, extended_end)
|
||||
|
||||
def add_partition(ptype='', extended='', label=''):
|
||||
free_space = clb.current().split(":")[1]
|
||||
dev = clb.current().split(":")[2]
|
||||
dev_name = dev.split("/dev/")[1]
|
||||
size = clb.current().split(":")[3]
|
||||
size_pretty = clb.current().split(":")[7]
|
||||
free_space_start = filter(str.isdigit, clb.current().split(":")[4])
|
||||
free_space_end = filter(str.isdigit, clb.current().split(":")[5])
|
||||
free_space_sn = int(p_d.Partition.dict[dev]['partition'][free_space]['sn'])
|
||||
|
||||
# 4k assign
|
||||
#if int(free_space_start) < 2*1000*1000:
|
||||
# free_space_start_real = free_space_start
|
||||
# free_space_start = '0%'
|
||||
|
||||
size_num = filter(str.isdigit, size)
|
||||
#size_num = get_size_num(size)
|
||||
unit = filter(str.isalpha, size_pretty)
|
||||
#size_pretty_num = filter(str.isdigit, size_pretty)
|
||||
size_pretty_num = get_size_num(size_pretty)
|
||||
|
||||
bb2 = ButtonBar(screen, (("OK", "ok"), ("Cancel", "cancel")))
|
||||
sg21 = Grid(2,1)
|
||||
typeLbl = Label("File System type: ")
|
||||
lb_fstype = Listbox(height=3, scroll=1)
|
||||
list_fs = ['ext2', 'ext3', 'ext4', 'linux-swap', 'raid', 'reiserfs', 'xfs', 'jfs']
|
||||
for fs in list_fs:
|
||||
lb_fstype.append(fs, fs)
|
||||
lb_fstype.setCurrent('ext3')
|
||||
sg21.setField(typeLbl, 0, 0, anchorLeft=0)
|
||||
sg21.setField(lb_fstype, 1, 0)
|
||||
|
||||
sg22 = Grid(2,1)
|
||||
sizeLbl = Label("Size(%s): " %(unit))
|
||||
entry_size = Entry(10, size_pretty_num)
|
||||
sg22.setField(sizeLbl, 0, 0)
|
||||
sg22.setField(entry_size, 1, 0)
|
||||
|
||||
sg23 = Grid(2,1)
|
||||
rb_primary = SingleRadioButton("primary", None, 1)
|
||||
rb_extended = SingleRadioButton("extended", rb_primary)
|
||||
sg23.setField(rb_primary, 0, 0)
|
||||
sg23.setField(rb_extended, 1, 0)
|
||||
|
||||
cb_boot = Checkbox("Force to be a bootable partition")
|
||||
|
||||
g2 = GridForm(screen, "New Partition(%s)" %(dev), 1, 9)
|
||||
g2.add(sg21,0,0)
|
||||
|
||||
g2.add(Label(""),0,1)
|
||||
g2.add(sg22,0,2)
|
||||
g2.add(Label(""),0,3)
|
||||
g2.add(cb_boot,0,4)
|
||||
g2.add(Label(""),0,5)
|
||||
|
||||
if extended == "extended" or label == 'gpt':
|
||||
g2.add(bb2, 0, 6)
|
||||
res2 = g2.runOnce()
|
||||
if label == 'gpt':
|
||||
ptype = 'primary'
|
||||
else:
|
||||
g2.add(sg23,0,6)
|
||||
g2.add(Label(""),0,7)
|
||||
g2.add(bb2, 0, 8)
|
||||
res2 = g2.runOnce()
|
||||
if rb_primary.selected():
|
||||
ptype = 'primary'
|
||||
else:
|
||||
ptype = 'extended'
|
||||
|
||||
if bb2.buttonPressed(res2) == "ok":
|
||||
#if ptype == 'extended' and count_extended != 0:
|
||||
# show_error('An extended partition has existed !You can not create any more !')
|
||||
fs_set = lb_fstype.current()
|
||||
tips = check_size_set(entry_size.value(),size_pretty_num)
|
||||
if tips:
|
||||
show_error(tips)
|
||||
else:
|
||||
size_set_pretty = entry_size.value() + unit
|
||||
size_set_num = unit_to_byte(size_set_pretty)
|
||||
size_set = str(size_set_num) + base_unit
|
||||
partition_start = free_space_start + base_unit
|
||||
partition_end = str(int(free_space_start) + size_set_num) + base_unit
|
||||
|
||||
flags = ''
|
||||
if cb_boot.value() == 1:
|
||||
if flags == '':
|
||||
flags = 'boot'
|
||||
else:
|
||||
flags = flags + ',boot'
|
||||
if fs_set == 'raid':
|
||||
if flags == '':
|
||||
flags = 'raid'
|
||||
else:
|
||||
flags = flags + ',raid'
|
||||
|
||||
partition_num = 0
|
||||
list_partition_sorted = p_d.sort_partitions(p_d.Partition.dict,dev,'partition')
|
||||
list_free_sorted = p_d.sort_partitions(p_d.Partition.dict,dev,'free')
|
||||
if list_partition_sorted == []:
|
||||
# an empty disk
|
||||
pass
|
||||
else:
|
||||
if ptype == 'logical':
|
||||
partition_num = 4
|
||||
for p in list_partition_sorted:
|
||||
if int(p_d.Partition.dict[dev]['partition'][p]['num']) > partition_num \
|
||||
and p_d.Partition.dict[dev]['partition'][p]['type'] =='logical':
|
||||
partition_num = int(p_d.Partition.dict[dev]['partition'][p]['num'])
|
||||
else:
|
||||
if label == 'msdos':
|
||||
for p in list_partition_sorted:
|
||||
if int(p_d.Partition.dict[dev]['partition'][p]['num']) > partition_num \
|
||||
and p_d.Partition.dict[dev]['partition'][p]['type'] != 'logical':
|
||||
partition_num = int(p_d.Partition.dict[dev]['partition'][p]['num'])
|
||||
elif label == 'gpt':
|
||||
if int(p_d.Partition.dict[dev]['partition'][list_partition_sorted[0]]['num']) != 1:
|
||||
pass
|
||||
else:
|
||||
for i in range(len(list_partition_sorted)):
|
||||
#print int(p_d.Partition.dict[dev]['partition'][sorted(list_partition)[i]]['num'])
|
||||
if i == len(list_partition_sorted) - 1 or \
|
||||
int(p_d.Partition.dict[dev]['partition'][list_partition_sorted[i]]['num']) \
|
||||
!= int(p_d.Partition.dict[dev]['partition'][list_partition_sorted[i+1]]['num']) - 1:
|
||||
partition_num = int(p_d.Partition.dict[dev]['partition'][list_partition_sorted[i]]['num'])
|
||||
break
|
||||
|
||||
partition_num += 1
|
||||
partition = dev + str(partition_num)
|
||||
partition_sn = free_space_sn
|
||||
|
||||
if size_set_pretty == size_pretty:
|
||||
partition_end = free_space_end
|
||||
if len(list_free_sorted) > 1:
|
||||
for p in list_free_sorted:
|
||||
if int(p_d.Partition.dict[dev]['partition'][p]['sn']) >= int(free_space_sn):
|
||||
p_num = int(p_d.Partition.dict[dev]['partition'][p]['num'])
|
||||
p_d.Partition.dict[dev]['partition'][p]['sn'] = p_d.Partition.dict[dev]['partition']['free '+str(p_num+1)]['sn']
|
||||
p_d.Partition.dict[dev]['partition'][p]['start'] = p_d.Partition.dict[dev]['partition']['free '+str(p_num+1)]['start']
|
||||
p_d.Partition.dict[dev]['partition'][p]['end'] = p_d.Partition.dict[dev]['partition']['free '+str(p_num+1)]['end']
|
||||
p_d.Partition.dict[dev]['partition'][p]['size'] = p_d.Partition.dict[dev]['partition']['free '+str(p_num+1)]['size']
|
||||
p_d.delete_one_partition(p_d.Partition.dict, dev, 'free '+str(len(list_free_sorted)+1))
|
||||
p_d.delete_one_partition(p_d.Partition.dict, dev, 'free '+str(len(list_free_sorted)))
|
||||
else:
|
||||
del p_d.Partition.dict[dev]['partition'][free_space]
|
||||
else:
|
||||
list_partition_all_sorted = p_d.sort_partitions(p_d.Partition.dict, dev, 'all')
|
||||
p_d.Partition.dict[dev]['partition'][free_space]['start'] = str(int(free_space_start) + size_set_num + 1) + base_unit
|
||||
for p in list_partition_all_sorted:
|
||||
if p_d.Partition.dict[dev]['partition'][p]['sn'] > free_space_sn-1:
|
||||
p_d.Partition.dict[dev]['partition'][p]['sn'] = int(p_d.Partition.dict[dev]['partition'][p]['sn']) + 1
|
||||
p_d.Partition.dict[dev]['partition'][free_space]['sn'] = int(free_space_sn) + 1
|
||||
p_d.Partition.dict[dev]['partition'][free_space]['size'] = \
|
||||
str(int(filter(str.isdigit,p_d.Partition.dict[dev]['partition'][free_space]['end'])) - \
|
||||
int(filter(str.isdigit,p_d.Partition.dict[dev]['partition'][free_space]['start']))) + base_unit
|
||||
|
||||
p_d.Partition.dict[dev]['partition'][partition]['sn'] = int(partition_sn)
|
||||
p_d.Partition.dict[dev]['partition'][partition]['num'] = int(partition_num)
|
||||
p_d.Partition.dict[dev]['partition'][partition]['start'] = partition_start
|
||||
p_d.Partition.dict[dev]['partition'][partition]['end'] = partition_end
|
||||
p_d.Partition.dict[dev]['partition'][partition]['size'] = size_set
|
||||
p_d.Partition.dict[dev]['partition'][partition]['type'] = ptype
|
||||
p_d.Partition.dict[dev]['partition'][partition]['filesystem'] = fs_set
|
||||
p_d.Partition.dict[dev]['partition'][partition]['flags'] = flags
|
||||
|
||||
if ptype == 'extended':
|
||||
list_partition_all_sorted = p_d.sort_partitions(p_d.Partition.dict,dev, 'all')
|
||||
list_free_sorted = p_d.sort_partitions(p_d.Partition.dict,dev,'free')
|
||||
extended_free_space_sn = partition_sn + 1
|
||||
free_num = 0
|
||||
if len(list_partition_all_sorted) == partition_sn:
|
||||
if list_free_sorted != []:
|
||||
for f in list_free_sorted:
|
||||
if p_d.Partition.dict[dev]['partition'][f]['num'] > free_num:
|
||||
free_num = p_d.Partition.dict[dev]['partition'][f]['num']
|
||||
else:
|
||||
for p in list_partition_all_sorted[::-1]:
|
||||
p_num = p_d.Partition.dict[dev]['partition'][p]['num']
|
||||
if p_d.Partition.dict[dev]['partition'][p]['sn'] > partition_sn:
|
||||
if re.search('free', p):
|
||||
p_d.Partition.dict[dev]['partition']['free '+str(p_num+1)]['sn'] = p_d.Partition.dict[dev]['partition'][p]['sn']+1
|
||||
p_d.Partition.dict[dev]['partition']['free '+str(p_num+1)]['num'] = p_num + 1
|
||||
p_d.Partition.dict[dev]['partition']['free '+str(p_num+1)]['start'] =\
|
||||
p_d.Partition.dict[dev]['partition'][p]['start']
|
||||
p_d.Partition.dict[dev]['partition']['free '+str(p_num+1)]['end'] =\
|
||||
p_d.Partition.dict[dev]['partition'][p]['end']
|
||||
p_d.Partition.dict[dev]['partition']['free '+str(p_num+1)]['size'] =\
|
||||
p_d.Partition.dict[dev]['partition'][p]['size']
|
||||
p_d.Partition.dict[dev]['partition']['free '+str(p_num+1)]['type'] = ' '
|
||||
p_d.Partition.dict[dev]['partition']['free '+str(p_num+1)]['flags'] = ' '
|
||||
else:
|
||||
p_d.Partition.dict[dev]['partition'][p]['sn'] = p_d.Partition.dict[dev]['partition'][p]['sn']+1
|
||||
|
||||
if p_d.Partition.dict[dev]['partition'][p]['sn'] == partition_sn+1:
|
||||
p_d.delete_one_partition(p_d.Partition.dict, dev, p)
|
||||
if list_free_sorted != []:
|
||||
for f in list_free_sorted:
|
||||
if p_d.Partition.dict[dev]['partition'][f]['sn'] < extended_free_space_sn:
|
||||
if p_d.Partition.dict[dev]['partition'][f]['num'] > free_num:
|
||||
free_num = p_d.Partition.dict[dev]['partition'][f]['num']
|
||||
free_num += 1
|
||||
p_d.Partition.dict[dev]['partition']['free '+str(free_num)]['sn'] = int(partition_sn+1)
|
||||
p_d.Partition.dict[dev]['partition']['free '+str(free_num)]['num'] = int(free_num)
|
||||
p_d.Partition.dict[dev]['partition']['free '+str(free_num)]['start'] = partition_start
|
||||
p_d.Partition.dict[dev]['partition']['free '+str(free_num)]['end'] = partition_end
|
||||
p_d.Partition.dict[dev]['partition']['free '+str(free_num)]['size'] = size_set
|
||||
p_d.Partition.dict[dev]['partition']['free '+str(free_num)]['type'] = ''
|
||||
p_d.Partition.dict[dev]['partition']['free '+str(free_num)]['flags'] = ''
|
||||
|
||||
def del_partition(partition,dev):
|
||||
bb3 = ButtonBar(screen, (("Cancel", "cancel"), ("Delete", "delete")))
|
||||
g3 = GridForm(screen, "Del Partition", 1, 3)
|
||||
g3.add(TextboxReflowed(45, 'You are about to delete the partition "%s".' \
|
||||
%(partition)), 0, 0)
|
||||
g3.add(Label(""),0,1)
|
||||
g3.add(bb3, 0, 2)
|
||||
res3 = g3.runOnce()
|
||||
if bb3.buttonPressed(res3) == "delete":
|
||||
list_partition_all_sorted = p_d.sort_partition(p_d.Partition.dict, dev, "all")
|
||||
partition_sn = int(p_d.Partition.dict[dev]['partition'][partition]['sn'])
|
||||
for p in list_partition_all_sorted:
|
||||
p_sn = p_d.Partition.dict[dev]['partition'][p]['sn']
|
||||
if p_sn == partition_sn -1 and re.search('free', p):
|
||||
p_d.Partition.dict[dev]['partition'][p]['end']
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
p_d.Partition.init_from_os()
|
||||
|
||||
while(1):
|
||||
global ret
|
||||
showPartitionWindow()
|
||||
if bb.buttonPressed(res) == "cancel":
|
||||
ret = 1
|
||||
break
|
||||
if bb.buttonPressed(res) == "ok":
|
||||
ret = 0
|
||||
break
|
||||
# assign label(msdos or gpt) of dev
|
||||
if re.search("dev:", clb.current()) and bb.buttonPressed(res) == "new":
|
||||
dev = clb.current().split(":")[1]
|
||||
dev_size = clb.current().split(":")[2]
|
||||
rb = RadioBar(screen, (("gpt", "gpt", 0),("msdos", "msdos", 1)))
|
||||
bb1 = ButtonBar(screen, (("Cancel", "cancel"), ("OK", "ok")))
|
||||
g = GridForm(screen, "Partition table", 1, 4)
|
||||
g.add(TextboxReflowed(25, 'Warning! A new partition table will be created on "%s" and the data on it will be cleared.' \
|
||||
%(dev)), 0, 0)
|
||||
g.add(Label(""),0,1)
|
||||
g.add(rb,0,2,(0,0,0,1))
|
||||
g.add(bb1, 0, 3)
|
||||
res1 = g.runOnce()
|
||||
if bb1.buttonPressed(res1) == "ok":
|
||||
label = rb.getSelection()
|
||||
p_d.Partition.dict[dev]['partition_table'] = label
|
||||
p_d.delete_all_partitions(p_d.Partition.dict, dev)
|
||||
|
||||
# add partition when dev's label is msdos
|
||||
elif re.search("partition:free", clb.current()) and \
|
||||
clb.current().split(':')[6] == 'msdos'and \
|
||||
bb.buttonPressed(res) == "new":
|
||||
dev = clb.current().split(":")[2]
|
||||
dev_name = dev.split("/dev/")[1]
|
||||
free_space_start = clb.current().split(":")[4]
|
||||
free_space_end = clb.current().split(":")[5]
|
||||
free_space_size = clb.current().split(":")[3]
|
||||
|
||||
(count_primary, count_extended) = count_primary_extended(dev)
|
||||
# add logical partition when an extended partition exists
|
||||
if re.search('extended', str(p_d.Partition.dict[dev])):
|
||||
(extended_start, extended_end) = get_extended_start_end(dev)
|
||||
if int(filter(str.isdigit,free_space_start)) >= int(filter(str.isdigit,extended_start)) \
|
||||
and int(filter(str.isdigit,free_space_end)) <= int(filter(str.isdigit,extended_end)):
|
||||
ptype = 'logical'
|
||||
#print 'ptype'
|
||||
#time.sleep(5)
|
||||
add_partition(ptype, 'extended', 'msdos')
|
||||
elif int(filter(str.isdigit,free_space_start)) >= int(filter(str.isdigit,extended_end)):
|
||||
show_error("Bad partition scheme ! This free space can't be used any more !")
|
||||
else:
|
||||
if count_primary == 3:
|
||||
show_error('You can not add new primary or extended partition any more !')
|
||||
else:
|
||||
ptype = 'primary'
|
||||
add_partition(ptype, 'extended', 'msdos')
|
||||
else:
|
||||
if count_primary == 4:
|
||||
show_error("You can't add partitions any more !")
|
||||
else:
|
||||
add_partition(ptype='', extended='', label='msdos')
|
||||
elif re.search("partition:free", clb.current()) and \
|
||||
clb.current().split(':')[6] == 'gpt'and \
|
||||
bb.buttonPressed(res) == "new":
|
||||
dev = clb.current().split(":")[2]
|
||||
free_space_start = clb.current().split(":")[4]
|
||||
free_space_end = clb.current().split(":")[5]
|
||||
free_space_size = clb.current().split(":")[3]
|
||||
add_partition(ptype='primary', extended='', label='gpt')
|
||||
elif re.search("partition:free", clb.current()) == None and \
|
||||
re.search("dev:", clb.current()) == None and \
|
||||
bb.buttonPressed(res) == "delete":
|
||||
dev = clb.current().split(":")[2]
|
||||
partition = clb.current().split(":")[1]
|
||||
del_partition(partition, dev)
|
||||
|
||||
|
||||
|
||||
screen.finish()
|
||||
#p_d.pretty(p_d.Partition.dict)
|
||||
p_d.write_to_xml_file()
|
||||
@@ -1,170 +0,0 @@
|
||||
#! /bin/sh -e
|
||||
# get from debian-installer-utils list-devices-linux
|
||||
|
||||
TYPE="$1"
|
||||
|
||||
case $TYPE in
|
||||
maybe-floppy)
|
||||
#logger -t list-devices "deprecated parameter maybe-floppy"
|
||||
TYPE=floppy
|
||||
;;
|
||||
cd|disk|partition|floppy|maybe-usb-floppy|usb-partition) ;;
|
||||
*)
|
||||
echo "Usage: $0 cd|disk|partition|floppy|maybe-usb-floppy|usb-partition" >&2
|
||||
exit 2
|
||||
;;
|
||||
esac
|
||||
|
||||
if [ ! -d /sys/block ]; then
|
||||
exit 0
|
||||
fi
|
||||
if type udevadm >/dev/null 2>&1; then
|
||||
device_info () {
|
||||
udevadm info -q "$1" -p "$2" 2>/dev/null
|
||||
}
|
||||
elif type udevinfo >/dev/null 2>&1; then
|
||||
device_info () {
|
||||
udevinfo -q "$1" -p "$2" 2>/dev/null
|
||||
}
|
||||
else
|
||||
exit 0
|
||||
fi
|
||||
|
||||
device_name () {
|
||||
local name
|
||||
if ! name="$(device_info name "$1")"; then
|
||||
name="$(printf %s "${1##*/}" | \
|
||||
sed 's,!,/,g')"
|
||||
fi
|
||||
echo "/dev/$name"
|
||||
}
|
||||
|
||||
is_sataraid () {
|
||||
grep -qs ^DMRAID- "$1/dm/uuid"
|
||||
}
|
||||
|
||||
is_sataraid_partition () {
|
||||
# dmraid partitions are always slaved to another dm device
|
||||
for slave in "$1"/slaves/dm-*; do
|
||||
if [ -e "$slave" ]; then
|
||||
return 0
|
||||
fi
|
||||
done
|
||||
return 1
|
||||
}
|
||||
|
||||
if type dmraid >/dev/null 2>&1; then
|
||||
raiddevs="$(dmraid -r -c || true)"
|
||||
else
|
||||
raiddevs=
|
||||
fi
|
||||
|
||||
# cloned-and-hacked from partman-base/init.d/parted
|
||||
part_of_sataraid () {
|
||||
local raiddev
|
||||
for raiddev in $raiddevs; do
|
||||
if [ "$(readlink -f "$raiddev")" = "$1" ]; then
|
||||
return 0
|
||||
fi
|
||||
done
|
||||
return 1
|
||||
}
|
||||
|
||||
syspaths=
|
||||
scan_partition=false
|
||||
case $TYPE in
|
||||
partition)
|
||||
for x in /sys/block/*/*[0-9]; do
|
||||
[ -d "$x" ] || continue
|
||||
syspaths="${syspaths:+$syspaths }$x"
|
||||
done
|
||||
for x in /sys/block/dm-*; do
|
||||
[ -d "$x" ] || continue
|
||||
(is_sataraid "$x" && is_sataraid_partition "$x") || continue
|
||||
syspaths="${syspaths:+$syspaths }$x"
|
||||
done
|
||||
TYPE=disk
|
||||
# Also allow misdetected USB devices
|
||||
scan_partition=:
|
||||
;;
|
||||
usb-partition)
|
||||
for x in /sys/block/*/*; do
|
||||
[ -d "$x" ] || continue
|
||||
syspaths="${syspaths:+$syspaths }$x"
|
||||
done
|
||||
;;
|
||||
*)
|
||||
for x in /sys/block/*; do
|
||||
[ -d "$x" ] || continue
|
||||
case $x in
|
||||
/sys/block/dm-*)
|
||||
if is_sataraid "$x" && is_sataraid_partition "$x"; then
|
||||
continue
|
||||
fi
|
||||
;;
|
||||
*)
|
||||
name="$(device_name "$x")"
|
||||
if part_of_sataraid "$name"; then
|
||||
continue
|
||||
fi
|
||||
;;
|
||||
esac
|
||||
syspaths="${syspaths:+$syspaths }$x"
|
||||
done
|
||||
;;
|
||||
esac
|
||||
for x in $syspaths; do
|
||||
devpath="${x#/sys}"
|
||||
match=false
|
||||
case $TYPE in
|
||||
floppy)
|
||||
# TODO ugly special case for non-IDE floppies
|
||||
case $devpath in
|
||||
/block/fd[0-9]*)
|
||||
match=:
|
||||
;;
|
||||
esac
|
||||
;;
|
||||
esac
|
||||
if ! $match && [ "$TYPE" = cd ]; then
|
||||
if device_info env "$devpath" | grep -q '^ID_CDROM='; then
|
||||
match=:
|
||||
fi
|
||||
fi
|
||||
if ! $match; then
|
||||
if device_info env "$devpath" | grep -q "^ID_TYPE=$TYPE"; then
|
||||
match=:
|
||||
fi
|
||||
fi
|
||||
if ! $match && [ "$TYPE" = disk ]; then
|
||||
case $devpath in
|
||||
/block/cciss\!*|/block/ida\!*|/block/rd\!*|/block/mmcblk*|/block/vd[a-z]*|/block/xvd[a-z]*)
|
||||
match=:
|
||||
;;
|
||||
/block/dm-*)
|
||||
# for now, we only understand dmraid
|
||||
if is_sataraid "/sys$devpath"; then
|
||||
match=:
|
||||
fi
|
||||
;;
|
||||
esac
|
||||
fi
|
||||
# Some USB sticks and CD drives are misdetected as floppy
|
||||
# This allows to scan for those
|
||||
if ! $match && ( $scan_partition || [ "$TYPE" = maybe-usb-floppy ] ); then
|
||||
if device_info env "$devpath" | grep -q '^ID_BUS=usb' && \
|
||||
device_info env "$devpath" | grep -q '^ID_TYPE=floppy'; then
|
||||
match=:
|
||||
fi
|
||||
fi
|
||||
# Disk partitions, but only on USB drives
|
||||
if ! $match && [ "$TYPE" = usb-partition ]; then
|
||||
if device_info env "$devpath" | grep -q '^ID_BUS=usb' && \
|
||||
device_info env "$devpath" | grep -q '^ID_TYPE=disk'; then
|
||||
match=:
|
||||
fi
|
||||
fi
|
||||
if $match; then
|
||||
device_name "/sys$devpath"
|
||||
fi
|
||||
done
|
||||
@@ -1,558 +0,0 @@
|
||||
#!/usr/bin/env python
|
||||
|
||||
from snack import *
|
||||
import gettext
|
||||
_ = lambda x: gettext.ldgettext("linx", x)
|
||||
|
||||
import sys
|
||||
import os
|
||||
import re
|
||||
import string
|
||||
|
||||
data_dir = '/tmp/new_partitions'
|
||||
os.mkdir(data_dir)
|
||||
|
||||
screen = SnackScreen()
|
||||
|
||||
screen.drawRootText(0, 0, "Welcome to Rocky Security OS")
|
||||
|
||||
screen.pushHelpLine( _(" F1-New F2-Delete F3-Boot F4-Raid F12-OK "))
|
||||
|
||||
global p_num
|
||||
p_num = dict()
|
||||
|
||||
def invalidnumber(str, maxsize):
|
||||
ints = string.digits + "."
|
||||
if str == "":
|
||||
return ("Must specify a value")
|
||||
for n in str:
|
||||
if n not in ints:
|
||||
return ("Requested value is not an number")
|
||||
if float(str) > float(maxsize):
|
||||
return ("Requested value is too large")
|
||||
|
||||
def showInvalidNumberWindow(tips):
|
||||
g21 = GridForm(screen, "Invalid Entry for Partition Size", 1, 2)
|
||||
g21.add(Label("%s." %(tips)), 0, 0)
|
||||
g21.add(Button("OK"), 0, 1)
|
||||
g21.runOnce()
|
||||
|
||||
def findstrinfile(filename, lookup):
|
||||
return lookup in open(filename, 'rt').read()
|
||||
|
||||
def get_extended_end(filename):
|
||||
f_extended = open(filename, 'r')
|
||||
for end in f_extended.readlines():
|
||||
if re.search('extended',end):
|
||||
extended_end = end.split('\n')[0].split()[2]
|
||||
f_extended.close()
|
||||
return extended_end
|
||||
else:
|
||||
continue
|
||||
f_extended.close()
|
||||
|
||||
def get_extended_start(filename):
|
||||
f_extended = open(filename, 'r')
|
||||
for start in f_extended.readlines():
|
||||
if re.search('extended',start):
|
||||
extended_start = start.split('\n')[0].split()[1]
|
||||
f_extended.close()
|
||||
return extended_start
|
||||
else:
|
||||
continue
|
||||
f_extended.close()
|
||||
|
||||
def conform_start_end(free_space_start, size_set, flag_align=""):
|
||||
free_space_start_unit = filter(str.isalpha, free_space_start)
|
||||
size_set_unit = filter(str.isalpha, size_set)
|
||||
free_space_start_num = get_size_num(free_space_start)
|
||||
size_set_num = get_size_num(size_set)
|
||||
size_set_num_orig = size_set_num
|
||||
|
||||
if size_set_unit == free_space_start_unit:
|
||||
pass
|
||||
else:
|
||||
if free_space_start_unit == "kB" and size_set_unit == "MB":
|
||||
#size_set_num = float(size_set_num) * 1000
|
||||
free_space_start_num = float(free_space_start_num) / 1000
|
||||
elif free_space_start_unit == "kB" and size_set_unit == "GB":
|
||||
#size_set_num = float(size_set_num) * 1000 * 1000
|
||||
free_space_start_num = float(free_space_start_num) / 1000 / 1000
|
||||
elif free_space_start_unit == "MB" and size_set_unit == "kB":
|
||||
size_set_num = float(size_set_num) / 1000
|
||||
size_set_unit = free_space_start_unit
|
||||
elif free_space_start_unit == "MB" and size_set_unit == "GB":
|
||||
#size_set_num = float(size_set_num) * 1000
|
||||
free_space_start_num = float(free_space_start_num) / 1000
|
||||
elif free_space_start_unit == "GB" and size_set_unit == "kB":
|
||||
size_set_num = float(size_set_num) / 1000 / 1000
|
||||
size_set_unit = free_space_start_unit
|
||||
elif free_space_start_unit == "GB" and size_set_unit == "MB":
|
||||
size_set_num = float(size_set_num) / 1000
|
||||
size_set_unit = free_space_start_unit
|
||||
|
||||
if flag_align == "0%":
|
||||
if size_set_unit == "kB":
|
||||
size_set_num_tmp = float(size_set_num_orig)
|
||||
if size_set_unit == "MB":
|
||||
size_set_num_tmp = float(size_set_num_orig) * 1000
|
||||
elif size_set_unit == "GB":
|
||||
size_set_num_tmp = float(size_set_num_orig) * 1000 * 1000
|
||||
|
||||
if size_set_num_tmp < 2000:
|
||||
free_space_end = "2MB"
|
||||
else:
|
||||
free_space_end = size_set
|
||||
else:
|
||||
free_space_end_num = float(free_space_start_num) + float(size_set_num)
|
||||
free_space_end = str(free_space_end_num) + size_set_unit
|
||||
|
||||
return free_space_end
|
||||
|
||||
def conform_and_compare(var1, var2, sign):
|
||||
|
||||
var1_unit = filter(str.isalpha, var1)
|
||||
var2_unit = filter(str.isalpha, var2)
|
||||
var1_num = get_size_num(var1)
|
||||
var2_num = get_size_num(var2)
|
||||
|
||||
if var1_unit == var2_unit:
|
||||
pass
|
||||
if var1_unit == "kB" and var2_unit == "MB":
|
||||
var2_num = float(var2_num) * 1000
|
||||
elif var1_unit == "kB" and var2_unit == "GB":
|
||||
var2_num = float(var2_num) * 1000 * 1000
|
||||
elif var1_unit == "MB" and var2_unit == "kB":
|
||||
var2_num = float(var2_num) / 1000
|
||||
elif var1_unit == "MB" and var2_unit == "GB":
|
||||
var2_num = float(var2_num) * 1000
|
||||
elif var1_unit == "GB" and var2_unit == "kB":
|
||||
var2_num = float(var2_num) / 1000 / 1000
|
||||
elif var1_unit == "GB" and var2_unit == "MB":
|
||||
var2_num = float(var2_num) / 1000
|
||||
|
||||
var2_num = float(var2_num)
|
||||
var1_num = float(var1_num)
|
||||
|
||||
if sign == ">=":
|
||||
if var2_num >= var1_num:
|
||||
return True
|
||||
else:
|
||||
return False
|
||||
elif sign == "<=":
|
||||
if var2_num <= var1_num:
|
||||
return True
|
||||
else:
|
||||
return False
|
||||
|
||||
|
||||
def get_disk_label(disk_name):
|
||||
os.system("parted /dev/%s print |grep 'Partition Table:'|awk -F':' \
|
||||
'{print $2}' >%s/label-%s" %(disk_name, data_dir, disk_name))
|
||||
f_disk_label = open("%s/label-%s" %(data_dir, disk_name))
|
||||
label = f_disk_label.readline().split('\n')[0].strip()
|
||||
f_disk_label.close()
|
||||
|
||||
return label
|
||||
|
||||
def get_size_num(size):
|
||||
if re.search('kB', size):
|
||||
size_num = size.split('kB')[0]
|
||||
elif re.search('MB', size):
|
||||
size_num = size.split('MB')[0]
|
||||
elif re.search('GB', size):
|
||||
size_num = size.split('GB')[0]
|
||||
return size_num
|
||||
|
||||
def get_new_partition_num(dev, dev_name, ptype):
|
||||
p_num_new = dict()
|
||||
p_num_new['logical_num_'+dev_name] = []
|
||||
p_num_new['primary_num_'+dev_name] = []
|
||||
|
||||
os.system('parted %s print free |sed -n "/^Number/,//p" |sed \
|
||||
"/^Number/d" |sed "/^$/d">%s/%s-partitions 2>/dev/null' %(dev,data_dir,dev_name))
|
||||
f_partitions = open("%s/%s-partitions" %(data_dir,dev_name), 'r')
|
||||
|
||||
label = get_disk_label(dev_name)
|
||||
|
||||
if label == "gpt":
|
||||
for p in f_partitions.readlines():
|
||||
p = p.split('\n')[0]
|
||||
if re.search('Free Space', p):
|
||||
pass
|
||||
else:
|
||||
p_num_new['primary_num_'+dev_name].append(int(p.split()[0]))
|
||||
elif label == "msdos":
|
||||
for p in f_partitions.readlines():
|
||||
p = p.split('\n')[0]
|
||||
ptype = p.split()[4]
|
||||
if re.search('Free Space', p):
|
||||
pass
|
||||
else:
|
||||
if ptype == "logical":
|
||||
p_num_new['logical_num_'+dev_name].append(int(p.split()[0]))
|
||||
else:
|
||||
if ptype != "extended":
|
||||
p_num_new['primary_num_'+dev_name].append(int(p.split()[0]))
|
||||
|
||||
f_partitions.close()
|
||||
return p_num_new
|
||||
|
||||
def set_partition_flag(ptype, dev, dev_name, flag):
|
||||
p_num_new = get_new_partition_num(dev,dev_name,ptype)
|
||||
for i in p_num_new[ptype+'_num_'+dev_name]:
|
||||
if i not in p_num[ptype+'_num_'+dev_name]:
|
||||
if flag == 'boot':
|
||||
os.system("parted -s %s set %d boot >/dev/null 2>&1" %(dev, i))
|
||||
elif flag == 'raid':
|
||||
os.system("parted -s %s set %d raid >/dev/null 2>&1" %(dev, i))
|
||||
|
||||
def new_partition(ptype='', extended='', label=''):
|
||||
dev = clb.current().split(":")[2]
|
||||
dev_name = dev.split("/")[2]
|
||||
size = clb.current().split(":")[3]
|
||||
free_space_start = clb.current().split(":")[4]
|
||||
end = clb.current().split(":")[5]
|
||||
|
||||
if re.search('kB', free_space_start) and \
|
||||
float(get_size_num(free_space_start)) < 2048:
|
||||
free_space_start_real = free_space_start
|
||||
free_space_start = '0%'
|
||||
|
||||
size_num = get_size_num(size)
|
||||
unit = filter(str.isalpha, size)
|
||||
|
||||
bb2 = ButtonBar(screen, (("OK", "ok"), ("Cancel", "cancel")))
|
||||
|
||||
sg21 = Grid(2,1)
|
||||
typeLbl = Label("File System type: ")
|
||||
lb_fstype = Listbox(height=3, scroll=1)
|
||||
list_fs = ['ext2', 'ext3', 'ext4', 'linux-swap', 'raid', 'reiserfs', 'xfs', 'jfs']
|
||||
for fs in list_fs:
|
||||
lb_fstype.append(fs, fs)
|
||||
lb_fstype.setCurrent('ext3')
|
||||
sg21.setField(typeLbl, 0, 0, anchorLeft=0)
|
||||
sg21.setField(lb_fstype, 1, 0)
|
||||
|
||||
sg22 = Grid(2,1)
|
||||
sizeLbl = Label("Size(%s): " %(unit))
|
||||
size_entry = Entry(10, size_num)
|
||||
sg22.setField(sizeLbl, 0, 0)
|
||||
sg22.setField(size_entry, 1, 0)
|
||||
|
||||
sg23 = Grid(2,1)
|
||||
rb_primary = SingleRadioButton("primary", None, 1)
|
||||
rb_extended = SingleRadioButton("extended", rb_primary)
|
||||
sg23.setField(rb_primary, 0, 0)
|
||||
sg23.setField(rb_extended, 1, 0)
|
||||
|
||||
cb_boot = Checkbox("Force to be a bootable partition")
|
||||
|
||||
g2 = GridForm(screen, "New Partition(%s)" %(dev), 1, 9)
|
||||
g2.add(sg21,0,0)
|
||||
g2.add(Label(""),0,1)
|
||||
g2.add(sg22,0,2)
|
||||
g2.add(Label(""),0,3)
|
||||
g2.add(cb_boot,0,4)
|
||||
g2.add(Label(""),0,5)
|
||||
|
||||
if extended == "extended" or label == 'gpt':
|
||||
g2.add(bb2, 0, 6)
|
||||
res2 = g2.runOnce()
|
||||
if label == 'gpt':
|
||||
ptype = 'primary'
|
||||
else:
|
||||
g2.add(sg23,0,6)
|
||||
g2.add(Label(""),0,7)
|
||||
g2.add(bb2, 0, 8)
|
||||
res2 = g2.runOnce()
|
||||
if rb_primary.selected():
|
||||
ptype = 'primary'
|
||||
else:
|
||||
ptype = 'extended'
|
||||
|
||||
if bb2.buttonPressed(res2) == "ok":
|
||||
fs_set = lb_fstype.current()
|
||||
|
||||
tips = invalidnumber(size_entry.value(), size_num)
|
||||
if tips:
|
||||
showInvalidNumberWindow(tips)
|
||||
else:
|
||||
size_set = size_entry.value() + unit
|
||||
if free_space_start == "0%":
|
||||
free_space_end = conform_start_end(free_space_start_real,size_set,"0%")
|
||||
else:
|
||||
free_space_end = conform_start_end(free_space_start, size_set)
|
||||
|
||||
if ptype == 'primary' or ptype == 'logical':
|
||||
if fs_set == 'raid':
|
||||
os.system("parted -s %s mkpart %s %s %s >/dev/null 2>&1" %(dev, ptype,\
|
||||
free_space_start, free_space_end))
|
||||
set_partition_flag(ptype, dev, dev_name, 'raid')
|
||||
elif fs_set == 'linux-swap':
|
||||
os.system("parted -s %s mkpartfs %s %s %s %s >/dev/null 2>&1" %(dev, ptype,\
|
||||
fs_set,free_space_start, free_space_end))
|
||||
else:
|
||||
os.system("parted -s %s mkpart %s %s %s %s >/dev/null 2>&1" %(dev, ptype,\
|
||||
fs_set,free_space_start, free_space_end))
|
||||
if cb_boot.value() == 1:
|
||||
set_partition_flag(ptype, dev, dev_name, 'boot')
|
||||
elif ptype == 'extended':
|
||||
os.system("parted -s %s mkpart %s %s %s >/dev/null 2>&1" %(dev, ptype,\
|
||||
free_space_start, free_space_end))
|
||||
|
||||
|
||||
def del_partition():
|
||||
dev = clb.current().split(":")[1]
|
||||
bb3 = ButtonBar(screen, (("Cancel", "cancel"), ("Delete", "delete")))
|
||||
g3 = GridForm(screen, "Del Partition", 1, 3)
|
||||
g3.add(TextboxReflowed(45, 'You are about to delete the partition "%s".' \
|
||||
%(dev,)), 0, 0)
|
||||
g3.add(Label(""),0,1)
|
||||
g3.add(bb3, 0, 2)
|
||||
res3 = g3.runOnce()
|
||||
if bb3.buttonPressed(res3) == "delete":
|
||||
disk = "/dev/" + filter(str.isalpha, dev)
|
||||
num = filter(str.isdigit, dev)
|
||||
ptype = clb.current().split(":")[2]
|
||||
os.system("parted -s %s rm %s >/dev/null 2>&1" %(disk, num))
|
||||
|
||||
def showPartitionWindow():
|
||||
p_num.clear()
|
||||
global clb
|
||||
clb = CListbox(height=10, cols=6,
|
||||
col_widths=[13,11,11,11,10,12],
|
||||
scroll=1, returnExit = 1,
|
||||
width=79, col_pad=2,
|
||||
col_labels=[_('Device'), _('Start'), _('End'), _('Size'), _('Type'), _('Flags')],
|
||||
col_label_align=[CENTER,CENTER,CENTER,CENTER,CENTER,CENTER])
|
||||
|
||||
os.system("../new_partition/parted_devices |awk -F' ' '{print $1}' >%s/disks 2>/dev/null" %(data_dir))
|
||||
f_disk = open("%s/disks" %(data_dir), 'r')
|
||||
|
||||
for d in f_disk.readlines():
|
||||
disk = d.split('\n')[0]
|
||||
disk_name = disk.split('/')[2]
|
||||
|
||||
p_num['logical_num_'+disk_name] = []
|
||||
p_num['primary_num_'+disk_name] = []
|
||||
|
||||
clb.append(["%s" %(disk),"","","","",""], \
|
||||
"disk:%s" %(disk), \
|
||||
[LEFT, RIGHT, RIGHT, RIGHT, LEFT, LEFT])
|
||||
|
||||
os.system('parted %s print free |sed -n "/^Number/,//p" |sed \
|
||||
"/^Number/d" |sed "/^$/d" >%s/%s-partitions 2>/dev/null' %(disk,data_dir,disk_name))
|
||||
|
||||
f_partitions = open("%s/%s-partitions" %(data_dir,disk_name), 'r')
|
||||
|
||||
for p in f_partitions.readlines():
|
||||
p = p.split('\n')[0]
|
||||
if re.search('Free Space', p):
|
||||
size = p.split()[2]
|
||||
if re.search('512B', size) or (float(get_size_num(size)) < 2048 \
|
||||
and filter(str.isalpha, size) == 'kB'):
|
||||
continue
|
||||
partition = "Free Space"
|
||||
start = p.split()[0]
|
||||
end = p.split()[1]
|
||||
ptype = p.split()[3] + " " + p.split()[4]
|
||||
fs = ""
|
||||
flags = ""
|
||||
|
||||
label = get_disk_label(disk_name)
|
||||
|
||||
clb.append([" %s" %(partition),
|
||||
"%s" %(start),
|
||||
"%s" %(end),
|
||||
"%s" %(size),
|
||||
"%s" %(ptype),
|
||||
"%s" %(flags)], "partition:%s:%s:%s:%s:%s:%s" %(partition,disk, size, start, end,label),
|
||||
[LEFT, RIGHT, RIGHT, RIGHT, LEFT, LEFT])
|
||||
|
||||
else:
|
||||
partition = disk_name + p.split()[0]
|
||||
|
||||
start = p.split()[1]
|
||||
end = p.split()[2]
|
||||
size = p.split()[3]
|
||||
ptype = p.split()[4]
|
||||
|
||||
if ptype == "logical":
|
||||
p_num['logical_num_'+disk_name].append(int(p.split()[0]))
|
||||
else:
|
||||
if ptype != "extended":
|
||||
p_num['primary_num_'+disk_name].append(int(p.split()[0]))
|
||||
|
||||
os.system("blkid /dev/%s |awk -F' TYPE=' '{print $2}' |awk \
|
||||
-F'\"' '{print $2}' >%s/fsType-%s 2>/dev/null" %(partition,data_dir,partition))
|
||||
|
||||
f_partitions_fs = open("%s/fsType-%s" %(data_dir,partition))
|
||||
fs = f_partitions_fs.readline().split('\n')[0]
|
||||
flags = ""
|
||||
|
||||
try:
|
||||
if fs != "":
|
||||
try:
|
||||
flags = p.split()[6] + p.split()[7]
|
||||
except:
|
||||
flags = p.split()[6]
|
||||
else:
|
||||
try:
|
||||
#flags = p.split()[5] + ", " + p.split()[6]
|
||||
flags = p.split()[5] + " " + p.split()[6]
|
||||
except:
|
||||
flags = p.split()[5]
|
||||
except:
|
||||
pass
|
||||
|
||||
if fs == "swap":
|
||||
if flags == "":
|
||||
flags = fs
|
||||
else:
|
||||
flags = flags + ", swap"
|
||||
|
||||
#if fs == "linux_raid_member":
|
||||
# if flags == "":
|
||||
# flags = 'raid'
|
||||
# else:
|
||||
# flags = flags + ", raid"
|
||||
|
||||
clb.append([" %s" %(partition),
|
||||
"%s" %(start),
|
||||
"%s" %(end),
|
||||
"%s" %(size),
|
||||
"%s" %(ptype),
|
||||
"%s" %(flags)], "partition:%s:%s:%s:%s" %(partition, ptype, disk, flags),
|
||||
[LEFT, RIGHT, RIGHT, RIGHT, LEFT, LEFT])
|
||||
|
||||
f_partitions_fs.close()
|
||||
|
||||
|
||||
f_partitions.close()
|
||||
|
||||
f_disk.close()
|
||||
|
||||
global bb
|
||||
bb = ButtonBar (screen, ((_("New"), "new", "F1"),
|
||||
(_("Delete"), "delete", "F2"),
|
||||
(_("Boot"), "boot", "F3"),
|
||||
(_("Raid"), "raid", "F4"),
|
||||
(_("OK"), "ok", "F12"),
|
||||
(_("Cancel"), "cancel"),
|
||||
))
|
||||
|
||||
sg = Grid(2, 3)
|
||||
sg.setField(bb, 0, 1, anchorLeft = 1)
|
||||
|
||||
g = Grid(1, 3)
|
||||
g.setField(clb, 0, 0)
|
||||
g.setField(sg, 0, 2)
|
||||
#g.setField(bb, 0, 1)
|
||||
g.place(1, 1)
|
||||
screen.gridWrappedWindow(g, "Partitioning")
|
||||
|
||||
f = Form("This is some help")
|
||||
f.add(bb)
|
||||
f.add(clb)
|
||||
|
||||
f.addHotKey("F1")
|
||||
f.addHotKey("F2")
|
||||
f.addHotKey("F3")
|
||||
f.addHotKey("F4")
|
||||
f.addHotKey("F12")
|
||||
|
||||
global res
|
||||
res = f.run()
|
||||
|
||||
#screen.popWindow()
|
||||
screen.refresh()
|
||||
|
||||
while(1):
|
||||
global ret
|
||||
showPartitionWindow()
|
||||
|
||||
if bb.buttonPressed(res) == "cancel":
|
||||
ret = 1
|
||||
break
|
||||
|
||||
if bb.buttonPressed(res) == "ok":
|
||||
ret = 0
|
||||
break
|
||||
|
||||
if bb.buttonPressed(res) == "boot":
|
||||
if re.search("partition:", clb.current()) and \
|
||||
re.search("swap", clb.current()) == None and \
|
||||
re.search("raid", clb.current()) == None and \
|
||||
re.search("lba", clb.current()) == None:
|
||||
dev = clb.current().split(":")[3]
|
||||
partition_num = filter(str.isdigit, clb.current().split(":")[1])
|
||||
os.system("parted -s %s set %s boot >/dev/null 2>&1" %(dev, partition_num))
|
||||
|
||||
if bb.buttonPressed(res) == "raid":
|
||||
if re.search("partition:", clb.current()) and \
|
||||
re.search("lba", clb.current()) == None:
|
||||
dev = clb.current().split(":")[3]
|
||||
partition_num = filter(str.isdigit, clb.current().split(":")[1])
|
||||
os.system("parted -s %s set %s raid >/dev/null 2>&1" %(dev, partition_num))
|
||||
|
||||
# assign partition table label
|
||||
if re.search("disk:", clb.current()):
|
||||
dev = clb.current().split(":")[1]
|
||||
rb = RadioBar(screen, (("gpt", "gpt", 0),("msdos", "msdos", 1)))
|
||||
bb1 = ButtonBar(screen, (("Cancel", "cancel"), ("OK", "ok")))
|
||||
g = GridForm(screen, "Partition table", 1, 4)
|
||||
g.add(TextboxReflowed(25, 'Warning! A new partition table will be created on "%s" and the data on it will be cleared.' \
|
||||
%(dev,)), 0, 0)
|
||||
g.add(Label(""),0,1)
|
||||
g.add(rb,0,2,(0,0,0,1))
|
||||
g.add(bb1, 0, 3)
|
||||
res1 = g.runOnce()
|
||||
if bb1.buttonPressed(res1) == "ok":
|
||||
label = rb.getSelection()
|
||||
os.system("parted -s %s mklabel %s >/dev/null 2>&1" %(dev, label))
|
||||
|
||||
# new partition when partition table label is msdos
|
||||
elif re.search("partition:Free", clb.current()) and \
|
||||
clb.current().split(':')[6] == 'msdos'and \
|
||||
bb.buttonPressed(res) == "new":
|
||||
dev = clb.current().split(":")[2]
|
||||
dev_name = dev.split("/")[2]
|
||||
free_space_start = clb.current().split(":")[4]
|
||||
end = clb.current().split(":")[5]
|
||||
# new logical partition when partition table is msdos and there is
|
||||
# an extended partition
|
||||
if findstrinfile("%s/%s-partitions" %(data_dir,dev_name), "extended"):
|
||||
|
||||
extended_start = get_extended_start("%s/%s-partitions" %(data_dir,dev_name))
|
||||
extended_end = get_extended_end("%s/%s-partitions" %(data_dir,dev_name))
|
||||
|
||||
if conform_and_compare(extended_start, free_space_start, '>=') and \
|
||||
conform_and_compare(extended_end, end, '<='):
|
||||
ptype = 'logical'
|
||||
# new primary partition when partition table label is msdos and
|
||||
# there is an extended partition
|
||||
else:
|
||||
ptype = 'primary'
|
||||
|
||||
new_partition(ptype,'extended','msdos')
|
||||
|
||||
# new partition when partition table label is msdos and there is no
|
||||
# extended partition
|
||||
else:
|
||||
new_partition(ptype='', extended='', label='msdos')
|
||||
|
||||
# new partition when partition table label is gpt
|
||||
elif re.search("partition:Free", clb.current()) and \
|
||||
clb.current().split(':')[6] == 'gpt' and \
|
||||
bb.buttonPressed(res) == "new":
|
||||
new_partition(ptype='primary', extended='', label='gpt')
|
||||
elif re.search("partition:Free", clb.current()) == None and \
|
||||
re.search("disk:", clb.current()) == None and \
|
||||
bb.buttonPressed(res) == "delete":
|
||||
del_partition()
|
||||
|
||||
|
||||
screen.finish()
|
||||
os.system('rm -rf %s' %(data_dir))
|
||||
sys.exit(ret)
|
||||
Binary file not shown.
@@ -1,38 +1,60 @@
|
||||
#!/usr/bin/python
|
||||
#
|
||||
# pythonlized partman-base/parted_devices.c
|
||||
#
|
||||
|
||||
import parted
|
||||
import _ped
|
||||
import os,fcntl,array
|
||||
import re
|
||||
|
||||
'''is cdrom return 0'''
|
||||
def is_cdrom(path):
|
||||
CDROM_GET_CAPABILITY = 0x5331
|
||||
ret = 1
|
||||
|
||||
'''h: array type code, mean signed short '''
|
||||
buf= array.array('h', [0])
|
||||
fd = os.open(path, os.O_RDONLY | os.O_NONBLOCK)
|
||||
try:
|
||||
ret = fcntl.ioctl(fd, CDROM_GET_CAPABILITY, buf)
|
||||
ret = buf[0]
|
||||
except IOError:
|
||||
pass
|
||||
|
||||
return ret
|
||||
|
||||
'''is floppy return true'''
|
||||
def is_floppy(path):
|
||||
return path == "/dev/floppy" or path == "/dev/fd";
|
||||
|
||||
'''is device mapper return true,
|
||||
filter /dev/mapper, we don't use /dev/mapper in installer -- bqin'''
|
||||
def is_devicemapper(path):
|
||||
return (path.startswith("/dev/mapper"))
|
||||
|
||||
def process_device(dev):
|
||||
if dev.readOnly == 1:
|
||||
return
|
||||
if not is_cdrom(dev.path) or is_floppy(dev.path) or is_devicemapper(dev.path):
|
||||
return
|
||||
if dev.path == "/dev/ramzswap" or dev.path == "/dev/zram":
|
||||
return
|
||||
return dev.path
|
||||
|
||||
|
||||
# class from pyparted-3.4/tests/_ped/baseclass.py
|
||||
# Base class for any test case that requires a list being built via successive
|
||||
# calls of some function. The function must raise IndexError when there's no
|
||||
# more output to add to the return list. This class is most useful for all
|
||||
# those _get_next methods.
|
||||
class BuildList:
|
||||
def getDeviceList(self, func):
|
||||
lst = []
|
||||
prev = None
|
||||
def get_disks():
|
||||
disk_list = []
|
||||
|
||||
while True:
|
||||
try:
|
||||
if not prev:
|
||||
prev = func()
|
||||
else:
|
||||
prev = func(prev)
|
||||
device_list = parted.getAllDevices()
|
||||
|
||||
lst.append(prev)
|
||||
except IndexError:
|
||||
break
|
||||
for i in range(len(device_list)):
|
||||
item = process_device(device_list[i])
|
||||
if item:
|
||||
disk_list.append(item)
|
||||
|
||||
return lst
|
||||
return disk_list
|
||||
|
||||
|
||||
_ped.device_probe_all()
|
||||
List = BuildList()
|
||||
disk_list = List.getDeviceList(_ped.device_get_next)
|
||||
|
||||
for i in range(len(disk_list)):
|
||||
print disk_list[i].path
|
||||
|
||||
#print _ped.device_get_next()
|
||||
if __name__ == "__main__":
|
||||
for i in get_disks():
|
||||
print i
|
||||
|
||||
373
new_partition/partition_data.py
Executable file
373
new_partition/partition_data.py
Executable file
@@ -0,0 +1,373 @@
|
||||
#!/usr/bin/python
|
||||
|
||||
import re,os
|
||||
import commands
|
||||
import subprocess
|
||||
import signal
|
||||
from xml.dom import minidom
|
||||
from collections import defaultdict
|
||||
import _ped
|
||||
import parted_devices
|
||||
|
||||
DEBUG = False
|
||||
|
||||
''' algorithm from libparted/unit.c '''
|
||||
def parse_unit_suffix(suffix):
|
||||
if (len(suffix) > 1) and (suffix[1] == 'i'):
|
||||
return {
|
||||
'k': _ped.UNIT_KIBIBYTE,
|
||||
'm': _ped.UNIT_MEBIBYTE,
|
||||
'g': _ped.UNIT_GIBIBYTE,
|
||||
't': _ped.UNIT_TEBIBYTE,
|
||||
}[suffix[0].lower()]
|
||||
elif (len(suffix) > 0):
|
||||
return {
|
||||
's': _ped.UNIT_SECTOR,
|
||||
'b': _ped.UNIT_BYTE,
|
||||
'k': _ped.UNIT_KILOBYTE,
|
||||
'm': _ped.UNIT_MEGABYTE,
|
||||
'g': _ped.UNIT_GIGABYTE,
|
||||
't': _ped.UNIT_TERABYTE,
|
||||
'c': _ped.UNIT_CYLINDER,
|
||||
'%': _ped.UNIT_PERCENT,
|
||||
}[suffix[0].lower()]
|
||||
|
||||
''' type name for display '''
|
||||
def get_type_name(type):
|
||||
try: return {
|
||||
_ped.PARTITION_NORMAL :'primary',
|
||||
_ped.PARTITION_LOGICAL :'logical',
|
||||
_ped.PARTITION_EXTENDED :'extended',
|
||||
_ped.PARTITION_FREESPACE :' ',
|
||||
_ped.PARTITION_METADATA :' ',
|
||||
_ped.PARTITION_PROTECTED :' ',
|
||||
}[type]
|
||||
except KeyError:
|
||||
return ' '
|
||||
|
||||
''' get_flags from rhel5 anaconda partedUtils.py
|
||||
algorithm the same as parted in parted.c partition_print_flags() '''
|
||||
def get_flags (part):
|
||||
string=""
|
||||
if not part.is_active ():
|
||||
return string
|
||||
first=1
|
||||
flag = _ped.partition_flag_next (0)
|
||||
while flag:
|
||||
if part.get_flag (flag):
|
||||
string = string + _ped.partition_flag_get_name (flag)
|
||||
if first:
|
||||
first = 0
|
||||
else:
|
||||
string = string + ", "
|
||||
flag = _ped.partition_flag_next (flag)
|
||||
return string
|
||||
|
||||
|
||||
'''make nested dict'''
|
||||
def makehash():
|
||||
return defaultdict(makehash)
|
||||
|
||||
class Partition:
|
||||
''' disk partition '''
|
||||
unit = ''
|
||||
dict = makehash()
|
||||
def __init__(self, dev, ds, pt, sn, partition, num, st, se, sz, tp, fs, fg, fr, fm, mp):
|
||||
''' Partition init function '''
|
||||
self.dict[dev][dev] = dev
|
||||
self.dict[dev]['disk_size'] = ds
|
||||
self.dict[dev]['partition_table'] = pt
|
||||
self.dict[dev]['partition'][partition]['sn']= sn
|
||||
self.dict[dev]['partition'][partition]['num']= num
|
||||
self.dict[dev]['partition'][partition]['start'] = st
|
||||
self.dict[dev]['partition'][partition]['end'] = se
|
||||
self.dict[dev]['partition'][partition]['size'] = sz
|
||||
self.dict[dev]['partition'][partition]['type'] = tp
|
||||
self.dict[dev]['partition'][partition]['filesystem'] = fs
|
||||
self.dict[dev]['partition'][partition]['flags'] = fg
|
||||
self.dict[dev]['partition'][partition]['from_os'] = fr
|
||||
self.dict[dev]['partition'][partition]['format'] = fm
|
||||
self.dict[dev]['partition'][partition]['mount_point'] = mp
|
||||
|
||||
@staticmethod
|
||||
def get_disks():
|
||||
return parted_devices.get_disks()
|
||||
|
||||
@staticmethod
|
||||
def check_partitions():
|
||||
cmd = "grep [a-zA-Z][0-9] /proc/partitions>/dev/null"
|
||||
ret = os.system(cmd)
|
||||
return ret
|
||||
|
||||
@staticmethod
|
||||
def init_from_os(unit='b'):
|
||||
|
||||
Partition.unit = unit
|
||||
|
||||
if Partition.unit:
|
||||
default_unit = parse_unit_suffix(Partition.unit)
|
||||
else:
|
||||
default_unit = _ped.UNIT_COMPACT
|
||||
_ped.unit_set_default(default_unit)
|
||||
|
||||
''' each disk '''
|
||||
for d in Partition.get_disks():
|
||||
_device = _ped.device_get(d)
|
||||
_disk = _ped.Disk(_device)
|
||||
_part = _disk.next_partition()
|
||||
''' free partition number '''
|
||||
fn = 0
|
||||
''' partition sequence number '''
|
||||
sn = 0
|
||||
''' each partition '''
|
||||
|
||||
''' algorithm from parted.c do_print() '''
|
||||
disk_start = _device.unit_format (0)
|
||||
disk_end = _device.unit_format_byte (_device.length * _device.sector_size \
|
||||
- (default_unit == _ped.UNIT_CHS or \
|
||||
default_unit == _ped.UNIT_CYLINDER))
|
||||
|
||||
disk_size = disk_end
|
||||
|
||||
partition_table = _disk.type.name
|
||||
dev = _device.path
|
||||
|
||||
if DEBUG:
|
||||
print dev
|
||||
print partition_table
|
||||
print disk_start
|
||||
print disk_size
|
||||
while _part:
|
||||
|
||||
''' skip _part.type = 9
|
||||
I can't find type 9 from pyparted '''
|
||||
if _part.type == 9:
|
||||
_part = _disk.next_partition(_part)
|
||||
continue
|
||||
|
||||
p_g = _part.geom
|
||||
|
||||
''' algorithm get from parted.c do_print() '''
|
||||
start = _device.unit_format(p_g.start)
|
||||
end = _device.unit_format_byte((p_g.end + 1) * _device.sector_size - 1)
|
||||
size = _device.unit_format(p_g.length)
|
||||
|
||||
if _part.num == -1:
|
||||
fn += 1
|
||||
num = fn
|
||||
partition = "free %s" %fn
|
||||
else:
|
||||
num = _part.num
|
||||
partition = _part.get_path()
|
||||
|
||||
type_name = get_type_name(_part.type)
|
||||
|
||||
try:
|
||||
fs = _part.fs_type.name
|
||||
except:
|
||||
fs = ' '
|
||||
''' may be PARTITION_METADATA mustn't appear at free space,
|
||||
but may be pyparted have bug, awareness last partition as
|
||||
metadata. But parted is not. '''
|
||||
if _part.type & _ped.PARTITION_FREESPACE or \
|
||||
_part.type & _ped.PARTITION_METADATA:
|
||||
fs = 'Free Space'
|
||||
|
||||
flags = get_flags(_part)
|
||||
|
||||
sn += 1
|
||||
if DEBUG:
|
||||
print "sn:%s, num:%s, %s, start:%s, end:%s, size:%s, type_name:%s, fs: %s, flags: %s" %(sn, num, partition, start, end, size, type_name, fs, flags)
|
||||
|
||||
''' create a Partition instance from hardware info'''
|
||||
Partition(dev , # device name
|
||||
disk_size, # disk size
|
||||
partition_table, # partition table
|
||||
sn, # partition sequence number
|
||||
partition, # partition
|
||||
num, # num
|
||||
start, # start
|
||||
end, # end
|
||||
size, # size
|
||||
type_name, # type
|
||||
fs, # file system
|
||||
flags, # flags
|
||||
'yes', # from os
|
||||
' ', # whether format
|
||||
' ' # mount point
|
||||
)
|
||||
_part = _disk.next_partition(_part)
|
||||
|
||||
'''TODO:
|
||||
need fix for new data structure or abandon
|
||||
'''
|
||||
@staticmethod
|
||||
def init_from_xml(node):
|
||||
''' create Partition instances from xml node '''
|
||||
Partition.unit = node.attributes['unit'].value.encode('ascii')
|
||||
for p in node.childNodes:
|
||||
if p.nodeType == node.ELEMENT_NODE and p.nodeName == 'partition':
|
||||
Partition(p.attributes['device'].value.encode('ascii'),\
|
||||
p.attributes['start'].value.encode('ascii'),\
|
||||
p.attributes['size'].value.encode('ascii'),\
|
||||
p.attributes['type'].value.encode('ascii'),\
|
||||
p.attributes['file-system'].value.encode('ascii'),\
|
||||
p.attributes['flags'].value.encode('ascii'),\
|
||||
p.attributes['from_os'].value.encode('ascii'))
|
||||
|
||||
|
||||
@staticmethod
|
||||
def to_xml(doc, p_node):
|
||||
''' write all Partition instance into xml
|
||||
doc - xml document instance
|
||||
p_node - xml node (parent node)'''
|
||||
pts = doc.createElement('disks')
|
||||
unit_attr = doc.createAttribute('unit')
|
||||
unit_attr.value = Partition.unit
|
||||
pts.setAttributeNode(unit_attr)
|
||||
|
||||
create_node(Partition.dict, doc, pts)
|
||||
p_node.appendChild(pts)
|
||||
p_node.appendChild(pts)
|
||||
|
||||
@staticmethod
|
||||
def get_disk_attr(disk, attr):
|
||||
try:
|
||||
return Partition.dict[disk][attr]
|
||||
except:
|
||||
return None
|
||||
|
||||
@staticmethod
|
||||
def get_partition_attr(partition, attr):
|
||||
disk = re.sub("\d+$", "", partition)
|
||||
try:
|
||||
return Partition.dict[disk]['partition'][partition][attr]
|
||||
except:
|
||||
return None
|
||||
|
||||
|
||||
|
||||
''' Fix Me:
|
||||
make recursive is better '''
|
||||
def create_node(d, doc, pts):
|
||||
for key in d.keys():
|
||||
dt = doc.createElement('disk')
|
||||
dt.setAttribute('disk', key)
|
||||
for k in d[key].keys():
|
||||
if k == 'partition':
|
||||
pt = doc.createElement('partitions')
|
||||
for l in d[key]['partition'].keys():
|
||||
lt = doc.createElement('partition')
|
||||
lt.setAttribute('partition', str(l))
|
||||
for m in d[key]['partition'][l].keys():
|
||||
'''if mount_point etc. is ' ', then can't set attribute,
|
||||
so I manual add space
|
||||
'''
|
||||
attr = "%s " %d[key]['partition'][l][m]
|
||||
if attr.rstrip():
|
||||
attr = attr.rstrip()
|
||||
lt.setAttribute(m, attr)
|
||||
pt.appendChild(lt)
|
||||
dt.appendChild(pt)
|
||||
elif k == 'disk_size':
|
||||
dt.setAttribute(str(k), d[key]['disk_size'])
|
||||
elif k == 'partition_table':
|
||||
dt.setAttribute(str(k), d[key]['partition_table'])
|
||||
pts.appendChild(dt)
|
||||
|
||||
def pretty(d, indent=0):
|
||||
for key, value in d.iteritems():
|
||||
print '\t' * indent + str(key)
|
||||
if isinstance(value, dict):
|
||||
pretty(value, indent+1)
|
||||
else:
|
||||
print '\t' * (indent+1) + str(value)
|
||||
|
||||
def delete_all_partitions(d, k):
|
||||
for key in d[k]['partition'].keys():
|
||||
d[k]['partition'].pop(key, None)
|
||||
|
||||
partition = 'free 1'
|
||||
sz = se = d[k]['disk_size']
|
||||
d[k]['partition'][partition]['sn']= 1
|
||||
d[k]['partition'][partition]['num']= 1
|
||||
d[k]['partition'][partition]['start'] = '0'
|
||||
d[k]['partition'][partition]['end'] = se
|
||||
d[k]['partition'][partition]['size'] = sz
|
||||
d[k]['partition'][partition]['type'] = ''
|
||||
d[k]['partition'][partition]['filesystem'] = ''
|
||||
d[k]['partition'][partition]['flags'] = ''
|
||||
d[k]['partition'][partition]['from_os'] = ''
|
||||
d[k]['partition'][partition]['format'] = ''
|
||||
d[k]['partition'][partition]['mount_point'] = ''
|
||||
|
||||
def delete_one_partition(dict, disk, partition):
|
||||
for key in dict[disk]['partition'].keys():
|
||||
if key == partition:
|
||||
del dict[disk]['partition'][key]
|
||||
|
||||
def sort_partition(dict, disk, p):
|
||||
f_d = {}
|
||||
p_d = {}
|
||||
|
||||
for k in dict[disk]["partition"]:
|
||||
if k.startswith("free"):
|
||||
f_d[k] = dict[disk]["partition"][k]["num"]
|
||||
else:
|
||||
p_d[k] = dict[disk]["partition"][k]["num"]
|
||||
|
||||
if p == "free":
|
||||
return (sorted(f_d, key = lambda key: f_d[key]))
|
||||
elif p == "partition":
|
||||
return (sorted(p_d, key = lambda key: p_d[key]))
|
||||
else:
|
||||
return
|
||||
|
||||
|
||||
def sort_partitions(dict, disk, p="all"):
|
||||
# k, t: partitions
|
||||
if p == "all":
|
||||
return (sorted(((k) for k in dict[disk]["partition"]), key=lambda \
|
||||
t: dict[disk]["partition"][t]["sn"]))
|
||||
elif p == "free":
|
||||
return sort_partition(dict, disk, "free")
|
||||
elif p == "partition":
|
||||
return sort_partition(dict, disk, "partition")
|
||||
|
||||
def write_to_xml_file():
|
||||
xmldoc = minidom.Document()
|
||||
root = xmldoc.createElement('install')
|
||||
xmldoc.appendChild(root)
|
||||
Partition.to_xml(xmldoc, root)
|
||||
xml_string =xmldoc.toprettyxml(indent=" ")
|
||||
print xml_string
|
||||
|
||||
|
||||
|
||||
|
||||
#if __name__ == "__main__":
|
||||
# Partition.init_from_os()
|
||||
#pretty(Partition.dict)
|
||||
#delete_all_partitions(Partition.dict, "/dev/sda")
|
||||
# delete_one_partition(Partition.dict, "/dev/sdb", "free 1")
|
||||
#pretty(Partition.dict)
|
||||
# print sort_partitions(Partition.dict, "/dev/sda", "all")
|
||||
# print "+"*100
|
||||
# print sort_partitions(Partition.dict, "/dev/sda", "free")
|
||||
# print "+"*100
|
||||
# print sort_partitions(Partition.dict, "/dev/sda", "partition")
|
||||
# write_to_xml_file()
|
||||
#print Partition.dict
|
||||
#print Partition.get_size("/dev/sda")
|
||||
#print Partition.get_disk_attr("/dev/sda", "disk_size")
|
||||
#print Partition.get_disk_attr("/dev/sda", "partition_table")
|
||||
#print Partition.get_partition_attr("/dev/sda1", "size")
|
||||
|
||||
# xmldoc = minidom.Document()
|
||||
# root = xmldoc.createElement('install')
|
||||
# xmldoc.appendChild(root)
|
||||
# Partition.to_xml(xmldoc, root)
|
||||
# xml_string = xmldoc.toprettyxml(indent=" ")
|
||||
|
||||
# print xml_string
|
||||
|
||||
Reference in New Issue
Block a user