def creatoropts(args):
if not args:
raise errors.Usage("need one argument as the path of ks file")
if len(args) != 1:
raise errors.Usage("Extra arguments given")
creatoropts = configmgr.create
ksconf = args[0]
if not os.path.exists(ksconf):
raise errors.CreatorError("Can't find the file: %s" % ksconf)
if not 'record_pkgs' in creatoropts:
creatoropts['record_pkgs'] = []
if creatoropts['release'] is not None:
if 'name' not in creatoropts['record_pkgs']:
creatoropts['record_pkgs'].append('name')
ksconf = misc.normalize_ksfile(ksconf, creatoropts['tokenmap'])
configmgr._ksconf = ksconf
# Called After setting the configmgr._ksconf as the creatoropts['name'] is reset there.
if creatoropts['release'] is not None:
creatoropts['outdir'] = "%s/%s/images/%s/" % (
creatoropts['outdir'], creatoropts['release'], creatoropts['name'])
# try to find the pkgmgr
pkgmgr = None
for (key, pcls) in pluginmgr.get_plugins('backend').items():
if key == creatoropts['pkgmgr']:
pkgmgr = pcls
break
if not pkgmgr:
pkgmgrs = list(pluginmgr.get_plugins('backend').keys())
raise errors.CreatorError(
"Can't find package manager: %s (availables: %s)" %
(creatoropts['pkgmgr'], ', '.join(pkgmgrs)))
creatoropts['pkgmgr_pcls'] = pkgmgr
if creatoropts['runtime']:
rt_util.runmic_in_runtime(creatoropts['runtime'], creatoropts, ksconf,
None)
# Write the normalized kickstart to outdir
# It has to be done this way in case the source ks is same as dest ks
mkdir_p(creatoropts['outdir'])
dst_ks = "%s/%s.ks" % (creatoropts['outdir'], creatoropts['name'])
with open(configmgr._ksconf, 'r') as src_ksf:
src_ks = src_ksf.read()
with open(dst_ks, 'w') as dst_ksf:
dst_ksf.write(src_ks)
creatoropts['dst_ks'] = dst_ks
return creatoropts
def creatoropts(args):
if not args:
raise errors.Usage("need one argument as the path of ks file")
if len(args) != 1:
raise errors.Usage("Extra arguments given")
creatoropts = configmgr.create
ksconf = args[0]
if not os.path.exists(ksconf):
raise errors.CreatorError("Can't find the file: %s" % ksconf)
if not 'record_pkgs' in creatoropts:
creatoropts['record_pkgs'] = []
if creatoropts['release'] is not None:
if 'name' not in creatoropts['record_pkgs']:
creatoropts['record_pkgs'].append('name')
ksconf = misc.normalize_ksfile(ksconf, creatoropts['tokenmap'])
configmgr._ksconf = ksconf
# Called After setting the configmgr._ksconf as the creatoropts['name'] is reset there.
if creatoropts['release'] is not None:
creatoropts['outdir'] = "%s/%s/images/%s/" % (creatoropts['outdir'], creatoropts['release'], creatoropts['name'])
# try to find the pkgmgr
pkgmgr = None
for (key, pcls) in pluginmgr.get_plugins('backend').iteritems():
if key == creatoropts['pkgmgr']:
pkgmgr = pcls
break
if not pkgmgr:
pkgmgrs = pluginmgr.get_plugins('backend').keys()
raise errors.CreatorError("Can't find package manager: %s (availables: %s)" % (creatoropts['pkgmgr'], ', '.join(pkgmgrs)))
creatoropts['pkgmgr_pcls'] = pkgmgr
if creatoropts['runtime']:
rt_util.runmic_in_runtime(creatoropts['runtime'], creatoropts, ksconf, None)
# Write the normalized kickstart to outdir
# It has to be done this way in case the source ks is same as dest ks
mkdir_p(creatoropts['outdir'])
dst_ks = "%s/%s.ks" % (creatoropts['outdir'], creatoropts['name'])
with open(configmgr._ksconf, 'r') as src_ksf:
src_ks = src_ksf.read()
with open(dst_ks, 'w') as dst_ksf:
dst_ksf.write(src_ks)
creatoropts['dst_ks'] = dst_ks
return creatoropts
def main(parser, args, argv):
"""mic choot entry point."""
#args is argparser namespace, argv is the input cmd line
if args is None:
raise errors.Usage("Invalid arguments")
targetimage = args.imagefile
if not os.path.exists(targetimage):
raise errors.CreatorError("Cannot find the image: %s"
% targetimage)
_root_confirm()
configmgr.chroot['saveto'] = args.saveto
imagetype = misc.get_image_type(targetimage)
if imagetype in ("ext3fsimg", "ext4fsimg", "btrfsimg"):
imagetype = "loop"
chrootclass = None
for pname, pcls in pluginmgr.get_plugins('imager').iteritems():
if pname == imagetype and hasattr(pcls, "do_chroot"):
chrootclass = pcls
break
if not chrootclass:
raise errors.CreatorError("Cannot support image type: %s" \
% imagetype)
chrootclass.do_chroot(targetimage, args.cmd)
def _setPkgmgr(self, name):
backend_plugins = pluginmgr.get_plugins('backend')
for (key, cls) in backend_plugins.iteritems():
if key == name:
self._pkgmgr = cls
if not self._pkgmgr:
raise errors.BootstrapError("Backend: %s can't be loaded correctly" % name)
def _setPkgmgr(self, name):
backend_plugins = pluginmgr.get_plugins('backend')
for (key, cls) in backend_plugins.iteritems():
if key == name:
self._pkgmgr = cls
if not self._pkgmgr:
raise errors.BootstrapError(
"Backend: %s can't be loaded correctly" % name)
def __init__(self, *args, **kwargs):
cmdln.Cmdln.__init__(self, *args, **kwargs)
self._subcmds = []
# get cmds from pluginmgr
# mix-in do_subcmd interface
for subcmd, klass in pluginmgr.get_plugins('imager').iteritems():
if not hasattr(klass, 'do_create'):
msger.warning("Unsurpport subcmd: %s" % subcmd)
continue
func = getattr(klass, 'do_create')
setattr(self.__class__, "do_"+subcmd, func)
self._subcmds.append(subcmd)
def __init__(self, *args, **kwargs):
cmdln.Cmdln.__init__(self, *args, **kwargs)
self._subcmds = []
# get cmds from pluginmgr
# mix-in do_subcmd interface
for subcmd, klass in pluginmgr.get_plugins('imager').iteritems():
if not hasattr(klass, 'do_create'):
msger.warning("Unsurpport subcmd: %s" % subcmd)
continue
func = getattr(klass, 'do_create')
setattr(self.__class__, "do_"+subcmd, func)
self._subcmds.append(subcmd)
def do_create(self, subcmd, opts, *args):
"""${cmd_name}: create liveusb image
Usage:
${name} ${cmd_name} <ksfile> [OPTS]
${cmd_option_list}
"""
if len(args) != 1:
raise errors.Usage("Extra arguments given")
creatoropts = configmgr.create
ksconf = args[0]
if creatoropts['runtime'] == "bootstrap":
configmgr._ksconf = ksconf
rt_util.bootstrap_mic()
if creatoropts['arch'] and creatoropts['arch'].startswith('arm'):
msger.warning('liveusb cannot support arm images, Quit')
return
recording_pkgs = []
if len(creatoropts['record_pkgs']) > 0:
recording_pkgs = creatoropts['record_pkgs']
if creatoropts['release'] is not None:
if 'name' not in recording_pkgs:
recording_pkgs.append('name')
if 'vcs' not in recording_pkgs:
recording_pkgs.append('vcs')
configmgr._ksconf = ksconf
# Called After setting the configmgr._ksconf as the creatoropts['name'] is reset there.
if creatoropts['release'] is not None:
creatoropts['outdir'] = "%s/%s/images/%s/" % (
creatoropts['outdir'], creatoropts['release'],
creatoropts['name'])
# try to find the pkgmgr
pkgmgr = None
backends = pluginmgr.get_plugins('backend')
if 'auto' == creatoropts['pkgmgr']:
for key in configmgr.prefer_backends:
if key in backends:
pkgmgr = backends[key]
break
else:
for key in backends.keys():
if key == creatoropts['pkgmgr']:
pkgmgr = backends[key]
break
if not pkgmgr:
raise errors.CreatorError(
"Can't find backend: %s, "
"available choices: %s" %
(creatoropts['pkgmgr'], ','.join(backends.keys())))
creator = liveusb.LiveUSBImageCreator(creatoropts, pkgmgr)
if len(recording_pkgs) > 0:
creator._recording_pkgs = recording_pkgs
self.check_image_exists(creator.destdir, creator.pack_to,
[creator.name + ".usbimg"],
creatoropts['release'])
try:
creator.check_depend_tools()
creator.mount(None, creatoropts["cachedir"])
creator.install()
creator.configure(creatoropts["repomd"])
creator.copy_kernel()
creator.unmount()
creator.package(creatoropts["outdir"])
if creatoropts['release'] is not None:
creator.release_output(ksconf, creatoropts['outdir'],
creatoropts['release'])
creator.print_outimage_info()
except errors.CreatorError:
raise
finally:
creator.cleanup()
msger.info("Finished.")
return 0
def do_create(self, subcmd, opts, *args):
"""${cmd_name}: create livecd image
Usage:
${name} ${cmd_name} <ksfile> [OPTS]
${cmd_option_list}
"""
if len(args) != 1:
raise errors.Usage("Extra arguments given")
creatoropts = configmgr.create
ksconf = args[0]
if creatoropts['runtime'] == 'bootstrap':
configmgr._ksconf = ksconf
rt_util.bootstrap_mic()
if creatoropts['arch'] and creatoropts['arch'].startswith('arm'):
msger.warning('livecd cannot support arm images, Quit')
return
recording_pkgs = []
if len(creatoropts['record_pkgs']) > 0:
recording_pkgs = creatoropts['record_pkgs']
if creatoropts['release'] is not None:
if 'name' not in recording_pkgs:
recording_pkgs.append('name')
if 'vcs' not in recording_pkgs:
recording_pkgs.append('vcs')
configmgr._ksconf = ksconf
# Called After setting the configmgr._ksconf as the creatoropts['name'] is reset there.
if creatoropts['release'] is not None:
creatoropts['outdir'] = "%s/%s/images/%s/" % (creatoropts['outdir'], creatoropts['release'], creatoropts['name'])
# try to find the pkgmgr
pkgmgr = None
backends = pluginmgr.get_plugins('backend')
if 'auto' == creatoropts['pkgmgr']:
for key in configmgr.prefer_backends:
if key in backends:
pkgmgr = backends[key]
break
else:
for key in backends.keys():
if key == creatoropts['pkgmgr']:
pkgmgr = backends[key]
break
if not pkgmgr:
raise errors.CreatorError("Can't find backend: %s, "
"available choices: %s" %
(creatoropts['pkgmgr'],
','.join(backends.keys())))
creator = livecd.LiveCDImageCreator(creatoropts, pkgmgr)
if len(recording_pkgs) > 0:
creator._recording_pkgs = recording_pkgs
self.check_image_exists(creator.destdir,
creator.pack_to,
[creator.name + ".iso"],
creatoropts['release'])
try:
creator.check_depend_tools()
creator.mount(None, creatoropts["cachedir"])
creator.install()
creator.configure(creatoropts["repomd"])
creator.copy_kernel()
creator.unmount()
creator.package(creatoropts["outdir"])
if creatoropts['release'] is not None:
creator.release_output(ksconf, creatoropts['outdir'], creatoropts['release'])
creator.print_outimage_info()
except errors.CreatorError:
raise
finally:
creator.cleanup()
msger.info("Finished.")
return 0
def do_create(self, subcmd, opts, *args):
"""${cmd_name}: create loop image
Usage:
${name} ${cmd_name} <ksfile> [OPTS]
${cmd_option_list}
"""
if not args:
raise errors.Usage("need one argument as the path of ks file")
if len(args) != 1:
raise errors.Usage("Extra arguments given")
creatoropts = configmgr.create
ksconf = args[0]
if not os.path.exists(ksconf):
raise errors.CreatorError("Can't find the file: %s" % ksconf)
recording_pkgs = []
if len(creatoropts['record_pkgs']) > 0:
recording_pkgs = creatoropts['record_pkgs']
if creatoropts['release'] is not None:
if 'name' not in recording_pkgs:
recording_pkgs.append('name')
ksconf = misc.normalize_ksfile(ksconf,
creatoropts['release'],
creatoropts['arch'])
configmgr._ksconf = ksconf
# Called After setting the configmgr._ksconf
# as the creatoropts['name'] is reset there.
if creatoropts['release'] is not None:
creatoropts['outdir'] = "%s/%s/images/%s/" % (creatoropts['outdir'],
creatoropts['release'],
creatoropts['name'])
# try to find the pkgmgr
pkgmgr = None
for (key, pcls) in pluginmgr.get_plugins('backend').iteritems():
if key == creatoropts['pkgmgr']:
pkgmgr = pcls
break
if not pkgmgr:
pkgmgrs = pluginmgr.get_plugins('backend').keys()
raise errors.CreatorError("Can't find package manager: %s "
"(availables: %s)" \
% (creatoropts['pkgmgr'],
', '.join(pkgmgrs)))
if creatoropts['runtime']:
rt_util.runmic_in_runtime(creatoropts['runtime'], creatoropts, ksconf, None)
creator = LoopImageCreator(creatoropts,
pkgmgr,
opts.compress_image,
opts.shrink)
if len(recording_pkgs) > 0:
creator._recording_pkgs = recording_pkgs
self.check_image_exists(creator.destdir,
creator.pack_to,
[creator.name + ".img"],
creatoropts['release'])
try:
creator.check_depend_tools()
creator.mount(None, creatoropts["cachedir"])
creator.install()
creator.configure(creatoropts["repomd"])
creator.copy_kernel()
creator.unmount()
creator.package(creatoropts["outdir"])
if creatoropts['release'] is not None:
creator.release_output(ksconf,
creatoropts['outdir'],
creatoropts['release'])
creator.print_outimage_info()
except errors.CreatorError:
raise
finally:
creator.cleanup()
msger.info("Finished.")
return 0
def do_create(self, subcmd, opts, *args):
"""${cmd_name}: create raw image
Usage:
${name} ${cmd_name} <ksfile> [OPTS]
${cmd_option_list}
"""
if len(args) != 1:
raise errors.Usage("Extra arguments given")
creatoropts = configmgr.create
ksconf = args[0]
if creatoropts['runtime'] == "bootstrap":
configmgr._ksconf = ksconf
rt_util.bootstrap_mic()
recording_pkgs = []
if len(creatoropts['record_pkgs']) > 0:
recording_pkgs = creatoropts['record_pkgs']
if creatoropts['release'] is not None:
if 'name' not in recording_pkgs:
recording_pkgs.append('name')
if 'vcs' not in recording_pkgs:
recording_pkgs.append('vcs')
configmgr._ksconf = ksconf
# Called After setting the configmgr._ksconf as the creatoropts['name'] is reset there.
if creatoropts['release'] is not None:
creatoropts['outdir'] = "%s/%s/images/%s/" % (creatoropts['outdir'], creatoropts['release'], creatoropts['name'])
# try to find the pkgmgr
pkgmgr = None
backends = pluginmgr.get_plugins('backend')
if 'auto' == creatoropts['pkgmgr']:
for key in configmgr.prefer_backends:
if key in backends:
pkgmgr = backends[key]
break
else:
for key in backends.keys():
if key == creatoropts['pkgmgr']:
pkgmgr = backends[key]
break
if not pkgmgr:
raise errors.CreatorError("Can't find backend: %s, "
"available choices: %s" %
(creatoropts['pkgmgr'],
','.join(backends.keys())))
creator = raw.RawImageCreator(creatoropts, pkgmgr, opts.compress_image,
opts.generate_bmap, opts.fstab_entry)
if len(recording_pkgs) > 0:
creator._recording_pkgs = recording_pkgs
images = ["%s-%s.raw" % (creator.name, disk_name)
for disk_name in creator.get_disk_names()]
self.check_image_exists(creator.destdir,
creator.pack_to,
images,
creatoropts['release'])
try:
creator.check_depend_tools()
creator.mount(None, creatoropts["cachedir"])
creator.install()
creator.configure(creatoropts["repomd"])
creator.copy_kernel()
creator.unmount()
creator.generate_bmap()
creator.package(creatoropts["outdir"])
if creatoropts['release'] is not None:
creator.release_output(ksconf, creatoropts['outdir'], creatoropts['release'])
creator.print_outimage_info()
except errors.CreatorError:
raise
finally:
creator.cleanup()
msger.info("Finished.")
return 0
def do_create(self, subcmd, opts, *args):
"""${cmd_name}: create loop image
${cmd_usage}
${cmd_option_list}
"""
if not args:
raise errors.Usage("More arguments needed")
if len(args) != 1:
raise errors.Usage("Extra arguments given")
creatoropts = configmgr.create
ksconf = args[0]
if not os.path.exists(ksconf):
raise errors.CreatorError("Can't find the file: %s" % ksconf)
recording_pkgs = []
if len(creatoropts['record_pkgs']) > 0:
recording_pkgs = creatoropts['record_pkgs']
if creatoropts['release'] is not None:
if 'name' not in recording_pkgs:
recording_pkgs.append('name')
ksconf = misc.save_ksconf_file(ksconf, creatoropts['release'])
name = os.path.splitext(os.path.basename(ksconf))[0]
creatoropts['outdir'] = "%s/%s/images/%s/" % (
creatoropts['outdir'], creatoropts['release'], name)
configmgr._ksconf = ksconf
# try to find the pkgmgr
pkgmgr = None
for (key, pcls) in pluginmgr.get_plugins('backend').iteritems():
if key == creatoropts['pkgmgr']:
pkgmgr = pcls
break
if not pkgmgr:
pkgmgrs = pluginmgr.get_plugins('backend').keys()
raise errors.CreatorError(
"Can't find package manager: %s (availables: %s)" %
(creatoropts['pkgmgr'], ', '.join(pkgmgrs)))
creator = loop.LoopImageCreator(creatoropts, pkgmgr, opts.taring_to)
if len(recording_pkgs) > 0:
creator._recording_pkgs = recording_pkgs
if creatoropts['release'] is None:
if opts.taring_to:
imagefile = "%s.tar" % os.path.join(creator.destdir,
opts.taring_to)
else:
imagefile = "%s.img" % os.path.join(creator.destdir,
creator.name)
if os.path.exists(imagefile):
if msger.ask(
'The target image: %s already exists, cleanup and continue?'
% imagefile):
os.unlink(imagefile)
else:
raise errors.Abort('Canceled')
try:
creator.check_depend_tools()
creator.mount(None, creatoropts["cachedir"])
creator.install()
creator.configure(creatoropts["repomd"])
creator.unmount()
creator.package(creatoropts["outdir"])
if creatoropts['release'] is not None:
creator.release_output(ksconf, creatoropts['outdir'],
creatoropts['release'])
creator.print_outimage_info()
except errors.CreatorError:
raise
finally:
creator.cleanup()
msger.info("Finished.")
return 0
def do_create(self, args):
"""${cmd_name}: create raw image
Usage:
${name} ${cmd_name} <ksfile> [OPTS]
${cmd_option_list}
"""
creatoropts = configmgr.create
ksconf = args.ksfile
if creatoropts['runtime'] == "bootstrap":
configmgr._ksconf = ksconf
rt_util.bootstrap_mic()
recording_pkgs = []
if len(creatoropts['record_pkgs']) > 0:
recording_pkgs = creatoropts['record_pkgs']
if creatoropts['release'] is not None:
if 'name' not in recording_pkgs:
recording_pkgs.append('name')
if 'vcs' not in recording_pkgs:
recording_pkgs.append('vcs')
configmgr._ksconf = ksconf
# try to find the pkgmgr
pkgmgr = None
backends = pluginmgr.get_plugins('backend')
if 'auto' == creatoropts['pkgmgr']:
for key in configmgr.prefer_backends:
if key in backends:
pkgmgr = backends[key]
break
else:
for key in backends.keys():
if key == creatoropts['pkgmgr']:
pkgmgr = backends[key]
break
if not pkgmgr:
raise errors.CreatorError(
"Can't find backend: %s, "
"available choices: %s" %
(creatoropts['pkgmgr'], ','.join(backends.keys())))
creator = raw.RawImageCreator(creatoropts, pkgmgr, args.compress_image,
args.generate_bmap, args.fstab_entry)
if len(recording_pkgs) > 0:
creator._recording_pkgs = recording_pkgs
images = [
"%s-%s.raw" % (creator.name, disk_name)
for disk_name in creator.get_disk_names()
]
self.check_image_exists(creator.destdir, creator.pack_to, images,
creatoropts['release'])
try:
creator.check_depend_tools()
creator.mount(None, creatoropts["cachedir"])
creator.install()
creator.configure(creatoropts["repomd"])
creator.copy_kernel()
creator.unmount()
creator.generate_bmap()
creator.package(creatoropts["destdir"])
creator.create_manifest()
if creatoropts['release'] is not None:
creator.release_output(ksconf, creatoropts['destdir'],
creatoropts['release'])
creator.print_outimage_info()
except errors.CreatorError:
raise
finally:
creator.cleanup()
#Run script of --run_script after image created
if creatoropts['run_script']:
cmd = creatoropts['run_script']
try:
runner.show(cmd)
except OSError, err:
msger.warning(str(err))
def do_create(self, subcmd, opts, *args):
"""${cmd_name}: create liveusb image
Usage:
${name} ${cmd_name} <ksfile> [OPTS]
${cmd_option_list}
"""
if len(args) != 1:
raise errors.Usage("Extra arguments given")
creatoropts = configmgr.create
ksconf = args[0]
if creatoropts['runtime'] == "bootstrap":
configmgr._ksconf = ksconf
rt_util.bootstrap_mic()
elif not rt_util.inbootstrap():
try:
fs_related.find_binary_path('mic-native')
except errors.CreatorError:
if not msger.ask(
"Subpackage \"mic-native\" has not been "
"installed in your host system, still "
"continue with \"native\" running mode?", False):
raise errors.Abort("Abort because subpackage 'mic-native' "
"has not been installed")
if creatoropts['arch'] and creatoropts['arch'].startswith('arm'):
msger.warning('liveusb cannot support arm images, Quit')
return
recording_pkgs = []
if len(creatoropts['record_pkgs']) > 0:
recording_pkgs = creatoropts['record_pkgs']
if creatoropts['release'] is not None:
if 'name' not in recording_pkgs:
recording_pkgs.append('name')
if 'vcs' not in recording_pkgs:
recording_pkgs.append('vcs')
configmgr._ksconf = ksconf
# try to find the pkgmgr
pkgmgr = None
backends = pluginmgr.get_plugins('backend')
if 'auto' == creatoropts['pkgmgr']:
for key in configmgr.prefer_backends:
if key in backends:
pkgmgr = backends[key]
break
else:
for key in backends.keys():
if key == creatoropts['pkgmgr']:
pkgmgr = backends[key]
break
if not pkgmgr:
raise errors.CreatorError(
"Can't find backend: %s, "
"available choices: %s" %
(creatoropts['pkgmgr'], ','.join(backends.keys())))
creator = liveusb.LiveUSBImageCreator(creatoropts, pkgmgr)
if len(recording_pkgs) > 0:
creator._recording_pkgs = recording_pkgs
self.check_image_exists(creator.destdir, creator.pack_to,
[creator.name + ".usbimg"],
creatoropts['release'])
try:
creator.check_depend_tools()
creator.mount(None, creatoropts["cachedir"])
creator.install()
creator.configure(creatoropts["repomd"])
creator.copy_kernel()
creator.unmount()
creator.package(creatoropts["destdir"])
creator.create_manifest()
if creatoropts['release'] is not None:
creator.release_output(ksconf, creatoropts['destdir'],
creatoropts['release'])
creator.print_outimage_info()
except errors.CreatorError:
raise
finally:
creator.cleanup()
msger.info("Finished.")
return 0
def do_create(self, subcmd, opts, *args):
"""${cmd_name}: create fs image
Usage:
${name} ${cmd_name} <ksfile> [OPTS]
${cmd_option_list}
"""
if len(args) != 1:
raise errors.Usage("Extra arguments given")
creatoropts = configmgr.create
ksconf = args[0]
if creatoropts['runtime'] == 'bootstrap':
configmgr._ksconf = ksconf
rt_util.bootstrap_mic()
elif not rt_util.inbootstrap():
try:
fs_related.find_binary_path('mic-native')
except errors.CreatorError:
if not msger.ask("Subpackage \"mic-native\" has not been "
"installed in your host system, still "
"continue with \"native\" running mode?",
False):
raise errors.Abort("Abort because subpackage 'mic-native' "
"has not been installed")
recording_pkgs = []
if len(creatoropts['record_pkgs']) > 0:
recording_pkgs = creatoropts['record_pkgs']
if creatoropts['release'] is not None:
if 'name' not in recording_pkgs:
recording_pkgs.append('name')
if 'vcs' not in recording_pkgs:
recording_pkgs.append('vcs')
configmgr._ksconf = ksconf
# try to find the pkgmgr
pkgmgr = None
backends = pluginmgr.get_plugins('backend')
if 'auto' == creatoropts['pkgmgr']:
for key in configmgr.prefer_backends:
if key in backends:
pkgmgr = backends[key]
break
else:
for key in backends.keys():
if key == creatoropts['pkgmgr']:
pkgmgr = backends[key]
break
if not pkgmgr:
raise errors.CreatorError("Can't find backend: %s, "
"available choices: %s" %
(creatoropts['pkgmgr'],
','.join(backends.keys())))
creator = fs.FsImageCreator(creatoropts, pkgmgr)
creator._include_src = opts.include_src
if len(recording_pkgs) > 0:
creator._recording_pkgs = recording_pkgs
self.check_image_exists(creator.destdir,
creator.pack_to,
[creator.name],
creatoropts['release'])
try:
creator.check_depend_tools()
creator.mount(None, creatoropts["cachedir"])
creator.install()
#Download the source packages ###private options
if opts.include_src:
installed_pkgs = creator.get_installed_packages()
msger.info('--------------------------------------------------')
msger.info('Generating the image with source rpms included ...')
if not misc.SrcpkgsDownload(installed_pkgs, creatoropts["repomd"], creator._instroot, creatoropts["cachedir"]):
msger.warning("Source packages can't be downloaded")
creator.configure(creatoropts["repomd"])
creator.copy_kernel()
creator.unmount()
creator.package(creatoropts["destdir"])
if creatoropts['release'] is not None:
creator.release_output(ksconf, creatoropts['destdir'],
creatoropts['release'])
creator.print_outimage_info()
except errors.CreatorError:
raise
finally:
creator.cleanup()
msger.info("Finished.")
return 0
def do_create(self, args):
"""${cmd_name}: create fs image
Usage:
${name} ${cmd_name} <ksfile> [OPTS]
${cmd_option_list}
"""
if args is None:
raise errors.Usage("Invalid arguments.")
creatoropts = configmgr.create
ksconf = args.ksfile
if creatoropts['runtime'] == 'bootstrap':
configmgr._ksconf = ksconf
rt_util.bootstrap_mic()
recording_pkgs = []
if len(creatoropts['record_pkgs']) > 0:
recording_pkgs = creatoropts['record_pkgs']
if creatoropts['release'] is not None:
if 'name' not in recording_pkgs:
recording_pkgs.append('name')
if 'vcs' not in recording_pkgs:
recording_pkgs.append('vcs')
configmgr._ksconf = ksconf
# try to find the pkgmgr
pkgmgr = None
backends = pluginmgr.get_plugins('backend')
if 'auto' == creatoropts['pkgmgr']:
for key in configmgr.prefer_backends:
if key in backends:
pkgmgr = backends[key]
break
else:
for key in backends.keys():
if key == creatoropts['pkgmgr']:
pkgmgr = backends[key]
break
if not pkgmgr:
raise errors.CreatorError("Can't find backend: %s, "
"available choices: %s" %
(creatoropts['pkgmgr'],
','.join(backends.keys())))
creator = fs.FsImageCreator(creatoropts, pkgmgr)
creator._include_src = args.include_src
if len(recording_pkgs) > 0:
creator._recording_pkgs = recording_pkgs
self.check_image_exists(creator.destdir,
creator.pack_to,
[creator.name],
creatoropts['release'])
try:
creator.check_depend_tools()
creator.mount(None, creatoropts["cachedir"])
creator.install()
#Download the source packages ###private options
if args.include_src:
installed_pkgs = creator.get_installed_packages()
msger.info('Generating the image with source rpms included ...')
if not misc.SrcpkgsDownload(installed_pkgs, creatoropts["repomd"],
creator._instroot, creatoropts["cachedir"]):
msger.warning("Source packages can't be downloaded")
creator.configure(creatoropts["repomd"])
creator.copy_kernel()
creator.unmount()
creator.package(creatoropts["destdir"])
creator.create_manifest()
if creatoropts['release'] is not None:
creator.release_output(ksconf, creatoropts['destdir'],
creatoropts['release'])
creator.print_outimage_info()
except errors.CreatorError:
raise
finally:
creator.cleanup()
#Run script of --run_script after image created
if creatoropts['run_script']:
cmd = creatoropts['run_script']
try:
runner.show(cmd)
except OSError,err:
msger.warning(str(err))
def do_create(self, subcmd, opts, *args):
"""${cmd_name}: create fs image
${cmd_usage}
${cmd_option_list}
"""
if not args:
raise errors.Usage("More arguments needed")
if len(args) != 1:
raise errors.Usage("Extra arguments given")
creatoropts = configmgr.create
ksconf = args[0]
if not os.path.exists(ksconf):
raise errors.CreatorError("Can't find the file: %s" % ksconf)
recording_pkgs = []
if len(creatoropts['record_pkgs']) > 0:
recording_pkgs = creatoropts['record_pkgs']
if creatoropts['release'] is not None:
if 'name' not in recording_pkgs:
recording_pkgs.append('name')
ksconf = misc.save_ksconf_file(ksconf, creatoropts['release'])
name = os.path.splitext(os.path.basename(ksconf))[0]
creatoropts['outdir'] = "%s/%s/images/%s/" % (creatoropts['outdir'], creatoropts['release'], name)
configmgr._ksconf = ksconf
# try to find the pkgmgr
pkgmgr = None
for (key, pcls) in pluginmgr.get_plugins('backend').iteritems():
if key == creatoropts['pkgmgr']:
pkgmgr = pcls
break
if not pkgmgr:
pkgmgrs = pluginmgr.get_plugins('backend').keys()
raise errors.CreatorError("Can't find package manager: %s (availables: %s)" % (creatoropts['pkgmgr'], ', '.join(pkgmgrs)))
creator = fs.FsImageCreator(creatoropts, pkgmgr)
creator._include_src = opts.include_src
if len(recording_pkgs) > 0:
creator._recording_pkgs = recording_pkgs
if creatoropts['release'] is None:
fsdir = os.path.join(creator.destdir, creator.name)
if os.path.exists(fsdir):
if msger.ask('The target dir: %s already exists, cleanup and continue?' % fsdir):
import shutil
shutil.rmtree(fsdir)
else:
raise errors.Abort('Canceled')
try:
creator.check_depend_tools()
creator.mount(None, creatoropts["cachedir"])
creator.install()
#Download the source packages ###private options
if opts.include_src:
installed_pkgs = creator.get_installed_packages()
msger.info('--------------------------------------------------')
msger.info('Generating the image with source rpms included, The number of source packages is %d.' %(len(installed_pkgs)))
if not misc.SrcpkgsDownload(installed_pkgs, creatoropts["repomd"], creator._instroot, creatoropts["cachedir"]):
msger.warning("Source packages can't be downloaded")
creator.configure(creatoropts["repomd"])
creator.unmount()
creator.package(creatoropts["outdir"])
if creatoropts['release'] is not None:
creator.release_output(ksconf, creatoropts['outdir'], creatoropts['release'])
creator.print_outimage_info()
except errors.CreatorError:
raise
finally:
creator.cleanup()
msger.info("Finished.")
return 0
def do_create(self, subcmd, opts, *args):
"""${cmd_name}: create loop image
Usage:
${name} ${cmd_name} <ksfile> [OPTS]
${cmd_option_list}
"""
if not args:
raise errors.Usage("need one argument as the path of ks file")
if len(args) != 1:
raise errors.Usage("Extra arguments given")
creatoropts = configmgr.create
ksconf = args[0]
if not os.path.exists(ksconf):
raise errors.CreatorError("Can't find the file: %s" % ksconf)
recording_pkgs = []
if len(creatoropts['record_pkgs']) > 0:
recording_pkgs = creatoropts['record_pkgs']
if creatoropts['release'] is not None:
if 'name' not in recording_pkgs:
recording_pkgs.append('name')
ksconf = misc.normalize_ksfile(ksconf, creatoropts['release'],
creatoropts['arch'])
configmgr._ksconf = ksconf
# Called After setting the configmgr._ksconf
# as the creatoropts['name'] is reset there.
if creatoropts['release'] is not None:
creatoropts['outdir'] = "%s/%s/images/%s/" % (
creatoropts['outdir'], creatoropts['release'],
creatoropts['name'])
# try to find the pkgmgr
pkgmgr = None
for (key, pcls) in pluginmgr.get_plugins('backend').iteritems():
if key == creatoropts['pkgmgr']:
pkgmgr = pcls
break
if not pkgmgr:
pkgmgrs = pluginmgr.get_plugins('backend').keys()
raise errors.CreatorError("Can't find package manager: %s "
"(availables: %s)" \
% (creatoropts['pkgmgr'],
', '.join(pkgmgrs)))
if creatoropts['runtime']:
rt_util.runmic_in_runtime(creatoropts['runtime'], creatoropts,
ksconf, None)
creator = LoopImageCreator(creatoropts, pkgmgr, opts.compress_image,
opts.shrink)
if len(recording_pkgs) > 0:
creator._recording_pkgs = recording_pkgs
self.check_image_exists(creator.destdir, creator.pack_to,
[creator.name + ".img"],
creatoropts['release'])
try:
creator.check_depend_tools()
creator.mount(None, creatoropts["cachedir"])
creator.install()
creator.configure(creatoropts["repomd"])
creator.copy_kernel()
creator.unmount()
creator.package(creatoropts["outdir"])
if creatoropts['release'] is not None:
creator.release_output(ksconf, creatoropts['outdir'],
creatoropts['release'])
creator.print_outimage_info()
except errors.CreatorError:
raise
finally:
creator.cleanup()
msger.info("Finished.")
return 0
def do_create(self, subcmd, opts, *args):
"""${cmd_name}: create liveusb image
Usage:
${name} ${cmd_name} <ksfile> [OPTS]
${cmd_option_list}
"""
if not args:
raise errors.Usage("need one argument as the path of ks file")
if len(args) != 1:
raise errors.Usage("Extra arguments given")
creatoropts = configmgr.create
ksconf = args[0]
if not os.path.exists(ksconf):
raise errors.CreatorError("Can't find the file: %s" % ksconf)
if creatoropts['arch'] and creatoropts['arch'].startswith('arm'):
msger.warning('liveusb cannot support arm images, Quit')
return
recording_pkgs = []
if len(creatoropts['record_pkgs']) > 0:
recording_pkgs = creatoropts['record_pkgs']
if creatoropts['release'] is not None:
if 'name' not in recording_pkgs:
recording_pkgs.append('name')
ksconf = misc.save_ksconf_file(ksconf, creatoropts['release'])
configmgr._ksconf = ksconf
# Called After setting the configmgr._ksconf as the creatoropts['name'] is reset there.
if creatoropts['release'] is not None:
creatoropts['outdir'] = "%s/%s/images/%s/" % (creatoropts['outdir'], creatoropts['release'], creatoropts['name'])
# try to find the pkgmgr
pkgmgr = None
for (key, pcls) in pluginmgr.get_plugins('backend').iteritems():
if key == creatoropts['pkgmgr']:
pkgmgr = pcls
break
if not pkgmgr:
pkgmgrs = pluginmgr.get_plugins('backend').keys()
raise errors.CreatorError("Can't find package manager: %s (availables: %s)" % (creatoropts['pkgmgr'], ', '.join(pkgmgrs)))
if creatoropts['runtime']:
rt_util.runmic_in_runtime(creatoropts['runtime'], creatoropts, ksconf, None)
creator = liveusb.LiveUSBImageCreator(creatoropts, pkgmgr)
if len(recording_pkgs) > 0:
creator._recording_pkgs = recording_pkgs
if creatoropts['release'] is None:
imagefile = "%s.usbimg" % os.path.join(creator.destdir, creator.name)
if os.path.exists(imagefile):
if msger.ask('The target image: %s already exists, cleanup and continue?' % imagefile):
os.unlink(imagefile)
else:
raise errors.Abort('Canceled')
try:
creator.check_depend_tools()
creator.mount(None, creatoropts["cachedir"])
creator.install()
creator.configure(creatoropts["repomd"])
creator.unmount()
creator.package(creatoropts["outdir"])
if creatoropts['release'] is not None:
creator.release_output(ksconf, creatoropts['outdir'], creatoropts['release'])
creator.print_outimage_info()
except errors.CreatorError:
raise
finally:
creator.cleanup()
msger.info("Finished.")
return 0
def do_create(cls, args):
"""${cmd_name}: create qcow image
Usage:
${name} ${cmd_name} <ksfile> [OPTS]
${cmd_option_list}
"""
if args is None:
raise errors.Usage("Invalid arguments")
creatoropts = configmgr.create
ksconf = args.ksfile
if creatoropts['runtime'] == "bootstrap":
configmgr._ksconf = ksconf
rt_util.bootstrap_mic()
recording_pkgs = []
if len(creatoropts['record_pkgs']) > 0:
recording_pkgs = creatoropts['record_pkgs']
if creatoropts['release'] is not None:
if 'name' not in recording_pkgs:
recording_pkgs.append('name')
if 'vcs' not in recording_pkgs:
recording_pkgs.append('vcs')
configmgr._ksconf = ksconf
# try to find the pkgmgr
pkgmgr = None
backends = pluginmgr.get_plugins('backend')
if 'auto' == creatoropts['pkgmgr']:
for key in configmgr.prefer_backends:
if key in backends:
pkgmgr = backends[key]
break
else:
for key in backends.keys():
if key == creatoropts['pkgmgr']:
pkgmgr = backends[key]
break
if not pkgmgr:
raise errors.CreatorError("Can't find backend: %s, "
"available choices: %s" %
(creatoropts['pkgmgr'],
','.join(backends.keys())))
creator = QcowImageCreator(creatoropts,
pkgmgr)
if len(recording_pkgs) > 0:
creator._recording_pkgs = recording_pkgs
image_names = [creator.name + ".img"]
image_names.extend(creator.get_image_names())
cls.check_image_exists(creator.destdir,
creator.pack_to,
image_names,
creatoropts['release'])
try:
creator.check_depend_tools()
creator.mount(None, creatoropts["cachedir"])
creator.install()
creator.configure(creatoropts["repomd"])
creator.copy_kernel()
creator.unmount()
creator.package(creatoropts["destdir"])
creator.create_manifest()
if creatoropts['release'] is not None:
creator.release_output(ksconf,
creatoropts['destdir'],
creatoropts['release'])
creator.print_outimage_info()
except errors.CreatorError:
raise
finally:
creator.cleanup()
msger.info("Finished.")
return 0
def do_create(self, subcmd, opts, *args):
"""${cmd_name}: create liveusb image
Usage:
${name} ${cmd_name} <ksfile> [OPTS]
${cmd_option_list}
"""
if not args:
raise errors.Usage("need one argument as the path of ks file")
if len(args) != 1:
raise errors.Usage("Extra arguments given")
creatoropts = configmgr.create
ksconf = args[0]
if not os.path.exists(ksconf):
raise errors.CreatorError("Can't find the file: %s" % ksconf)
if creatoropts["arch"] and creatoropts["arch"].startswith("arm"):
msger.warning("liveusb cannot support arm images, Quit")
return
recording_pkgs = []
if len(creatoropts["record_pkgs"]) > 0:
recording_pkgs = creatoropts["record_pkgs"]
if creatoropts["release"] is not None:
if "name" not in recording_pkgs:
recording_pkgs.append("name")
ksconf = misc.normalize_ksfile(ksconf, creatoropts["release"], creatoropts["arch"])
configmgr._ksconf = ksconf
# Called After setting the configmgr._ksconf as the creatoropts['name'] is reset there.
if creatoropts["release"] is not None:
creatoropts["outdir"] = "%s/%s/images/%s/" % (
creatoropts["outdir"],
creatoropts["release"],
creatoropts["name"],
)
# try to find the pkgmgr
pkgmgr = None
for (key, pcls) in pluginmgr.get_plugins("backend").iteritems():
if key == creatoropts["pkgmgr"]:
pkgmgr = pcls
break
if not pkgmgr:
pkgmgrs = pluginmgr.get_plugins("backend").keys()
raise errors.CreatorError(
"Can't find package manager: %s (availables: %s)" % (creatoropts["pkgmgr"], ", ".join(pkgmgrs))
)
if creatoropts["runtime"]:
rt_util.runmic_in_runtime(creatoropts["runtime"], creatoropts, ksconf, None)
creator = liveusb.LiveUSBImageCreator(creatoropts, pkgmgr)
if len(recording_pkgs) > 0:
creator._recording_pkgs = recording_pkgs
self.check_image_exists(creator.destdir, creator.pack_to, [creator.name + ".usbimg"], creatoropts["release"])
try:
creator.check_depend_tools()
creator.mount(None, creatoropts["cachedir"])
creator.install()
creator.configure(creatoropts["repomd"])
creator.copy_kernel()
creator.unmount()
creator.package(creatoropts["outdir"])
if creatoropts["release"] is not None:
creator.release_output(ksconf, creatoropts["outdir"], creatoropts["release"])
creator.print_outimage_info()
except errors.CreatorError:
raise
finally:
creator.cleanup()
msger.info("Finished.")
return 0
def do_create(self, subcmd, opts, *args):
"""${cmd_name}: create loop image
Usage:
${name} ${cmd_name} <ksfile> [OPTS]
${cmd_option_list}
"""
if len(args) != 1:
raise errors.Usage("Extra arguments given")
creatoropts = configmgr.create
ksconf = args[0]
if creatoropts['runtime'] == "bootstrap":
configmgr._ksconf = ksconf
rt_util.bootstrap_mic()
elif not rt_util.inbootstrap():
try:
fs_related.find_binary_path('mic-native')
except errors.CreatorError:
if not msger.ask("Subpackage \"mic-native\" has not been "
"installed in your host system, still "
"continue with \"native\" running mode?",
False):
raise errors.Abort("Abort because subpackage 'mic-native' "
"has not been installed")
recording_pkgs = []
if len(creatoropts['record_pkgs']) > 0:
recording_pkgs = creatoropts['record_pkgs']
if creatoropts['release'] is not None:
if 'name' not in recording_pkgs:
recording_pkgs.append('name')
if 'vcs' not in recording_pkgs:
recording_pkgs.append('vcs')
configmgr._ksconf = ksconf
# try to find the pkgmgr
pkgmgr = None
backends = pluginmgr.get_plugins('backend')
if 'auto' == creatoropts['pkgmgr']:
for key in configmgr.prefer_backends:
if key in backends:
pkgmgr = backends[key]
break
else:
for key in backends.keys():
if key == creatoropts['pkgmgr']:
pkgmgr = backends[key]
break
if not pkgmgr:
raise errors.CreatorError("Can't find backend: %s, "
"available choices: %s" %
(creatoropts['pkgmgr'],
','.join(backends.keys())))
creator = LoopImageCreator(creatoropts,
pkgmgr,
opts.compress_image,
opts.shrink)
if len(recording_pkgs) > 0:
creator._recording_pkgs = recording_pkgs
image_names = [creator.name + ".img"]
image_names.extend(creator.get_image_names())
self.check_image_exists(creator.destdir,
creator.pack_to,
image_names,
creatoropts['release'])
try:
creator.check_depend_tools()
creator.mount(None, creatoropts["cachedir"])
creator.install()
creator.configure(creatoropts["repomd"])
creator.copy_kernel()
creator.unmount()
creator.package(creatoropts["destdir"])
if creatoropts['release'] is not None:
creator.release_output(ksconf,
creatoropts['destdir'],
creatoropts['release'])
creator.print_outimage_info()
except errors.CreatorError:
raise
finally:
creator.cleanup()
msger.info("Finished.")
return 0
def do_create(self, subcmd, opts, *args):
"""${cmd_name}: create fs image
Usage:
${name} ${cmd_name} <ksfile> [OPTS]
${cmd_option_list}
"""
if not args:
raise errors.Usage("need one argument as the path of ks file")
if len(args) != 1:
raise errors.Usage("Extra arguments given")
creatoropts = configmgr.create
ksconf = args[0]
if not os.path.exists(ksconf):
raise errors.CreatorError("Can't find the file: %s" % ksconf)
recording_pkgs = []
if len(creatoropts['record_pkgs']) > 0:
recording_pkgs = creatoropts['record_pkgs']
if creatoropts['release'] is not None:
if 'name' not in recording_pkgs:
recording_pkgs.append('name')
ksconf = misc.normalize_ksfile(ksconf,
creatoropts['release'],
creatoropts['arch'])
configmgr._ksconf = ksconf
# Called After setting the configmgr._ksconf as the creatoropts['name'] is reset there.
if creatoropts['release'] is not None:
creatoropts['outdir'] = "%s/%s/images/%s/" % (creatoropts['outdir'], creatoropts['release'], creatoropts['name'])
# try to find the pkgmgr
pkgmgr = None
for (key, pcls) in pluginmgr.get_plugins('backend').iteritems():
if key == creatoropts['pkgmgr']:
pkgmgr = pcls
break
if not pkgmgr:
pkgmgrs = pluginmgr.get_plugins('backend').keys()
raise errors.CreatorError("Can't find package manager: %s (availables: %s)" % (creatoropts['pkgmgr'], ', '.join(pkgmgrs)))
if creatoropts['runtime']:
rt_util.runmic_in_runtime(creatoropts['runtime'], creatoropts, ksconf, None)
creator = fs.FsImageCreator(creatoropts, pkgmgr)
creator._include_src = opts.include_src
if len(recording_pkgs) > 0:
creator._recording_pkgs = recording_pkgs
self.check_image_exists(creator.destdir,
creator.pack_to,
[creator.name],
creatoropts['release'])
try:
creator.check_depend_tools()
creator.mount(None, creatoropts["cachedir"])
creator.install()
#Download the source packages ###private options
if opts.include_src:
installed_pkgs = creator.get_installed_packages()
msger.info('--------------------------------------------------')
msger.info('Generating the image with source rpms included ...')
if not misc.SrcpkgsDownload(installed_pkgs, creatoropts["repomd"], creator._instroot, creatoropts["cachedir"]):
msger.warning("Source packages can't be downloaded")
creator.configure(creatoropts["repomd"])
creator.copy_kernel()
creator.unmount()
creator.package(creatoropts["outdir"])
if creatoropts['release'] is not None:
creator.release_output(ksconf, creatoropts['outdir'], creatoropts['release'])
creator.print_outimage_info()
except errors.CreatorError:
raise
finally:
creator.cleanup()
msger.info("Finished.")
return 0
def do_create(self, subcmd, opts, *args):
"""${cmd_name}: create fs image
Usage:
${name} ${cmd_name} <ksfile> [OPTS]
${cmd_option_list}
"""
if not args:
raise errors.Usage("need one argument as the path of ks file")
if len(args) != 1:
raise errors.Usage("Extra arguments given")
creatoropts = configmgr.create
ksconf = args[0]
if not os.path.exists(ksconf):
raise errors.CreatorError("Can't find the file: %s" % ksconf)
recording_pkgs = []
if len(creatoropts['record_pkgs']) > 0:
recording_pkgs = creatoropts['record_pkgs']
if creatoropts['release'] is not None:
if 'name' not in recording_pkgs:
recording_pkgs.append('name')
ksconf = misc.save_ksconf_file(ksconf, creatoropts['release'])
configmgr._ksconf = ksconf
# Called After setting the configmgr._ksconf as the creatoropts['name'] is reset there.
if creatoropts['release'] is not None:
creatoropts['outdir'] = "%s/%s/images/%s/" % (creatoropts['outdir'], creatoropts['release'], creatoropts['name'])
# try to find the pkgmgr
pkgmgr = None
for (key, pcls) in pluginmgr.get_plugins('backend').iteritems():
if key == creatoropts['pkgmgr']:
pkgmgr = pcls
break
if not pkgmgr:
pkgmgrs = pluginmgr.get_plugins('backend').keys()
raise errors.CreatorError("Can't find package manager: %s (availables: %s)" % (creatoropts['pkgmgr'], ', '.join(pkgmgrs)))
if creatoropts['runtime']:
rt_util.runmic_in_runtime(creatoropts['runtime'], creatoropts, ksconf, None)
creator = fs.FsImageCreator(creatoropts, pkgmgr)
creator._include_src = opts.include_src
if len(recording_pkgs) > 0:
creator._recording_pkgs = recording_pkgs
if creatoropts['release'] is None:
fsdir = os.path.join(creator.destdir, creator.name)
if os.path.exists(fsdir):
if msger.ask('The target dir: %s already exists, cleanup and continue?' % fsdir):
import shutil
shutil.rmtree(fsdir)
else:
raise errors.Abort('Canceled')
try:
creator.check_depend_tools()
creator.mount(None, creatoropts["cachedir"])
creator.install()
#Download the source packages ###private options
if opts.include_src:
installed_pkgs = creator.get_installed_packages()
msger.info('--------------------------------------------------')
msger.info('Generating the image with source rpms included ...')
if not misc.SrcpkgsDownload(installed_pkgs, creatoropts["repomd"], creator._instroot, creatoropts["cachedir"]):
msger.warning("Source packages can't be downloaded")
creator.configure(creatoropts["repomd"])
creator.copy_kernel()
creator.unmount()
creator.package(creatoropts["outdir"])
if creatoropts['release'] is not None:
creator.release_output(ksconf, creatoropts['outdir'], creatoropts['release'])
creator.print_outimage_info()
except errors.CreatorError:
raise
finally:
creator.cleanup()
msger.info("Finished.")
return 0
def do_create(self, subcmd, opts, *args):
"""${cmd_name}: create raw image
${cmd_usage}
${cmd_option_list}
"""
if not args:
raise errors.Usage("More arguments needed")
if len(args) != 1:
raise errors.Usage("Extra arguments given")
creatoropts = configmgr.create
ksconf = args[0]
if not os.path.exists(ksconf):
raise errors.CreatorError("Can't find the file: %s" % ksconf)
recording_pkgs = []
if len(creatoropts['record_pkgs']) > 0:
recording_pkgs = creatoropts['record_pkgs']
if creatoropts['release'] is not None:
if 'name' not in recording_pkgs:
recording_pkgs.append('name')
ksconf = misc.save_ksconf_file(ksconf, creatoropts['release'])
name = os.path.splitext(os.path.basename(ksconf))[0]
creatoropts['outdir'] = "%s/%s/images/%s/" % (creatoropts['outdir'], creatoropts['release'], name)
configmgr._ksconf = ksconf
# try to find the pkgmgr
pkgmgr = None
for (key, pcls) in pluginmgr.get_plugins('backend').iteritems():
if key == creatoropts['pkgmgr']:
pkgmgr = pcls
break
if not pkgmgr:
pkgmgrs = pluginmgr.get_plugins('backend').keys()
raise errors.CreatorError("Can't find package manager: %s (availables: %s)" % (creatoropts['pkgmgr'], ', '.join(pkgmgrs)))
creator = raw.RawImageCreator(creatoropts, pkgmgr)
if len(recording_pkgs) > 0:
creator._recording_pkgs = recording_pkgs
if creatoropts['release'] is None:
imagefile = "%s-sda.raw" % os.path.join(creator.destdir, creator.name)
if os.path.exists(imagefile):
if msger.ask('The target image: %s already exists, cleanup and continue?' % imagefile):
os.unlink(imagefile)
else:
raise errors.Abort('Canceled')
try:
creator.check_depend_tools()
creator.mount(None, creatoropts["cachedir"])
creator.install()
creator.configure(creatoropts["repomd"])
creator.unmount()
creator.package(creatoropts["outdir"])
if creatoropts['release'] is not None:
creator.release_output(ksconf, creatoropts['outdir'], creatoropts['release'])
creator.print_outimage_info()
except errors.CreatorError:
raise
finally:
creator.cleanup()
msger.info("Finished.")
return 0
def do_create(self, subcmd, opts, *args):
"""${cmd_name}: create fs image
Usage:
${name} ${cmd_name} <ksfile> [OPTS]
${cmd_option_list}
"""
if len(args) != 1:
raise errors.Usage("Extra arguments given")
creatoropts = configmgr.create
ksconf = args[0]
if creatoropts['runtime'] == 'bootstrap':
configmgr._ksconf = ksconf
rt_util.bootstrap_mic()
recording_pkgs = []
if len(creatoropts['record_pkgs']) > 0:
recording_pkgs = creatoropts['record_pkgs']
if creatoropts['release'] is not None:
if 'name' not in recording_pkgs:
recording_pkgs.append('name')
if 'vcs' not in recording_pkgs:
recording_pkgs.append('vcs')
configmgr._ksconf = ksconf
# Called After setting the configmgr._ksconf as the creatoropts['name'] is reset there.
if creatoropts['release'] is not None:
creatoropts['outdir'] = "%s/%s/images/%s/" % (
creatoropts['outdir'], creatoropts['release'],
creatoropts['name'])
# try to find the pkgmgr
pkgmgr = None
backends = pluginmgr.get_plugins('backend')
if 'auto' == creatoropts['pkgmgr']:
for key in configmgr.prefer_backends:
if key in backends:
pkgmgr = backends[key]
break
else:
for key in backends.keys():
if key == creatoropts['pkgmgr']:
pkgmgr = backends[key]
break
if not pkgmgr:
raise errors.CreatorError(
"Can't find backend: %s, "
"available choices: %s" %
(creatoropts['pkgmgr'], ','.join(backends.keys())))
creator = fs.FsImageCreator(creatoropts, pkgmgr)
creator._include_src = opts.include_src
if len(recording_pkgs) > 0:
creator._recording_pkgs = recording_pkgs
self.check_image_exists(creator.destdir, creator.pack_to,
[creator.name], creatoropts['release'])
try:
creator.check_depend_tools()
creator.mount(None, creatoropts["cachedir"])
creator.install()
#Download the source packages ###private options
if opts.include_src:
installed_pkgs = creator.get_installed_packages()
msger.info(
'--------------------------------------------------')
msger.info(
'Generating the image with source rpms included ...')
if not misc.SrcpkgsDownload(
installed_pkgs, creatoropts["repomd"],
creator._instroot, creatoropts["cachedir"]):
msger.warning("Source packages can't be downloaded")
creator.configure(creatoropts["repomd"])
creator.copy_kernel()
creator.unmount()
creator.package(creatoropts["outdir"])
if creatoropts['release'] is not None:
creator.release_output(ksconf, creatoropts['outdir'],
creatoropts['release'])
creator.print_outimage_info()
except errors.CreatorError:
raise
finally:
creator.cleanup()
msger.info("Finished.")
return 0
def main(parser, args, argv):
"""mic create entry point."""
#args is argparser namespace, argv is the input cmd line
if args is None:
raise errors.Usage("Invalid arguments")
if not os.path.exists(args.ksfile):
raise errors.CreatorError("Can't find the file: %s" % args.ksfile)
if os.geteuid() != 0:
msger.error("Root permission is required, abort")
try:
w = pwd.getpwuid(os.geteuid())
except KeyError:
msger.warning("Might fail in compressing stage for undetermined user")
abspath = lambda pth: os.path.abspath(os.path.expanduser(pth))
if args.logfile:
logfile_abs_path = abspath(args.logfile)
if os.path.isdir(logfile_abs_path):
raise errors.Usage("logfile's path %s should be file" %
args.logfile)
configmgr.create['logfile'] = logfile_abs_path
configmgr.set_logfile()
if args.subcommand == "auto":
do_auto(parser, args.ksfile, argv)
return
if args.interactive:
msger.enable_interactive()
else:
msger.disable_interactive()
if args.verbose:
msger.set_loglevel('VERBOSE')
if args.debug:
try:
import rpm
rpm.setVerbosity(rpm.RPMLOG_NOTICE)
except ImportError:
pass
msger.set_loglevel('DEBUG')
#check the imager type
createrClass = None
for subcmd, klass in pluginmgr.get_plugins('imager').iteritems():
if subcmd == args.subcommand and hasattr(klass, 'do_create'):
createrClass = klass
if createrClass is None:
raise errors.CreatorError("Can't support subcommand %s" %
args.subcommand)
if args.config:
configmgr.reset()
configmgr._siteconf = args.config
if args.outdir is not None:
configmgr.create['outdir'] = abspath(args.outdir)
if args.cachedir is not None:
configmgr.create['cachedir'] = abspath(args.cachedir)
os.environ['ZYPP_LOCKFILE_ROOT'] = configmgr.create['cachedir']
for cdir in ('outdir', 'cachedir'):
if os.path.exists(configmgr.create[cdir]) \
and not os.path.isdir(configmgr.create[cdir]):
raise errors.Usage('Invalid directory specified: %s' \
% configmgr.create[cdir])
if not os.path.exists(configmgr.create[cdir]):
os.makedirs(configmgr.create[cdir])
if os.getenv('SUDO_UID', '') and os.getenv('SUDO_GID', ''):
os.chown(configmgr.create[cdir], int(os.getenv('SUDO_UID')),
int(os.getenv('SUDO_GID')))
if args.local_pkgs_path is not None:
if not os.path.exists(args.local_pkgs_path):
raise errors.Usage('Local pkgs directory: \'%s\' not exist' \
% args.local_pkgs_path)
configmgr.create['local_pkgs_path'] = args.local_pkgs_path
if args.release:
configmgr.create['release'] = args.release.rstrip('/')
if args.record_pkgs:
configmgr.create['record_pkgs'] = []
for infotype in args.record_pkgs.split(','):
if infotype not in ('name', 'content', 'license', 'vcs'):
raise errors.Usage('Invalid pkg recording: %s, valid ones:'
' "name", "content", "license", "vcs"' \
% infotype)
configmgr.create['record_pkgs'].append(infotype)
if args.strict_mode:
configmgr.create['strict_mode'] = args.strict_mode
if args.arch is not None:
supported_arch = sorted(rpmmisc.archPolicies.keys(), reverse=True)
if args.arch in supported_arch:
configmgr.create['arch'] = args.arch
else:
raise errors.Usage('Invalid architecture: "%s".\n'
' Supported architectures are: \n'
' %s' % (args.arch, ', '.join(supported_arch)))
if args.pkgmgr is not None:
configmgr.create['pkgmgr'] = args.pkgmgr
if args.runtime:
configmgr.set_runtime(args.runtime)
if args.pack_to is not None:
configmgr.create['pack_to'] = args.pack_to
if args.copy_kernel:
configmgr.create['copy_kernel'] = args.copy_kernel
if args.install_pkgs:
configmgr.create['install_pkgs'] = []
for pkgtype in args.install_pkgs.split(','):
if pkgtype not in ('source', 'debuginfo', 'debugsource'):
raise errors.Usage('Invalid parameter specified: "%s", '
'valid values: source, debuginfo, '
'debusource' % pkgtype)
configmgr.create['install_pkgs'].append(pkgtype)
if args.check_pkgs:
for pkg in args.check_pkgs.split(','):
configmgr.create['check_pkgs'].append(pkg)
if args.enabletmpfs:
configmgr.create['enabletmpfs'] = args.enabletmpfs
if args.repourl:
for item in args.repourl:
try:
key, val = item.split('=')
except:
continue
configmgr.create['repourl'][key] = val
if args.repo:
for optvalue in args.repo:
repo = {}
for item in optvalue.split(';'):
try:
key, val = item.split('=')
except:
continue
repo[key.strip()] = val.strip()
if 'name' in repo:
configmgr.create['extrarepos'][repo['name']] = repo
if args.ignore_ksrepo:
configmgr.create['ignore_ksrepo'] = args.ignore_ksrepo
if args.run_script:
configmgr.create['run_script'] = args.run_script
if args.tpk_install:
configmgr.create['tpk_install'] = args.tpk_install
creater = createrClass()
creater.do_create(args)
def do_create(self, subcmd, opts, *args):
"""${cmd_name}: create raw image
Usage:
${name} ${cmd_name} <ksfile> [OPTS]
${cmd_option_list}
"""
if not args:
raise errors.Usage("need one argument as the path of ks file")
if len(args) != 1:
raise errors.Usage("Extra arguments given")
creatoropts = configmgr.create
ksconf = args[0]
if not os.path.exists(ksconf):
raise errors.CreatorError("Can't find the file: %s" % ksconf)
recording_pkgs = []
if len(creatoropts['record_pkgs']) > 0:
recording_pkgs = creatoropts['record_pkgs']
if creatoropts['release'] is not None:
if 'name' not in recording_pkgs:
recording_pkgs.append('name')
ksconf = misc.save_ksconf_file(ksconf, creatoropts['release'])
configmgr._ksconf = ksconf
# Called After setting the configmgr._ksconf as the creatoropts['name'] is reset there.
if creatoropts['release'] is not None:
creatoropts['outdir'] = "%s/%s/images/%s/" % (
creatoropts['outdir'], creatoropts['release'],
creatoropts['name'])
# try to find the pkgmgr
pkgmgr = None
for (key, pcls) in pluginmgr.get_plugins('backend').iteritems():
if key == creatoropts['pkgmgr']:
pkgmgr = pcls
break
if not pkgmgr:
pkgmgrs = pluginmgr.get_plugins('backend').keys()
raise errors.CreatorError(
"Can't find package manager: %s (availables: %s)" %
(creatoropts['pkgmgr'], ', '.join(pkgmgrs)))
if creatoropts['runtime']:
rt_util.runmic_in_runtime(creatoropts['runtime'], creatoropts,
ksconf, None)
creator = raw.RawImageCreator(creatoropts, pkgmgr)
if len(recording_pkgs) > 0:
creator._recording_pkgs = recording_pkgs
if creatoropts['release'] is None:
for item in creator.get_diskinfo():
imagefile = "%s-%s.raw" % (os.path.join(
creator.destdir, creator.name), item['name'])
if os.path.exists(imagefile):
if msger.ask(
'The target image: %s already exists, cleanup and continue?'
% imagefile):
os.unlink(imagefile)
else:
raise errors.Abort('Canceled')
try:
creator.check_depend_tools()
creator.mount(None, creatoropts["cachedir"])
creator.install()
creator.configure(creatoropts["repomd"])
creator.unmount()
creator.package(creatoropts["outdir"])
if creatoropts['release'] is not None:
creator.release_output(ksconf, creatoropts['outdir'],
creatoropts['release'])
creator.print_outimage_info()
except errors.CreatorError:
raise
finally:
creator.cleanup()
msger.info("Finished.")
return 0
def do_create(self, args):
"""${cmd_name}: create fs image
Usage:
${name} ${cmd_name} <ksfile> [OPTS]
${cmd_option_list}
"""
if args is None:
raise errors.Usage("Invalid arguments.")
creatoropts = configmgr.create
ksconf = args.ksfile
if creatoropts['runtime'] == 'bootstrap':
configmgr._ksconf = ksconf
rt_util.bootstrap_mic()
recording_pkgs = []
if len(creatoropts['record_pkgs']) > 0:
recording_pkgs = creatoropts['record_pkgs']
if creatoropts['release'] is not None:
if 'name' not in recording_pkgs:
recording_pkgs.append('name')
if 'vcs' not in recording_pkgs:
recording_pkgs.append('vcs')
configmgr._ksconf = ksconf
# try to find the pkgmgr
pkgmgr = None
backends = pluginmgr.get_plugins('backend')
if 'auto' == creatoropts['pkgmgr']:
for key in configmgr.prefer_backends:
if key in backends:
pkgmgr = backends[key]
break
else:
for key in backends.keys():
if key == creatoropts['pkgmgr']:
pkgmgr = backends[key]
break
if not pkgmgr:
raise errors.CreatorError("Can't find backend: %s, "
"available choices: %s" %
(creatoropts['pkgmgr'],
','.join(backends.keys())))
creator = fs.FsImageCreator(creatoropts, pkgmgr)
creator._include_src = args.include_src
if len(recording_pkgs) > 0:
creator._recording_pkgs = recording_pkgs
self.check_image_exists(creator.destdir,
creator.pack_to,
[creator.name],
creatoropts['release'])
try:
creator.check_depend_tools()
creator.mount(None, creatoropts["cachedir"])
creator.install()
#Download the source packages ###private options
if args.include_src:
installed_pkgs = creator.get_installed_packages()
msger.info('--------------------------------------------------')
msger.info('Generating the image with source rpms included ...')
if not misc.SrcpkgsDownload(installed_pkgs, creatoropts["repomd"],
creator._instroot, creatoropts["cachedir"]):
msger.warning("Source packages can't be downloaded")
creator.configure(creatoropts["repomd"])
creator.copy_kernel()
creator.unmount()
creator.package(creatoropts["destdir"])
creator.create_manifest()
if creatoropts['release'] is not None:
creator.release_output(ksconf, creatoropts['destdir'],
creatoropts['release'])
creator.print_outimage_info()
except errors.CreatorError:
raise
finally:
creator.cleanup()
msger.info("Finished.")
return 0
