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 postoptparse(self):
if self.options.verbose:
msger.set_loglevel('verbose')
if self.options.debug:
msger.set_loglevel('debug')
if self.options.logfile:
msger.set_interactive(False)
msger.set_logfile(self.options.logfile)
configmgr.create['logfile'] = self.options.logfile
if self.options.config:
configmgr.reset()
configmgr._siteconf = self.options.config
if self.options.outdir is not None:
configmgr.create['outdir'] = self.options.outdir
if self.options.cachedir is not None:
configmgr.create['cachedir'] = self.options.cachedir
os.environ['ZYPP_LOCKFILE_ROOT'] = configmgr.create['cachedir']
if self.options.local_pkgs_path is not None:
if not os.path.exists(self.options.local_pkgs_path):
msger.error('Local pkgs directory: \'%s\' not exist' \
% self.options.local_pkgs_path)
configmgr.create['local_pkgs_path'] = self.options.local_pkgs_path
if self.options.release:
configmgr.create['release'] = self.options.release
if self.options.record_pkgs:
configmgr.create['record_pkgs'] = []
for infotype in self.options.record_pkgs.split(','):
if infotype not in ('name', 'content', 'license'):
raise errors.Usage('Invalid pkg recording: %s, valid ones:'
' "name", "content", "license"' \
% infotype)
configmgr.create['record_pkgs'].append(infotype)
if self.options.arch is not None:
supported_arch = sorted(rpmmisc.archPolicies.keys(), reverse=True)
if self.options.arch in supported_arch:
configmgr.create['arch'] = self.options.arch
else:
raise errors.Usage(
'Invalid architecture: "%s".\n'
' Supported architectures are: \n'
' %s\n' % (self.options.arch, ', '.join(supported_arch)))
if self.options.pkgmgr is not None:
configmgr.create['pkgmgr'] = self.options.pkgmgr
if self.options.runtime:
configmgr.create['runtime'] = self.options.runtime
if self.options.compress_disk_image is not None:
configmgr.create['compress_disk_image'] = \
self.options.compress_disk_image
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 do_auto(self, subcmd, opts, *args):
"""${cmd_name}: auto detect image type from magic header
Usage:
${name} ${cmd_name} <ksfile>
${cmd_option_list}
"""
def parse_magic_line(re_str, pstr, ptype='mic'):
ptn = re.compile(re_str)
m = ptn.match(pstr)
if not m or not m.groups():
return None
inline_argv = m.group(1).strip()
if ptype == 'mic':
m2 = re.search('(?P<format>\w+)', inline_argv)
elif ptype == 'mic2':
m2 = re.search('(-f|--format(=)?)\s*(?P<format>\w+)',
inline_argv)
else:
return None
if m2:
cmdname = m2.group('format')
inline_argv = inline_argv.replace(m2.group(0), '')
return (cmdname, inline_argv)
return None
if not args:
self.do_help(['help', subcmd])
return None
if len(args) != 1:
raise errors.Usage("Extra arguments given")
if not os.path.exists(args[0]):
raise errors.CreatorError("Can't find the file: %s" % args[0])
with open(args[0], 'r') as rf:
first_line = rf.readline()
mic_re = '^#\s*-\*-mic-options-\*-\s+(.*)\s+-\*-mic-options-\*-'
mic2_re = '^#\s*-\*-mic2-options-\*-\s+(.*)\s+-\*-mic2-options-\*-'
result = parse_magic_line(mic_re, first_line, 'mic') \
or parse_magic_line(mic2_re, first_line, 'mic2')
if not result:
raise errors.KsError("Invalid magic line in file: %s" % args[0])
if result[0] not in self._subcmds:
raise errors.KsError("Unsupport format '%s' in %s" %
(result[0], args[0]))
argv = ' '.join(result + args).split()
self.main(argv)
def main(self, argv=None):
if argv is None:
argv = sys.argv
else:
argv = argv[:] # don't modify caller's list
self.optparser = self.get_optparser()
if self.optparser:
try:
argv = self.preoptparse(argv)
self.options, args = self.optparser.parse_args(argv)
except cmdln.CmdlnUserError, ex:
msg = "%s: %s\nTry '%s help' for info.\n"\
% (self.name, ex, self.name)
raise errors.Usage(msg)
except cmdln.StopOptionProcessing, ex:
return 0
def do_create(self, subcmd, opts, *args):
"""
Create direct image, called from creator as 'direct' cmd
"""
if len(args) != 9:
raise errors.Usage("Extra arguments given")
staging_data_dir = args[0]
hdddir = args[1]
native_sysroot = args[2]
kernel_dir = args[3]
bootimg_dir = args[4]
rootfs_dir = args[5]
creatoropts = configmgr.create
ksconf = args[6]
image_output_dir = args[7]
oe_builddir = args[8]
krootfs_dir = self.__rootfs_dir_to_dict(rootfs_dir)
configmgr._ksconf = ksconf
creator = direct.DirectImageCreator(oe_builddir, image_output_dir,
krootfs_dir, bootimg_dir,
kernel_dir, native_sysroot, hdddir,
staging_data_dir, creatoropts,
None, None, None)
try:
creator.mount(None, creatoropts["cachedir"])
creator.install()
creator.configure(creatoropts["repomd"])
creator.print_outimage_info()
except errors.CreatorError:
raise
finally:
creator.cleanup()
return 0
def preoptparse(self, argv):
optparser = self.get_optparser()
largs = []
rargs = []
while argv:
arg = argv.pop(0)
if arg in ('-h', '--help'):
rargs.append(arg)
elif optparser.has_option(arg):
largs.append(arg)
if optparser.get_option(arg).takes_value():
try:
largs.append(argv.pop(0))
except IndexError:
raise errors.Usage("option %s requires arguments" %
arg)
else:
if arg.startswith("--"):
if "=" in arg:
opt = arg.split("=")[0]
else:
opt = None
elif arg.startswith("-") and len(arg) > 2:
opt = arg[0:2]
else:
opt = None
if opt and optparser.has_option(opt):
largs.append(arg)
else:
rargs.append(arg)
return largs + rargs
def postoptparse(self):
abspath = lambda pth: os.path.abspath(os.path.expanduser(pth))
if self.options.verbose:
msger.set_loglevel('verbose')
if self.options.debug:
msger.set_loglevel('debug')
if self.options.logfile:
logfile_abs_path = abspath(self.options.logfile)
if os.path.isdir(logfile_abs_path):
raise errors.Usage("logfile's path %s should be file"
% self.options.logfile)
if not os.path.exists(os.path.dirname(logfile_abs_path)):
os.makedirs(os.path.dirname(logfile_abs_path))
msger.set_interactive(False)
msger.set_logfile(logfile_abs_path)
configmgr.create['logfile'] = self.options.logfile
if self.options.config:
configmgr.reset()
configmgr._siteconf = self.options.config
if self.options.outdir is not None:
configmgr.create['outdir'] = abspath(self.options.outdir)
if self.options.cachedir is not None:
configmgr.create['cachedir'] = abspath(self.options.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]):
msger.error('Invalid directory specified: %s' \
% configmgr.create[cdir])
if self.options.local_pkgs_path is not None:
if not os.path.exists(self.options.local_pkgs_path):
msger.error('Local pkgs directory: \'%s\' not exist' \
% self.options.local_pkgs_path)
configmgr.create['local_pkgs_path'] = self.options.local_pkgs_path
if self.options.release:
configmgr.create['release'] = self.options.release.rstrip('/')
if self.options.record_pkgs:
configmgr.create['record_pkgs'] = []
for infotype in self.options.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 self.options.arch is not None:
supported_arch = sorted(rpmmisc.archPolicies.keys(), reverse=True)
if self.options.arch in supported_arch:
configmgr.create['arch'] = self.options.arch
else:
raise errors.Usage('Invalid architecture: "%s".\n'
' Supported architectures are: \n'
' %s' % (self.options.arch,
', '.join(supported_arch)))
if self.options.pkgmgr is not None:
configmgr.create['pkgmgr'] = self.options.pkgmgr
if self.options.runtime:
configmgr.set_runtime(self.options.runtime)
if self.options.pack_to is not None:
configmgr.create['pack_to'] = self.options.pack_to
if self.options.copy_kernel:
configmgr.create['copy_kernel'] = self.options.copy_kernel
if self.options.install_pkgs:
configmgr.create['install_pkgs'] = []
for pkgtype in self.options.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 self.options.enabletmpfs:
configmgr.create['enabletmpfs'] = self.options.enabletmpfs
if self.options.repourl:
for item in self.options.repourl:
try:
key, val = item.split('=')
except:
continue
configmgr.create['repourl'][key] = val
def do_create(self, args):
"""${cmd_name}: create loop 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 = LoopImageCreator(creatoropts, pkgmgr, args.compress_image,
args.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.create_cpio_image()
creator.unmount()
creator.copy_cpio_image()
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 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 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 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, 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()
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 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 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, 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