def add_partition(mia, operid, devpath, parttype, fstype, start, end):
logger.d('add_partition %s' % str((devpath, parttype, fstype, start, end)))
fstype = revision_fstype(fstype)
if CF.S.all_harddisks.has_key(devpath):
(dev, disk, dirty_or_not) = CF.S.all_harddisks[devpath]
if disk:
constraint = parted.Constraint(device=dev)#exactGeom=newgeom)
if parttype == 'primary':
parttype = 0
elif parttype == 'extended':
parttype = parted.PARTITION_EXTENDED
elif parttype == 'logical':
parttype = parted.PARTITION_LOGICAL
if fstype != 'N/A':
fstype = parted.fileSystemType[fstype]
else:
fstype = None
try:
newgeom_bound = _grow_over_small_freespace(start, end, disk)
if not newgeom_bound:
return (-1, "Can't get the geometry of new partition (start=%s end=%s)." % (start, end))
newgeom = parted.Geometry(device=dev, start=newgeom_bound[0], end=newgeom_bound[1])
# We can use _ped's geometry to build parted's Geometry
if newgeom:
newpart = parted.Partition(disk=disk, type=parttype, geometry=newgeom)
disk.addPartition(partition=newpart, constraint=constraint)
if fstype:
newpart.getPedPartition().set_system(fstype)
except _ped.PartitionException, errmsg:
return(-1, str(errmsg))
CF.S.all_harddisks[devpath] = (dev, disk, 'y')
return (newpart.geometry.start, '')
def get_all_dirty_disk(mia, operid, dummy):
mia.set_step(operid, 0, -1)
result = []
for devpath in CF.S.all_harddisks.keys():
if CF.S.all_harddisks[devpath][2]:
result.append(devpath)
logger.d('get_all_dirty_disk result: %s' % str(result))
return result
def get_all_dirty_disk(mia, operid, dummy):
mia.set_step(operid, 0, -1)
result = []
for devpath in CF.S.all_harddisks.keys():
if CF.S.all_harddisks[devpath][2]:
result.append(devpath)
logger.d('get_all_dirty_disk result: %s' % str(result))
return result
def umount_tgtsys(mia, operid, tgtsys_devinfo):
dolog('umount_tgtsys %s' % repr(tgtsys_devinfo))
logger.d('######### UMount target system (please check the mount point) #############')
global dev_tgt # the target system devices.
logger.d('umount dev_tgt %s' % dev_tgt)
if dev_tgt:
dev_tgt.umount_tgt_device()
dev_tgt = None
return 0
def disk_new_fresh(mia, operid, devpath, dltype):
logger.d('disk_new_fresh %s %s' % (devpath, dltype))
#dltype = parted.disk_type_get(dltype)
dltype = parted.diskType[dltype]
if dltype and CF.S.all_harddisks.has_key(devpath):
dev = CF.S.all_harddisks[devpath][0]
#CF.S.all_harddisks[devpath] = (dev, dev.disk_new_fresh(dltype), 'y')
CF.S.all_harddisks[devpath] = (dev, parted.freshDisk(device=dev, ty=dltype), 'y')
return 0
def reload_partition_table(mia, operid, devpath):
logger.d('reload_partition_table %s' % devpath)
if CF.S.all_harddisks.has_key(devpath):
dev = CF.S.all_harddisks[devpath][0]
try:
CF.S.all_harddisks[devpath] = (dev, parted.Disk(dev), None)
except _ped.DiskLabelException:
dltype = parted.diskType['msdos']
CF.S.all_harddisks[devpath] = (dev, parted.freshDisk(device=dev, ty=dltype), 'y')
return 0
def mount_tgtsys(mia, operid, tgtsys_devinfo):
dolog('mount_tgtsys %s' % repr(tgtsys_devinfo))
global dev_tgt # the target system devices.
logger.d('######### Mount target system (please check the umount point) #############')
dev_tgt = MiDevice_TgtSys(tgtsys_devinfo)
if not dev_tgt.mount_tgt_device(): #### NOTE: carefully handle this device's mount.
msg = _('Mount target system devices Failed, install operate can not continue!!!')
logger.e(msg)
dev_tgt = None
return msg
return 0
def disk_new_fresh(mia, operid, devpath, dltype):
logger.d('disk_new_fresh %s %s' % (devpath, dltype))
#dltype = parted.disk_type_get(dltype)
dltype = parted.diskType[dltype]
if dltype and CF.S.all_harddisks.has_key(devpath):
dev = CF.S.all_harddisks[devpath][0]
#CF.S.all_harddisks[devpath] = (dev, dev.disk_new_fresh(dltype), 'y')
CF.S.all_harddisks[devpath] = (dev,
parted.freshDisk(device=dev,
ty=dltype), 'y')
return 0
def reload_partition_table(mia, operid, devpath):
logger.d('reload_partition_table %s' % devpath)
if CF.S.all_harddisks.has_key(devpath):
dev = CF.S.all_harddisks[devpath][0]
try:
CF.S.all_harddisks[devpath] = (dev, parted.Disk(dev), None)
except _ped.DiskLabelException:
dltype = parted.diskType['msdos']
CF.S.all_harddisks[devpath] = (dev,
parted.freshDisk(device=dev,
ty=dltype), 'y')
return 0
def commit_devpath(mia, operid, devpath):
logger.d('commit_devpath %s' % devpath)
mia.set_step(operid, 0, -1)
if CF.S.all_harddisks.has_key(devpath):
disk = CF.S.all_harddisks[devpath][1]
if disk:
try:
disk.commit()
CF.S.all_harddisks[devpath] = (CF.S.all_harddisks[devpath][0], disk, None)
#except parted.error, errmsg:
except parted.DiskException as errmsg:
return str(errmsg)
return 0
def umount_tgt_device(self):
self.mounted_devs.reverse()
for dev in self.mounted_devs:
if type(dev) is MiDevice:
if not dev.do_umount():
logger.w('Umount device %s Failed, but we continue')
else:
umount_dev(dev)
res = run_bash('mount')
logger.d(''''UMount target system partition finished, check the mount output please:)
%s
%s
''' % ('\n'.join(res['out']), '\n'.join(res['err'])))
def delete_partition(mia, operid, devpath, part_start):
logger.d('delete_partition %s' % str((devpath, part_start)))
if CF.S.all_harddisks.has_key(devpath):
disk = CF.S.all_harddisks[devpath][1]
if disk:
part = disk.getFirstPartition()
while part:
if part.geometry.start == part_start:
disk.removePartition(part)
break
part = part.nextPartition()
CF.S.all_harddisks[devpath] = (CF.S.all_harddisks[devpath][0], disk, 'y')
return get_all_partitions(mia, operid, devpath)
def _dispatch(self, method, params):
global server_quit
if method == 'quit':
mia.put_operation('quit')
server_quit = 1
return 0
elif method == 'get_results':
result_list = mia.get_result()
return result_list
elif method == 'probe_step':
return mia.probe_step()
if handlers_short.has_key(method):
if CF.D.EXPERT_MODE:
logger.d('Run short.%s() with %s,\n' % (method, params))
result = handlers_short[method](*params)
if CF.D.EXPERT_MODE:
logger.d(' which returns %r\n' % (result, ))
return result
else: # This is a long operation.
# Return the operation identifier to the caller.
if CF.D.EXPERT_MODE:
logger.d('Put long.%s() with %s' % (method, params))
t = xmlrpclib.dumps(params,
methodname=method,
allow_none=1)
#log_long.debug('%s' % t)
id = mia.put_operation(t)
if CF.D.EXPERT_MODE:
logger.d(', and get id %d.\n' % (id))
return id
def delete_partition(mia, operid, devpath, part_start):
logger.d('delete_partition %s' % str((devpath, part_start)))
if CF.S.all_harddisks.has_key(devpath):
disk = CF.S.all_harddisks[devpath][1]
if disk:
part = disk.getFirstPartition()
while part:
if part.geometry.start == part_start:
disk.removePartition(part)
break
part = part.nextPartition()
CF.S.all_harddisks[devpath] = (CF.S.all_harddisks[devpath][0],
disk, 'y')
return get_all_partitions(mia, operid, devpath)
def _dispatch(self, method, params):
global server_quit
if method == 'quit':
mia.put_operation('quit')
server_quit = 1
return 0
elif method == 'get_results':
result_list = mia.get_result()
return result_list
elif method == 'probe_step':
return mia.probe_step()
if handlers_short.has_key(method):
if CF.D.EXPERT_MODE:
logger.d('Run short.%s() with %s,\n' % (method, params))
result = handlers_short[method](*params)
if CF.D.EXPERT_MODE:
logger.d(' which returns %r\n' % (result,))
return result
else: # This is a long operation.
# Return the operation identifier to the caller.
if CF.D.EXPERT_MODE:
logger.d('Put long.%s() with %s' % (method, params))
t = xmlrpclib.dumps(params, methodname=method, allow_none = 1)
#log_long.debug('%s' % t)
id = mia.put_operation(t)
if CF.D.EXPERT_MODE:
logger.d(', and get id %d.\n' % (id))
return id
def commit_devpath(mia, operid, devpath):
logger.d('commit_devpath %s' % devpath)
mia.set_step(operid, 0, -1)
if CF.S.all_harddisks.has_key(devpath):
disk = CF.S.all_harddisks[devpath][1]
if disk:
try:
disk.commit()
CF.S.all_harddisks[devpath] = (CF.S.all_harddisks[devpath][0],
disk, None)
#except parted.error, errmsg:
except parted.DiskException as errmsg:
return str(errmsg)
return 0
def set_flags_and_label(mia, operid, devpath, part_start,
true_flags, false_flags, set_label, label):
logger.d('set_flags_and_label %s', str((devpath, part_start,
true_flags, false_flags, set_label, label)))
if CF.S.all_harddisks.has_key(devpath):
disk = CF.S.all_harddisks[devpath][1]
if disk:
part = disk.getFirstPartition()
while part:
if part.geometry.start == part_start:
for tf in true_flags:
part.setFlag(tf)
for ff in false_flags:
part.unsetFlag(ff)
if set_label == 'true':
part.getPedPartition().set_name(label)
break
part = part.nextPartition()
CF.S.all_harddisks[devpath] = (CF.S.all_harddisks[devpath][0], disk, 'y')
return 0
def format_partition(mia, operid, devpath, part_start, fstype):
logger.d('format_partition device: %s partition start: %s fstype: %s' % (devpath, part_start, fstype))
mia.set_step(operid, 0, -1)
if not CF.D.FSTYPE_MAP.has_key(fstype):
errmsg = _('Unrecoginzed filesystem %s.')
return errmsg % fstype
if CF.D.FSTYPE_MAP[fstype][1] == '':
errmsg = _('Format %s is not supported.')
return errmsg % fstype
if not CF.S.all_harddisks.has_key(devpath):
return _('No such device: ') + devpath
disk = CF.S.all_harddisks[devpath][1]
if not disk:
return _('Not any partition table found on: ') + devpath
part = disk.getFirstPartition()
while part:
if part.geometry.start != part_start:
part = part.nextPartition()
continue
if CF.D.FSTYPE_MAP[fstype][1] == 'internal':
parted_fstype = parted.fileSystemType[revision_fstype(fstype)]
try:
part.getPedPartition().set_system(parted_fstype)
logger.d('Create internal fstype %s on device %s partition start %s' % (fstype, devpath, part_start))
part.fileSystem.create()
disk.commit()
logger.d('Create internal partition complete!')
except NotImplementedError, errmsg:
return str(errmsg)
except parted.DiskException as errmsg:
return str(errmsg)
return 0
def try_format(devn, id_):
# Wait for device block appear.
fblk = False
time.sleep(1)
# We attemp to detect device file whether exists
for trycnt in range(10):
# os.path.exists cannot detect file exists real time
#if os.path.exists(devn):
if os.system('ls %s' % devn) == 0:
fblk = True
break
else:
time.sleep(1)
if not fblk:
msg = _('Not exists device block on %s: \ntry time: %d\n') % (devpath, trycnt)
logger.w(msg)
return msg
else:
logger.d('try_format %s ls device %s time' % (id_, trycnt))
# Run command to format partition
cmd_format = CF.D.FSTYPE_MAP[fstype][1]
cmd_f_list = cmd_format.split()
cmd = cmd_f_list[0]
argv = cmd_f_list[1:]
argv.append(devn)
cmdres = run_bash(cmd, argv)
logger.d('%s %s' % (cmd, ' '.join(argv)))
logger.d(' '.join(cmdres['out']))
if cmdres['ret'] != 0:
errmsg = _('Run "%s %s" failed: %s\ntry time: %d\n')
return errmsg % ( cmd, ' '.join(argv), str(cmdres['err']), trycnt )
else:
return 0
def run_post_script(script_rel, _argv=[], f_chroot=True):
logger.i('Run post_script %s %s' % (script_rel, str(_argv)))
post_scripts_dir = CF.D.POST_SCRIPTS_DIR
script = os.path.join(post_scripts_dir, script_rel)
if not os.path.exists(script):
msg = _('Can not find the script %s' % script)
logger.e(msg)
return -1, msg
root = CF.D.TGTSYS_ROOT
if f_chroot:
if not os.path.exists('%s/tmp' % root):
os.makedirs('%s/tmp' % root)
cmd0 = 'cp -pr %s %s/tmp/' % (post_scripts_dir, root)
logger.d(cmd0)
os.system(cmd0)
cmd = '/tmp/%s/%s' % (os.path.basename(post_scripts_dir), script_rel)
cmd0 = 'chmod 777 %s%s' % (root, cmd)
logger.d(cmd0)
os.system(cmd0)
argv = _argv
_environ = dict(os.environ)
_environ['LANG'] = 'en_US.UTF-8'
try:
res = run_bash(cmd, argv, root, env=_environ, cwd='/tmp/%s' % os.path.basename(post_scripts_dir))
except OSError, e:
res = {}
res['ret'] = -1
res['err'] = ['Can not run %s, can not chroot to target system or can not run this script.' % script_rel]
res['out'] = ['']
logger.e(res['err'], exc_info = sys.exc_info())
cmd0 = 'rm -rf %s/tmp/%s' % (root, os.path.basename(post_scripts_dir))
logger.d(cmd0)
os.system(cmd0)
def add_partition(mia, operid, devpath, parttype, fstype, start, end):
logger.d('add_partition %s' % str((devpath, parttype, fstype, start, end)))
fstype = revision_fstype(fstype)
if CF.S.all_harddisks.has_key(devpath):
(dev, disk, dirty_or_not) = CF.S.all_harddisks[devpath]
if disk:
constraint = parted.Constraint(device=dev) #exactGeom=newgeom)
if parttype == 'primary':
parttype = 0
elif parttype == 'extended':
parttype = parted.PARTITION_EXTENDED
elif parttype == 'logical':
parttype = parted.PARTITION_LOGICAL
if fstype != 'N/A':
fstype = parted.fileSystemType[fstype]
else:
fstype = None
try:
newgeom_bound = _grow_over_small_freespace(start, end, disk)
if not newgeom_bound:
return (
-1,
"Can't get the geometry of new partition (start=%s end=%s)."
% (start, end))
newgeom = parted.Geometry(device=dev,
start=newgeom_bound[0],
end=newgeom_bound[1])
# We can use _ped's geometry to build parted's Geometry
if newgeom:
newpart = parted.Partition(disk=disk,
type=parttype,
geometry=newgeom)
disk.addPartition(partition=newpart, constraint=constraint)
if fstype:
newpart.getPedPartition().set_system(fstype)
except _ped.PartitionException, errmsg:
return (-1, str(errmsg))
CF.S.all_harddisks[devpath] = (dev, disk, 'y')
return (newpart.geometry.start, '')
def set_flags_and_label(mia, operid, devpath, part_start, true_flags,
false_flags, set_label, label):
logger.d(
'set_flags_and_label %s',
str((devpath, part_start, true_flags, false_flags, set_label, label)))
if CF.S.all_harddisks.has_key(devpath):
disk = CF.S.all_harddisks[devpath][1]
if disk:
part = disk.getFirstPartition()
while part:
if part.geometry.start == part_start:
for tf in true_flags:
part.setFlag(tf)
for ff in false_flags:
part.unsetFlag(ff)
if set_label == 'true':
part.getPedPartition().set_name(label)
break
part = part.nextPartition()
CF.S.all_harddisks[devpath] = (CF.S.all_harddisks[devpath][0],
disk, 'y')
return 0
def format_partition(mia, operid, devpath, part_start, fstype):
logger.d('format_partition device: %s partition start: %s fstype: %s' %
(devpath, part_start, fstype))
mia.set_step(operid, 0, -1)
if not CF.D.FSTYPE_MAP.has_key(fstype):
errmsg = _('Unrecoginzed filesystem %s.')
return errmsg % fstype
if CF.D.FSTYPE_MAP[fstype][1] == '':
errmsg = _('Format %s is not supported.')
return errmsg % fstype
if not CF.S.all_harddisks.has_key(devpath):
return _('No such device: ') + devpath
disk = CF.S.all_harddisks[devpath][1]
if not disk:
return _('Not any partition table found on: ') + devpath
part = disk.getFirstPartition()
while part:
if part.geometry.start != part_start:
part = part.nextPartition()
continue
if CF.D.FSTYPE_MAP[fstype][1] == 'internal':
parted_fstype = parted.fileSystemType[revision_fstype(fstype)]
try:
part.getPedPartition().set_system(parted_fstype)
logger.d(
'Create internal fstype %s on device %s partition start %s'
% (fstype, devpath, part_start))
part.fileSystem.create()
disk.commit()
logger.d('Create internal partition complete!')
except NotImplementedError, errmsg:
return str(errmsg)
except parted.DiskException as errmsg:
return str(errmsg)
return 0
def try_format(devn, id_):
# Wait for device block appear.
fblk = False
time.sleep(1)
# We attemp to detect device file whether exists
for trycnt in range(10):
# os.path.exists cannot detect file exists real time
#if os.path.exists(devn):
if os.system('ls %s' % devn) == 0:
fblk = True
break
else:
time.sleep(1)
if not fblk:
msg = _('Not exists device block on %s: \ntry time: %d\n'
) % (devpath, trycnt)
logger.w(msg)
return msg
else:
logger.d('try_format %s ls device %s time' % (id_, trycnt))
# Run command to format partition
cmd_format = CF.D.FSTYPE_MAP[fstype][1]
cmd_f_list = cmd_format.split()
cmd = cmd_f_list[0]
argv = cmd_f_list[1:]
argv.append(devn)
cmdres = run_bash(cmd, argv)
logger.d('%s %s' % (cmd, ' '.join(argv)))
logger.d(' '.join(cmdres['out']))
if cmdres['ret'] != 0:
errmsg = _('Run "%s %s" failed: %s\ntry time: %d\n')
return errmsg % (cmd, ' '.join(argv), str(
cmdres['err']), trycnt)
else:
return 0
else:
logger.d('try_format %s ls device %s time' % (id_, trycnt))
# Run command to format partition
cmd_format = CF.D.FSTYPE_MAP[fstype][1]
cmd_f_list = cmd_format.split()
cmd = cmd_f_list[0]
argv = cmd_f_list[1:]
argv.append(devn)
cmdres = run_bash(cmd, argv)
logger.d('%s %s' % (cmd, ' '.join(argv)))
logger.d(' '.join(cmdres['out']))
if cmdres['ret'] != 0:
errmsg = _('Run "%s %s" failed: %s\ntry time: %d\n')
return errmsg % (cmd, ' '.join(argv), str(
cmdres['err']), trycnt)
else:
return 0
ret = 'None'
for t in range(5):
ret = try_format('%s%d' % (devpath, part.number), t)
if ret == 0:
break
else:
logger.d(
'try format time %s time, but can not format at last!' % t)
return ret
return _('Not any partition found on position: ') + str(part_start)
v['fstype'] = 'iso9660' # fill cdrom file type, because it is None for default.
all_drives.update(all_parts)
all_drives.update(cdrom_dev)
logger.i('all_drives: %s' % all_drives)
pos_id = -1
for k, value in all_drives.items():
devpath = value['devpath']
fstype = value['fstype']
if not CF.D.FSTYPE_MAP.has_key(fstype):
continue
if CF.D.FSTYPE_MAP[fstype][0] == '':
continue
midev = MiDevice(devpath, CF.D.FSTYPE_MAP[fstype][0])
logger.d('Search %s pkgarr(%s) in dirs %s' %
(CF.D.BOOTCDFN, CF.D.PKGARR_FILE,
repr(CF.D.PKGARR_SER_HDPATH + CF.D.PKGARR_SER_CDPATH)))
for f, reldir in midev.iter_searchfiles(
[CF.D.PKGARR_FILE, CF.D.BOOTCDFN],
CF.D.PKGARR_SER_HDPATH + CF.D.PKGARR_SER_CDPATH):
if f.endswith('.iso'):
midev_iso = MiDevice(f, 'iso9660')
for pkgarr, relative_dir in midev_iso.iter_searchfiles(
[CF.D.PKGARR_FILE], CF.D.PKGARR_SER_CDPATH):
pos_id += 1
r = probe_position(pkgarr, 100 + pos_id, devpath,
CF.D.FSTYPE_MAP[fstype][0],
relative_dir, CF.D.BOOTCDFN)
if r:
r[-1] = os.path.join(
reldir, r[-1]) #### revise iso relative path
for k, v in cdrom_dev.items():
v['fstype'] = 'iso9660' # fill cdrom file type, because it is None for default.
all_drives.update(all_parts)
all_drives.update(cdrom_dev)
logger.i('all_drives: %s' % all_drives)
pos_id = -1
for k, value in all_drives.items():
devpath = value['devpath']
fstype = value['fstype']
if not CF.D.FSTYPE_MAP.has_key(fstype):
continue
if CF.D.FSTYPE_MAP[fstype][0] == '':
continue
midev = MiDevice(devpath, CF.D.FSTYPE_MAP[fstype][0])
logger.d('Search %s pkgarr(%s) in dirs %s' % (CF.D.BOOTCDFN, CF.D.PKGARR_FILE, repr(CF.D.PKGARR_SER_HDPATH+CF.D.PKGARR_SER_CDPATH)))
for f, reldir in midev.iter_searchfiles([CF.D.PKGARR_FILE, CF.D.BOOTCDFN], CF.D.PKGARR_SER_HDPATH+CF.D.PKGARR_SER_CDPATH):
if f.endswith('.iso'):
midev_iso = MiDevice(f, 'iso9660')
for pkgarr, relative_dir in midev_iso.iter_searchfiles([CF.D.PKGARR_FILE], CF.D.PKGARR_SER_CDPATH):
pos_id += 1
r = probe_position(pkgarr, 100 + pos_id,
devpath, CF.D.FSTYPE_MAP[fstype][0], relative_dir, CF.D.BOOTCDFN)
if r:
r[-1] = os.path.join(reldir, r[-1]) #### revise iso relative path
result.append(r)
else:
pos_id += 1
r = probe_position(f, pos_id,
devpath, fstype, reldir, '')
if r: result.append(r)
try:
miinitrd_pos
except:
# Failed: Load the default values.
miinitrd_pos = None
mia = miactions.MIActions(128, 128 * 1024, 128 * 1024)
if mia.pid > 0:
server_quit = 0
# Control process.
# Run short operation and transfer long operation to action process.
#from mi.utils.milogger import ServerLogger_Short, ServerLogger_Long
from mi.server.utils import logger
from mi.server import handlers_short
logger.d('test short logger')
class MIAction:
def _dispatch(self, method, params):
global server_quit
if method == 'quit':
mia.put_operation('quit')
server_quit = 1
return 0
elif method == 'get_results':
result_list = mia.get_result()
return result_list
elif method == 'probe_step':
return mia.probe_step()
if handlers_short.has_key(method):
if CF.D.EXPERT_MODE:
try:
miinitrd_pos
except:
# Failed: Load the default values.
miinitrd_pos = None
mia = miactions.MIActions(128, 128*1024, 128*1024)
if mia.pid > 0:
server_quit = 0
# Control process.
# Run short operation and transfer long operation to action process.
#from mi.utils.milogger import ServerLogger_Short, ServerLogger_Long
from mi.server.utils import logger
from mi.server import handlers_short
logger.d('test short logger')
class MIAction:
def _dispatch(self, method, params):
global server_quit
if method == 'quit':
mia.put_operation('quit')
server_quit = 1
return 0
elif method == 'get_results':
result_list = mia.get_result()
return result_list
elif method == 'probe_step':
return mia.probe_step()
if handlers_short.has_key(method):
if CF.D.EXPERT_MODE:
def mount_tgt_device(self):
tgt_root_dev, tgt_root_type = self.get_devinfo_by_mpoint('/')
tgt_swap_dev, tgt_swap_type = self.get_devinfo_by_mpoint('USE')
if tgt_swap_dev and os.path.exists(tgt_swap_dev):
os.system('swapon %s' % tgt_swap_dev)
#### mount root device
mnt_point = CF.D.TGTSYS_ROOT
dev_tgt_root = MiDevice(tgt_root_dev, tgt_root_type, mnt_point)
if not dev_tgt_root.do_mount(): #### NOTE: carefully handle this device's mount.
logger.e('Mount device %s Failed, install operate can not continue' % dev_tgt_root.get_dev())
return False
else:
self.mounted_devs.append(dev_tgt_root)
def mount_each(tgt_root_dev, tgt_other_dev, tgt_other_type, tgt_other_mpoint):
if tgt_other_dev and tgt_root_dev != tgt_other_dev:
mnt_point = os.path.join(CF.D.TGTSYS_ROOT, tgt_other_mpoint.lstrip('/'))
dev_tgt_other = MiDevice(tgt_other_dev, tgt_other_type, mnt_point)
if not dev_tgt_other.do_mount(): #### NOTE: carefully handle this device's mount.
logger.e('Mount device %s Failed, install operate can not continue' % dev_tgt_other.get_dev())
self.umount_tgt_device()
return False
else:
self.mounted_devs.append(dev_tgt_other)
return True
else:
logger.e('Can not run to here!! The root file system had been mounted before!!')
return False
for mpoint, dev_, type_ in self.tgtsys_devinfo:
if mpoint not in ('/', 'USE'):
if not mount_each(tgt_root_dev, dev_, type_, mpoint):
return False
# mount -t proc proc myroot/proc/
mnt_point = os.path.join(CF.D.TGTSYS_ROOT, 'proc')
ret, msg = mount_dev('proc', 'proc', mntdir=mnt_point,flags=None)
if not ret:
logger.e("Error: mount proc on target failed '%s'" % msg)
return False
self.mounted_devs.append(mnt_point)
# mount -t sysfs sys myroot/sys/
mnt_point = os.path.join(CF.D.TGTSYS_ROOT, 'sys')
ret, msg = mount_dev('sysfs', 'sys', mntdir=mnt_point,flags=None)
if not ret:
logger.e("Error: mount sys on target failed '%s'" % msg)
return False
self.mounted_devs.append(mnt_point)
# mount -o bind /dev myroot/dev/
mnt_point = os.path.join(CF.D.TGTSYS_ROOT, 'dev')
ret, msg = mount_dev(None, '/dev', mntdir=mnt_point,flags='bind')
if not ret:
logger.e("Error: mount /dev on target failed '%s'" % msg)
return False
self.mounted_devs.append(mnt_point)
res = run_bash('mount')
logger.d(''''Mount target system partition finished, check the mount output please:)
%s
%s
''' % ('\n'.join(res['out']), '\n'.join(res['err'])))
return True
logger.w(msg)
return msg
else:
logger.d('try_format %s ls device %s time' % (id_, trycnt))
# Run command to format partition
cmd_format = CF.D.FSTYPE_MAP[fstype][1]
cmd_f_list = cmd_format.split()
cmd = cmd_f_list[0]
argv = cmd_f_list[1:]
argv.append(devn)
cmdres = run_bash(cmd, argv)
logger.d('%s %s' % (cmd, ' '.join(argv)))
logger.d(' '.join(cmdres['out']))
if cmdres['ret'] != 0:
errmsg = _('Run "%s %s" failed: %s\ntry time: %d\n')
return errmsg % ( cmd, ' '.join(argv), str(cmdres['err']), trycnt )
else:
return 0
ret = 'None'
for t in range(5):
ret = try_format('%s%d' % (devpath, part.number), t)
if ret == 0:
break
else:
logger.d('try format time %s time, but can not format at last!' % t)
return ret
return _('Not any partition found on position: ') + str(part_start)
