def pkgarr_probe(mia, operid):
logger.i("pkgarr_probe starting...")
def probe_position(localfn, pos_id, new_device, fstype, reldir, isofn):
logger.i('probe_position: %s, %s, %s, %s, %s, %s' %
(localfn, pos_id, new_device, fstype, reldir, isofn))
if not os.path.exists(localfn):
return None
try:
execfile(localfn)
except Exception, errmsg:
logger.e("Load %s failed(%s)." % (localfn, str(errmsg)))
return None
remotefn = 'allpa/%s.%d.%s' % (os.path.basename(new_device), pos_id,
os.path.basename(localfn))
logger.i('ftp upload %s to remote %s...' % (localfn, remotefn))
try:
ftp = ftplib.FTP("127.0.0.1")
ftp.login("root", "magic")
ftp.storbinary("STOR %s" % remotefn, open(localfn, "rb"), 1024)
ftp.close()
except:
logger.e('Upload failed')
return None
logger.i('Upload success')
return [remotefn, new_device, fstype, reldir, isofn]
def instpkg_disc_prep(mia, operid, dev, reldir, fstype, bootiso_relpath):
"""
Install each disc prepare work.
We should mount each iso to prepare packages source(for disc).
"""
global dev_hd # the harddisk device where save packages.
global dev_iso # the iso where save pkgs.
dolog("instpkg_disc_prep(%s, %s, %s, %s)\n" % (dev, reldir, fstype, bootiso_relpath))
############################## Mount Start #####################################
dev_hd = MiDevice(dev, fstype)
if not dev_hd.do_mount(): #### NOTE: carefully handle this device's mount.
msg = "Mount device %s Failed, install operate can not continue" % dev_hd.get_dev()
logger.e(msg)
return msg
if bootiso_relpath:
# an iso file on harddisk
dev_iso = MiDevice(dev_hd.get_file_path(bootiso_relpath), "iso9660")
if not dev_iso.do_mount(): #### NOTE: carefully handle this device's mount.
dev_hd.do_umount()
dev_hd = None
msg = "Mount device %s Failed, install operate can not continue!!!" % dev_iso.get_dev()
logger.e(msg)
dev_iso = None
return msg
############################## Mount Finished #####################################
return 0
def install_disc_prep(mia, operid, dev, fstype, bootiso_relpath, reldir):
'''
Install each disc prepare work.
We should mount each iso to prepare packages source(for disc).
'''
global dev_hd # the harddisk device where save packages.
global dev_iso # the iso where save pkgs.
global dev_mnt_dir # the current hd or iso mount dir
dolog('instpkg_disc_prep(%s, %s, %s, %s)\n' % \
(dev, fstype, bootiso_relpath, reldir))
############################## Mount Start #####################################
dev_hd = MiDevice(dev, fstype)
if not dev_hd.do_mount(): #### NOTE: carefully handle this device's mount.
msg = 'Mount device %s Failed, install operate can not continue' % dev_hd.get_dev()
logger.e(msg)
return msg
dev_mnt_dir = dev_hd.get_mountdir()
if bootiso_relpath:
# an iso file on harddisk
dev_iso = MiDevice(dev_hd.get_file_path(bootiso_relpath), 'iso9660')
if not dev_iso.do_mount(): #### NOTE: carefully handle this device's mount.
dev_hd.do_umount(); dev_hd = None
msg = 'Mount device %s Failed, install operate can not continue!!!' % dev_iso.get_dev()
logger.e(msg)
dev_iso = None
return msg
dev_mnt_dir = dev_iso.get_mountdir()
############################## Mount Finished #####################################
return 0
def mount_tgt_device(self):
tgt_root_dev, tgt_root_type = self.tgtsys_devinfo["/"]
tgt_boot_dev, tgt_boot_type = self.tgtsys_devinfo["/boot"]
tgt_swap_dev = self.tgtsys_devinfo["swap"][0]
if tgt_swap_dev:
#### swap on or not
pass
#### 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)
if tgt_boot_dev and (tgt_boot_dev != tgt_root_dev):
#### mount boot device
mnt_point = os.path.join(CF.D.TGTSYS_ROOT, "boot")
dev_tgt_boot = MiDevice(tgt_boot_dev, tgt_boot_type, mnt_point)
if not dev_tgt_boot.do_mount(): #### NOTE: carefully handle this device's mount.
logger.e("Mount device %s Failed, install operate can not continue" % dev_tgt_boot.get_dev())
self.umount_tgt_device()
return False
else:
self.mounted_devs.append(dev_tgt_boot)
return True
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 resp_pkgarr_probe(tdata, data):
logger.i('resp_pkgarr_probe result %s' % tdata)
if not check_data(tdata):
msg = _('Can not get packages info (pkgarr_probe)')+'''RESULT TYPE %s VALUE: %s''' % (type(tdata), tdata)
logger.e(msg)
self.sself.warn_dialog(msg)
CF.G.pkgarr_probe_result = tdata
CF.G.pkgarr_probe_status = STAT.OP_STATUS_DONE
def probe_position(localfn, pos_id, new_device, fstype, reldir, isofn):
logger.i('probe_position: %s, %s, %s, %s, %s, %s' % (localfn, pos_id, new_device, fstype, reldir, isofn))
if not os.path.exists(localfn):
return None
try:
execfile(localfn)
except Exception, errmsg:
logger.e("Load %s failed(%s)." % (localfn, str(errmsg)))
return None
def probe_position(localfn, pos_id, new_device, fstype, reldir, isofn):
logger.i('probe_position: %s, %s, %s, %s, %s, %s' %
(localfn, pos_id, new_device, fstype, reldir, isofn))
if not os.path.exists(localfn):
return None
try:
execfile(localfn)
except Exception, errmsg:
logger.e("Load %s failed(%s)." % (localfn, str(errmsg)))
return None
def resp_pkgarr_probe(tdata, data):
logger.i('resp_pkgarr_probe result %s' % tdata)
if not check_data(tdata):
msg = _('Can not get packages info (pkgarr_probe)'
) + '''RESULT TYPE %s VALUE: %s''' % (type(tdata),
tdata)
logger.e(msg)
self.sself.warn_dialog(msg)
CF.G.pkgarr_probe_result = tdata
CF.G.pkgarr_probe_status = STAT.OP_STATUS_DONE
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 do_umount(self):
if not self.has_mounted:
return True
ret, errmsg = umount_dev(self.mntdir)
if not ret:
logger.e("MiDevice.do_umount UMount(%s) failed: %s" % (self.mntdir, str(errmsg)))
return False
else:
self.has_mounted = False
if not self.mntdir_fixed:
self.mntdir = ""
return True
def do_umount(self):
if not self.has_mounted: return True
for t in range(3): # try 3 time, because some udisk program will hold on disk, when disk mount. umount action can not so quickly.
ret, errmsg = umount_dev(self.mntdir)
if ret:
break
else:
time.sleep(1)
if not ret:
logger.e("MiDevice.do_umount UMount(%s) failed: %s" % (self.mntdir, str(errmsg))); return False
else:
self.has_mounted = False
if not self.mntdir_fixed: self.mntdir = ''
return True
def install_disc_post(mia, operid, dev, fstype, bootiso_relpath, reldir):
global dev_hd # the harddisk device where save packages.
global dev_iso # the iso where save pkgs.
dolog('instpkg_disc_post(%s, %s, %s, %s)\n' % \
(dev, fstype, reldir, bootiso_relpath))
################################ Umount Start #####################################
if dev != dev_hd.get_dev():
msg = 'Error: previous use device %s, this time umount device %s, both should be equal, the install operate can not continue!!!' % (dev_hd.get_dev(), dev)
logger.e(msg)
return msg
if dev_iso:
if not dev_iso.do_umount():
msg = 'Umount previous iso %s Failed, install operate can not continue!!!' % dev_iso.get_dev()
logger.e(msg)
return msg
dev_iso = None
if dev_hd:
if not dev_hd.do_umount():
msg = 'Umount previous iso %s Failed, install operate can not continue!!!' % dev_hd.get_dev()
logger.e(msg)
return msg
if dev_hd.get_fstype() == 'iso9660':
# Eject the cdrom after used.
try:
cdfd = os.open(dev, os.O_RDONLY | os.O_NONBLOCK)
isys.ejectcdrom(cdfd) # TODO: ejectcdrom use other method
os.close(cdfd)
except Exception, errmsg:
logger.e('Eject(%s) failed: %s' % \
(dev, str(errmsg)))
return str(errmsg)
dev_hd = None
def instpkg_disc_post(mia, operid, dev, fstype, reldir, bootiso_relpath, first_pkg):
global dev_hd # the harddisk device where save packages.
global dev_iso # the iso where save pkgs.
if installmode == "copyinstallmode":
# determine the rpmdb.tar.bz2 and etc.tar.bz2. If exist copy it to tmp_config_dir in target system.
rpmpkgdir = os.path.dirname(first_pkg)
rpmdb_abs = os.path.join(rpmpkgdir, rpmdb)
etctar_abs = os.path.join(rpmpkgdir, etctar)
tgt_tmp_config_dir = os.path.join(CF.D.TGTSYS_ROOT, tmp_config_dir)
if not os.path.exists(tgt_tmp_config_dir):
os.makedirs(tgt_tmp_config_dir)
if os.path.exists(rpmdb_abs):
ret = os.system("cp %s %s" % (rpmdb_abs, os.path.join(tgt_tmp_config_dir, rpmdb)))
if ret != 0:
dolog("copy %s to target system failed.\n" % rpmdb)
else:
dolog("copy %s to target system successfully.\n" % rpmdb)
if os.path.exists(etctar_abs):
ret = os.system("cp %s %s" % (etctar_abs, os.path.join(tgt_tmp_config_dir, etctar)))
if ret != 0:
dolog("copy %s to target system failed.\n" % rpmdb)
else:
dolog("copy %s to target system successfully.\n" % rpmdb)
dolog("instpkg_disc_post(%s, %s, %s, %s, %s)\n" % (dev, fstype, reldir, bootiso_relpath, first_pkg))
# We don't know which package start the minilogd but it
# will lock the disk, so it must be killed.
if os.system("/usr/bin/killall minilogd") == 0:
time.sleep(2)
################################ Umount Start #####################################
if dev != dev_hd.get_dev():
msg = (
"Error: previous use device %s, this time umount device %s, both should be equal, the install operate can not continue!!!"
% (dev_hd.get_dev(), dev)
)
logger.e(msg)
return msg
if dev_iso:
if not dev_iso.do_umount():
msg = "Umount previous iso %s Failed, install operate can not continue!!!" % dev_iso.get_dev()
logger.e(msg)
return msg
dev_iso = None
if dev_hd:
if not dev_hd.do_umount():
msg = "Umount previous iso %s Failed, install operate can not continue!!!" % dev_hd.get_dev()
logger.e(msg)
return msg
if dev_hd.get_fstype() == "iso9660":
# Eject the cdrom after used.
try:
cdfd = os.open(dev, os.O_RDONLY | os.O_NONBLOCK)
isys.ejectcdrom(cdfd) # TODO: ejectcdrom use other method
os.close(cdfd)
except Exception, errmsg:
logger.e("Eject(%s) failed: %s" % (dev, str(errmsg)))
return str(errmsg)
dev_hd = None
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
def probe_all_disc(mia, operid, device, devfstype, bootiso_relpath, pkgarr_reldir, disc_first_pkgs):
"""
probe the package from all disk
bootiso_relpath is the first iso path relative path of device /
pkgarr_reldir is the relative directory path of pkgarr.py of device / OR iso dir /
"""
dolog("probe_all_disc(%s, %s, %s, %s, %s)\n" % (device, devfstype, bootiso_relpath, pkgarr_reldir, disc_first_pkgs))
midev = MiDevice(device, devfstype)
bootiso_fn = CF.D.ISOFN_FMT % (CF.D.DISTNAME, CF.D.DISTVER, 1)
# If probe in iso ,but bootiso_fn is not match error occur
if bootiso_relpath and not os.path.basename(bootiso_relpath) == bootiso_fn:
logger.e(
"probe_all_disc iso format is wrong: bootiso_relpath: %s bootiso_fn: %s", (bootiso_relpath, bootiso_relpath)
)
return None
probe_ret = None
result = []
for disc_no in range(len(disc_first_pkgs)):
pkg_probe_path = ["../packages", "packages", "../packages-%d" % (disc_no + 1), "packages-%d" % (disc_no + 1)]
if bootiso_relpath:
# deal with iso case
iso_fn = CF.D.ISOFN_FMT % (CF.D.DISTNAME, CF.D.DISTVER, disc_no + 1)
iso_relpath = os.path.join(os.path.dirname(bootiso_relpath), iso_fn)
pkgarr_reldirs = [os.path.join(pkgarr_reldir, p) for p in pkg_probe_path]
for f, reldir in midev.iter_searchfiles([iso_relpath], [""]): # from disk
midev_iso = MiDevice(f, "iso9660")
for pkgpath, relative_dir in midev_iso.iter_searchfiles(
[disc_first_pkgs[disc_no]], pkgarr_reldirs
): # from iso
probe_ret = (
os.path.join(os.path.dirname(bootiso_relpath), iso_fn),
os.path.normpath(os.path.join(relative_dir, os.path.basename(pkgpath))),
)
else:
# deal with harddisk case
pkgs = [os.path.join(p, disc_first_pkgs[disc_no]) for p in pkg_probe_path]
for f, reldir in midev.iter_searchfiles(pkgs, [pkgarr_reldir]):
probe_ret = ("", os.path.join(reldir, os.path.basename(f)))
if probe_ret:
result.append(probe_ret)
dolog("probe_all_disc return result is : %s\n" % str(result))
return result
def probe_all_disc(mia, operid, device, devfstype, bootiso_relpath, pkgarr_reldir, disc_first_pkgs):
'''
probe the package from all disk
bootiso_relpath is the first iso path relative path of device /
pkgarr_reldir is the relative directory path of pkgarr.py of device / OR iso dir /
'''
logger.i('probe_all_disc(%s, %s, %s, %s, %s)\n' % \
(device, devfstype, bootiso_relpath, pkgarr_reldir, disc_first_pkgs))
midev = MiDevice(device, devfstype)
bootiso_fn = CF.D.ISOFN_FMT % (CF.D.DISTNAME, CF.D.DISTVER, 1)
# If probe in iso ,but bootiso_fn is not match error occur
if bootiso_relpath and not os.path.basename(bootiso_relpath) == bootiso_fn:
logger.e('probe_all_disc iso format is wrong: bootiso_relpath: %s bootiso_fn: %s' % (bootiso_relpath, bootiso_fn))
return None
probe_ret = None
result = []
for disc_no in range(len(disc_first_pkgs)):
pkg_probe_path = [ '../packages',
'packages',
'../packages-%d' % (disc_no + 1),
'packages-%d' % (disc_no + 1)]
if bootiso_relpath:
# deal with iso case
iso_fn = CF.D.ISOFN_FMT % (CF.D.DISTNAME, CF.D.DISTVER, disc_no + 1)
iso_relpath = os.path.join(os.path.dirname(bootiso_relpath), iso_fn)
pkgarr_reldirs = [ os.path.join(pkgarr_reldir, p) for p in pkg_probe_path ]
for f, reldir in midev.iter_searchfiles([iso_relpath], ['']): # from disk
midev_iso = MiDevice(f, 'iso9660')
for pkgpath, relative_dir in midev_iso.iter_searchfiles([disc_first_pkgs[disc_no]], pkgarr_reldirs): # from iso
probe_ret = ( os.path.join(os.path.dirname(bootiso_relpath), iso_fn),
os.path.normpath(os.path.join(relative_dir, pkgpath)) )
else:
# deal with harddisk case
pkgs = [ os.path.join(p, disc_first_pkgs[disc_no]) for p in pkg_probe_path ]
for f, reldir in midev.iter_searchfiles(pkgs, [pkgarr_reldir]):
probe_ret = ('', os.path.normpath(os.path.join(reldir, f)))
if probe_ret:
result.append(probe_ret)
dolog('probe_all_disc return result is : %s\n' % str(result))
return result
def instpkg_prep(mia, operid, pkgsrc_devinfo, instmode, tgtsys_devinfo):
"""
Install all package prepare work.
We should mount target system device, to prepare install packages.
and mount disk which packages source is saved on.
"""
######### TODO: !!! there to get get get
# Set the package install mode.
global installmode
global dev_hd # the harddisk device where save packages.
global dev_iso # the iso where save pkgs.
global dev_tgt # the target system devices.
dev, fstype, bootiso_relpath, reldir = pkgsrc_devinfo
installmode = instmode
if CF.D.PKGTYPE == "rpm":
dolog("InstallMode: Rpm Packages %s\n" % installmode)
elif CF.D.PKGTYPE == "tar":
dolog("InstallMode: Tar Packages\n")
dolog("instpkg_prep(%s, %s, %s, %s)\n" % (dev, fstype, bootiso_relpath, reldir))
############################## Mount Start #####################################
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
############################## Mount Finished #####################################
# --- This code is according to rpm.spec in rpm-4.2-0.69.src.rpm. ---
# This code is specific to rpm.
import pdb
pdb.set_trace()
var_lib_rpm = os.path.join(CF.D.TGTSYS_ROOT, "var/lib/rpm")
if not os.path.isdir(var_lib_rpm):
os.makedirs(var_lib_rpm)
return 0
def _install(self, pkgpath, progress_cb):
try:
tar_size = os.path.getsize(pkgpath)
except:
errstr = _('Failed on get tar pakcage size "%s"') % (pkgpath, )
logger.e(errstr)
return errstr
try:
tarobj = tarfile.open(fileobj=CBFileObj(pkgpath, (progress_cb, tar_size)))
except:
errstr = _('Failed on create tarfile object on file "%s" size"%d"\n') % (pkgpath, tar_size)
logger.e(errstr)
return errstr
try:
tarobj.extractall(path=self.tgtsys_root)
except:
if tarobj:
tarobj.close()
errstr = _('Failed on extract file "%s" size"%d" to directory "%s"\n') % (pkgpath, tar_size, self.tgtsys_root)
logger.e(errstr)
return errstr
try:
tarobj.close()
except:
logger.w('Close tar pakcage failed path %s size %s' % (pkgpath, tar_size))
return 0
def do_mount(self):
if self.has_mounted: return True
if not self.blk_path: logger.e('MiDevice.do_mount block path is "%s" ' % self.blk_path); return False
# Priority to treat iso virtual device
if self.fstype == 'iso9660':
if not cdrom_available(self.blk_path):
logger.w('MiDevice.do_mount %s type device "%s" cannot be used\n' % (self.fstype, self.blk_path))
return False
else:
isopath = self.blk_path
mountdir = self.mntdir_fixed and self.mntdir or self.loopmntdir
ret, errmsg = mount_dev('iso9660', isopath, mountdir, flags='loop')
if not ret:
logger.e("LoMount %s on %s as %s failed: %s" % (isopath, mountdir, 'iso9660', str(errmsg)))
return False
else:
if not self.mntdir_fixed: self.mntdir = self.loopmntdir
self.has_mounted = True
return True
# Then treat Harddisk Device
if not self.mntdir_fixed:
ret, mntdir = mount_dev(self.fstype, self.blk_path)
else:
ret, mntdir = mount_dev(self.fstype, self.blk_path, self.mntdir)
if not ret:
logger.e("MiDevice.do_mount Mount %s on %s as %s failed: %s" % \
(self.blk_path, mntdir, self.fstype, str(mntdir)))
return False
else:
if not self.mntdir_fixed: self.mntdir = mntdir
self.has_mounted = True
return True
def pkgarr_probe(mia, operid):
logger.i("pkgarr_probe starting...")
def probe_position(localfn, pos_id, new_device, fstype, reldir, isofn):
logger.i('probe_position: %s, %s, %s, %s, %s, %s' % (localfn, pos_id, new_device, fstype, reldir, isofn))
if not os.path.exists(localfn):
return None
try:
execfile(localfn)
except Exception, errmsg:
logger.e("Load %s failed(%s)." % (localfn, str(errmsg)))
return None
remotefn = 'allpa/%s.%d.%s' % (os.path.basename(new_device), pos_id, os.path.basename(localfn))
logger.i('ftp upload %s to remote %s...' % (localfn, remotefn))
try:
ftp = ftplib.FTP("127.0.0.1")
ftp.login("root", "magic")
ftp.storbinary("STOR %s" % remotefn, open(localfn, "rb"), 1024)
ftp.close()
except:
logger.e('Upload failed')
return None
logger.i('Upload success')
return [remotefn, new_device, fstype, reldir, isofn]
if fstype == "iso9660":
return 0 # It is ok for CDROM installation.
mia.set_step(operid, 0, -1) # Sync is the long operation.
# if mntxxxpoint != 0: #### TODO; !!!!!UNKNOWN!!!!!!
# mntdir = os.path.join(CF.D.TGTSYS_ROOT, mntxxxpoint) ####TODO
# else:
# mntdir = os.path.join(CF.D.MNT_ROOT, os.path.basename(dev))
# ret, errmsg = umount_dev(mntdir)
# if not ret:
# logger.e('UMount(%s) failed: %s' % \
# (mntdir, str(errmsg)))
# return str(errmsg)
try:
isys.sync()
except Exception, errmsg:
logger.e("sync failed: %s" % str(errmsg))
return str(errmsg)
return 0
###################### Install package below code #########################
# Now package_install support rpm only.
@register.server_handler("long")
def rpm_installcb(what, bytes, total, h, data):
global cur_rpm_fd
(mia, operid) = data
if what == rpm.RPMCALLBACK_INST_OPEN_FILE: # @UndefinedVariable
cur_rpm_fd = os.open(h, os.O_RDONLY)
return cur_rpm_fd
elif what == rpm.RPMCALLBACK_INST_CLOSE_FILE: # @UndefinedVariable
os.close(cur_rpm_fd)
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
if opera == 'quit':
break
else:
(params, method) = xmlrpclib.loads(opera)
if handlers_long.has_key(method):
if CF.D.EXPERT_MODE:
logger.d('Run long.%s() with %s and id %d,\n' %
(method, params, id))
exe_ok = True
try:
result = handlers_long[method](mia, id, *params)
except:
result = 'Exception: run method %s raise %s' % (
method, str(sys.exc_info()[0:2]))
exe_ok = False
logger.e(result, exc_info=sys.exc_info())
if CF.D.EXPERT_MODE:
logger.d(' which returns %r.\n' % (result, ))
mia.put_result(
xmlrpclib.dumps((id, result, exe_ok),
methodname=method,
allow_none=1))
else:
if CF.D.EXPERT_MODE:
logger.e('ERROR: NOT SUPPORTED method %s().\n' % method)
logger.e('method %s NOT_SUPPORT' % method)
exe_ok = False
mia.put_result(
xmlrpclib.dumps(
(id, 'method %s NOT_SUPPORT' % method, exe_ok),
from mi.server.utils import logger
from mi.server import handlers_long
logger.i('test long logger')
while 1:
(id, opera) = mia.get_operation()
if opera == 'quit':
break
else:
(params, method) = xmlrpclib.loads(opera)
if handlers_long.has_key(method):
if CF.D.EXPERT_MODE:
logger.d('Run long.%s() with %s and id %d,\n' % (method, params, id))
exe_ok = True
try:
result = handlers_long[method](mia, id, *params)
except:
result = 'Exception: run method %s raise %s' % (method, str(sys.exc_info()[0:2]))
exe_ok = False
logger.e(result, exc_info = sys.exc_info())
if CF.D.EXPERT_MODE:
logger.d(' which returns %r.\n' % (result,))
mia.put_result(xmlrpclib.dumps((id, result, exe_ok), methodname=method, allow_none = 1))
else:
if CF.D.EXPERT_MODE:
logger.e('ERROR: NOT SUPPORTED method %s().\n' % method)
logger.e('method %s NOT_SUPPORT' % method)
exe_ok = False
mia.put_result(xmlrpclib.dumps((id, 'method %s NOT_SUPPORT' % method, exe_ok), methodname=method, allow_none = 1))
