def savefs_before_chroot(chrootdir, saveto = None):
""" backup chrootdir to another directory before chrooting in """
if configmgr.chroot['saveto']:
savefs = True
saveto = configmgr.chroot['saveto']
wrnmsg = "Can't save chroot fs for dir %s exists" % saveto
if saveto == chrootdir:
savefs = False
wrnmsg = "Dir %s is being used to chroot" % saveto
elif os.path.exists(saveto):
if msger.ask("Dir %s already exists, cleanup and continue?" %
saveto):
shutil.rmtree(saveto, ignore_errors = True)
savefs = True
else:
savefs = False
if savefs:
msger.info("Saving image to directory %s" % saveto)
fs_related.makedirs(os.path.dirname(os.path.abspath(saveto)))
runner.quiet("cp -af %s %s" % (chrootdir, saveto))
devs = ['dev/fd',
'dev/stdin',
'dev/stdout',
'dev/stderr',
'etc/mtab']
ignlst = [os.path.join(saveto, x) for x in devs]
map(os.unlink, filter(os.path.exists, ignlst))
else:
msger.warning(wrnmsg)
def check_image_exists(self, destdir, apacking=None,
images=(),
release=None):
# if it's a packing file, reset images
if apacking:
images = [apacking]
# release option will override images
if release is not None:
images = [os.path.basename(destdir.rstrip('/'))]
destdir = os.path.dirname(destdir.rstrip('/'))
for name in images:
if not name:
continue
image = os.path.join(destdir, name)
if not os.path.exists(image):
continue
if msger.ask("Target image/dir: %s already exists, "
"clean up and continue?" % image):
if os.path.isdir(image):
shutil.rmtree(image)
else:
os.unlink(image)
else:
raise errors.Abort("Canceled")
def check_image_exists(self, destdir, apacking=None,
images=(),
release=None):
# if it's a packing file, reset images
if apacking:
images = [apacking]
# release option will override images
if release is not None:
images = [os.path.basename(destdir.rstrip('/'))]
destdir = os.path.dirname(destdir.rstrip('/'))
for name in images:
if not name:
continue
image = os.path.join(destdir, name)
if not os.path.exists(image):
continue
if msger.ask("Target image/dir: %s already exists, "
"clean up the old files and continue?" % image):
if os.path.isdir(image):
for path, dirs, files in os.walk(os.path.abspath(image)):
for fname in files:
fpath = os.path.join(path, fname)
if not fpath.endswith('.log'):
os.remove(fpath)
else:
os.unlink(image)
else:
raise errors.Abort("Canceled")
def bootstrap_mic(argv=None):
def mychroot():
os.chroot(rootdir)
os.chdir(cwd)
# by default, sys.argv is used to run mic in bootstrap
if not argv:
argv = sys.argv
if argv[0] not in ('/usr/bin/mic', 'mic'):
argv[0] = '/usr/bin/mic'
cropts = configmgr.create
bsopts = configmgr.bootstrap
distro = bsopts['distro_name'].lower()
rootdir = bsopts['rootdir']
pkglist = bsopts['packages']
cwd = os.getcwd()
# create bootstrap and run mic in bootstrap
bsenv = bootstrap.Bootstrap(rootdir, distro, cropts['arch'])
bsenv.logfile = cropts['logfile']
# rootdir is regenerated as a temp dir
rootdir = bsenv.rootdir
if 'optional' in bsopts:
optlist = bsopts['optional']
else:
optlist = []
try:
msger.info("Creating %s bootstrap ..." % distro)
bsenv.create(cropts['repomd'], pkglist, optlist)
# bootstrap is relocated under "bootstrap"
if os.path.exists(os.path.join(rootdir, "bootstrap")):
rootdir = os.path.join(rootdir, "bootstrap")
bsenv.dirsetup(rootdir)
sync_mic(rootdir)
#FIXME: sync the ks file to bootstrap
if "/" == os.path.dirname(os.path.abspath(configmgr._ksconf)):
safecopy(configmgr._ksconf, rootdir)
msger.info("Start mic in bootstrap: %s\n" % rootdir)
bindmounts = get_bindmounts(cropts)
ret = bsenv.run(argv, cwd, rootdir, bindmounts)
except errors.BootstrapError, err:
msger.warning('\n%s' % err)
if msger.ask("Switch to native mode and continue?"):
return
else:
raise errors.BootstrapError("Failed to create bootstrap: %s" % err)
def read_kickstart(path):
"""Parse a kickstart file and return a KickstartParser instance.
This is a simple utility function which takes a path to a kickstart file,
parses it and returns a pykickstart KickstartParser instance which can
be then passed to an ImageCreator constructor.
If an error occurs, a CreatorError exception is thrown.
"""
#version = ksversion.makeVersion()
#ks = ksparser.KickstartParser(version)
using_version = ksversion.DEVEL
commandMap[using_version]["desktop"] = desktop.Moblin_Desktop
commandMap[using_version]["repo"] = moblinrepo.Moblin_Repo
commandMap[using_version]["bootloader"] = micboot.Moblin_Bootloader
commandMap[using_version]["part"] = partition.MeeGo_Partition
commandMap[using_version]["partition"] = partition.MeeGo_Partition
commandMap[using_version]["btrfs"] = btrfs.BTRFS
dataMap[using_version]["RepoData"] = moblinrepo.Moblin_RepoData
dataMap[using_version]["PartData"] = partition.MeeGo_PartData
dataMap[using_version]["BTRFSData"] = btrfs.BTRFSData
superclass = ksversion.returnClassForVersion(version=using_version)
class KSHandlers(superclass):
def __init__(self, mapping={}):
superclass.__init__(self, mapping=commandMap[using_version])
self.prepackages = PrePackages()
self.attachment = Attachment()
def __str__(self):
retval = superclass.__str__(self)
if self.prepackages:
retval += self.prepackages.__str__()
if self.attachment:
retval += self.attachment.__str__()
return retval
ks = ksparser.KickstartParser(KSHandlers(), errorsAreFatal=False)
ks.registerSection(PackScriptSection(ks.handler, dataObj=PackScript))
ks.registerSection(PrepackageSection(ks.handler))
ks.registerSection(AttachmentSection(ks.handler))
try:
ks.readKickstart(path)
except (kserrors.KickstartParseError, kserrors.KickstartError) as err:
if msger.ask("Errors occured on kickstart file, skip and continue?"):
msger.warning("%s" % err)
pass
else:
raise errors.KsError("%s" % err)
return ks
def bootstrap_mic(argv=None):
def mychroot():
os.chroot(rootdir)
os.chdir(cwd)
# by default, sys.argv is used to run mic in bootstrap
if not argv:
argv = sys.argv
if argv[0] not in ('/usr/bin/mic', 'mic'):
argv[0] = '/usr/bin/mic'
cropts = configmgr.create
bsopts = configmgr.bootstrap
distro = bsopts['distro_name'].lower()
rootdir = bsopts['rootdir']
pkglist = bsopts['packages']
cwd = os.getcwd()
# create bootstrap and run mic in bootstrap
bsenv = bootstrap.Bootstrap(rootdir, distro, cropts['arch'])
bsenv.logfile = cropts['logfile']
# rootdir is regenerated as a temp dir
rootdir = bsenv.rootdir
if 'optional' in bsopts:
optlist = bsopts['optional']
else:
optlist = []
try:
msger.info("Creating %s bootstrap ..." % distro)
bsenv.create(cropts['repomd'], pkglist, optlist)
# bootstrap is relocated under "bootstrap"
if os.path.exists(os.path.join(rootdir, "bootstrap")):
rootdir = os.path.join(rootdir, "bootstrap")
bsenv.dirsetup(rootdir)
sync_mic(rootdir)
#FIXME: sync the ks file to bootstrap
if "/" == os.path.dirname(os.path.abspath(configmgr._ksconf)):
safecopy(configmgr._ksconf, rootdir)
msger.info("Start mic in bootstrap: %s\n" % rootdir)
bindmounts = get_bindmounts(cropts)
ret = bsenv.run(argv, cwd, rootdir, bindmounts)
except errors.BootstrapError, err:
msger.warning('\n%s' % err)
if msger.ask("Switch to native mode and continue?"):
return
raise
def wrapper(*kargs, **kwargs):
try:
func(*kargs, **kwargs)
except (OSError, IOError, errors.KsError) as err:
cfgcls = kargs[0].__class__.__name__
if msger.ask("Failed to apply %s, skip and continue?" % cfgcls):
msger.warning("%s" % err)
pass
else:
# just throw out the exception
raise
def wrapper(*kargs, **kwargs):
try:
func(*kargs, **kwargs)
except (OSError, IOError, errors.KsError), err:
cfgcls = kargs[0].__class__.__name__
if msger.ask("Failed to apply %s, skip and continue?" % cfgcls):
msger.warning("%s" % err)
pass
else:
# just throw out the exception
raise
def read_kickstart(path):
"""Parse a kickstart file and return a KickstartParser instance.
This is a simple utility function which takes a path to a kickstart file,
parses it and returns a pykickstart KickstartParser instance which can
be then passed to an ImageCreator constructor.
If an error occurs, a CreatorError exception is thrown.
"""
#version = ksversion.makeVersion()
#ks = ksparser.KickstartParser(version)
using_version = ksversion.DEVEL
commandMap[using_version]["desktop"] = desktop.Mic_Desktop
commandMap[using_version]["repo"] = micrepo.Mic_Repo
commandMap[using_version]["tpk_repo"] = micrepo.Mic_Tpk_Repo
commandMap[using_version]["bootloader"] = micboot.Mic_Bootloader
commandMap[using_version]["part"] = partition.Mic_Partition
commandMap[using_version]["partition"] = partition.Mic_Partition
commandMap[using_version][
"installerfw_plugins"] = installerfw.Mic_installerfw
dataMap[using_version]["RepoData"] = micrepo.Mic_RepoData
dataMap[using_version]["Tpk_RepoData"] = micrepo.Mic_Tpk_RepoData
dataMap[using_version]["PartData"] = partition.Mic_PartData
superclass = ksversion.returnClassForVersion(version=using_version)
class KSHandlers(superclass):
def __init__(self):
superclass.__init__(self, mapping=commandMap[using_version])
self.prepackages = ksparser.Packages()
self.attachment = ksparser.Packages()
ks = ksparser.KickstartParser(KSHandlers(), errorsAreFatal=False)
ks.registerSection(PrepackageSection(ks.handler))
ks.registerSection(AttachmentSection(ks.handler))
try:
ks.readKickstart(path)
except (kserrors.KickstartParseError, kserrors.KickstartError), err:
if msger.ask("Errors occured on kickstart file, skip and continue?"):
msger.warning("%s" % err)
pass
else:
raise errors.KsError("%s" % err)
def read_kickstart(path):
"""Parse a kickstart file and return a KickstartParser instance.
This is a simple utility function which takes a path to a kickstart file,
parses it and returns a pykickstart KickstartParser instance which can
be then passed to an ImageCreator constructor.
If an error occurs, a CreatorError exception is thrown.
"""
#version = ksversion.makeVersion()
#ks = ksparser.KickstartParser(version)
using_version = ksversion.DEVEL
commandMap[using_version]["desktop"] = desktop.Mic_Desktop
commandMap[using_version]["repo"] = micrepo.Mic_Repo
commandMap[using_version]["bootloader"] = micboot.Mic_Bootloader
commandMap[using_version]["part"] = partition.Mic_Partition
commandMap[using_version]["partition"] = partition.Mic_Partition
commandMap[using_version]["installerfw_plugins"] = installerfw.Mic_installerfw
dataMap[using_version]["RepoData"] = micrepo.Mic_RepoData
dataMap[using_version]["PartData"] = partition.Mic_PartData
superclass = ksversion.returnClassForVersion(version=using_version)
class KSHandlers(superclass):
def __init__(self):
superclass.__init__(self, mapping=commandMap[using_version])
self.prepackages = ksparser.Packages()
self.attachment = ksparser.Packages()
ks = ksparser.KickstartParser(KSHandlers(), errorsAreFatal=False)
ks.registerSection(PrepackageSection(ks.handler))
ks.registerSection(AttachmentSection(ks.handler))
try:
ks.readKickstart(path)
except (kserrors.KickstartParseError, kserrors.KickstartError), err:
if msger.ask("Errors occured on kickstart file, skip and continue?"):
msger.warning("%s" % err)
pass
else:
raise errors.KsError("%s" % err)
def checkRepositoryEULA(name, repo):
""" This function is to check the EULA file if provided.
return True: no EULA or accepted
return False: user declined the EULA
"""
proxies = {}
proxy = repo.proxy
if proxy:
proxy_username = repo.proxy_username
proxy_password = repo.proxy_password
if proxy_username:
proxy_netloc = urlparse.urlsplit(proxy).netloc
if proxy_password:
proxy = 'http://%s:%s@%s' % (proxy_username, proxy_password, proxy_netloc)
else:
proxy = 'http://%s@%s' % (proxy_username, proxy_netloc)
else:
proxy = get_proxy_for(repo.baseurl[0])
if proxy:
proxies = {str(repo.baseurl[0].split(':')[0]): str(proxy)}
# download all remote files to one temp dir
baseurl = None
repo_lic_dir = tempfile.mkdtemp(prefix = 'repolic')
for url in repo.baseurl:
# try to download
repo_eula_url = urlparse.urljoin(url, "LICENSE.txt")
repo_eula_path = myurlgrab(repo_eula_url,
os.path.join(repo_lic_dir, repo.id + '_LICENSE.txt'),
proxies, ignore_404 = True)
if repo_eula_path:
# found
baseurl = url
break
if not baseurl:
shutil.rmtree(repo_lic_dir) #cleanup
return True
# show the license file
msger.info('For the software packages in this yum repo:')
msger.info(' %s: %s' % (name, baseurl))
msger.info('There is an "End User License Agreement" file that need to be checked.')
msger.info('Please read the terms and conditions outlined in it and answer the followed qustions.')
msger.pause()
_pager_file(repo_eula_path)
# Asking for the "Accept/Decline"
if not msger.ask('Would you agree to the terms and conditions outlined in the above End User License Agreement?'):
msger.warning('Will not install pkgs from this repo.')
shutil.rmtree(repo_lic_dir) #cleanup
return False
# try to find support_info.html for extra infomation
repo_info_url = urlparse.urljoin(baseurl, "support_info.html")
repo_info_path = myurlgrab(repo_eula_url,
os.path.join(repo_lic_dir, repo.id + '_LICENSE.txt'),
proxies, ignore_404 = True)
if repo_info_path:
msger.info('There is one more file in the repo for additional support information, please read it')
msger.pause()
_pager_file(repo_info_path)
#cleanup
shutil.rmtree(repo_lic_dir)
return True
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 chroot(chrootdir, bindmounts = None, execute = "/bin/bash"):
def mychroot():
os.chroot(chrootdir)
os.chdir("/")
if configmgr.chroot['saveto']:
savefs = True
saveto = configmgr.chroot['saveto']
wrnmsg = "Can't save chroot fs for dir %s exists" % saveto
if saveto == chrootdir:
savefs = False
wrnmsg = "Dir %s is being used to chroot" % saveto
elif os.path.exists(saveto):
if msger.ask("Dir %s already exists, cleanup and continue?" %
saveto):
shutil.rmtree(saveto, ignore_errors = True)
savefs = True
else:
savefs = False
if savefs:
msger.info("Saving image to directory %s" % saveto)
fs_related.makedirs(os.path.dirname(os.path.abspath(saveto)))
runner.quiet("cp -af %s %s" % (chrootdir, saveto))
devs = ['dev/fd',
'dev/stdin',
'dev/stdout',
'dev/stderr',
'etc/mtab']
ignlst = [os.path.join(saveto, x) for x in devs]
map(os.unlink, filter(os.path.exists, ignlst))
else:
msger.warning(wrnmsg)
dev_null = os.open("/dev/null", os.O_WRONLY)
files_to_check = ["/bin/bash", "/sbin/init"]
architecture_found = False
""" Register statically-linked qemu-arm if it is an ARM fs """
qemu_emulator = None
for ftc in files_to_check:
ftc = "%s/%s" % (chrootdir,ftc)
# Return code of 'file' is "almost always" 0 based on some man pages
# so we need to check the file existance first.
if not os.path.exists(ftc):
continue
for line in runner.outs(['file', ftc]).splitlines():
if 'ARM' in line:
qemu_emulator = misc.setup_qemu_emulator(chrootdir, "arm")
architecture_found = True
break
if 'Intel' in line:
architecture_found = True
break
if architecture_found:
break
os.close(dev_null)
if not architecture_found:
raise errors.CreatorError("Failed to get architecture from any of the "
"following files %s from chroot." \
% files_to_check)
try:
msger.info("Launching shell. Exit to continue.\n"
"----------------------------------")
globalmounts = setup_chrootenv(chrootdir, bindmounts)
subprocess.call(execute, preexec_fn = mychroot, shell=True)
except OSError, err:
raise errors.CreatorError("chroot err: %s" % str(err))
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 livecd 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("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")
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 = livecd.LiveCDImageCreator(creatoropts, pkgmgr)
if len(recording_pkgs) > 0:
creator._recording_pkgs = recording_pkgs
if creatoropts["release"] is None:
imagefile = "%s.iso" % 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 __init__(self, createopts = None, pkgmgr = None):
"""Initialize an ImageCreator instance.
ks -- a pykickstart.KickstartParser instance; this instance will be
used to drive the install by e.g. providing the list of packages
to be installed, the system configuration and %post scripts
name -- a name for the image; used for e.g. image filenames or
filesystem labels
"""
self.pkgmgr = pkgmgr
self.__builddir = None
self.__bindmounts = []
self.ks = None
self.name = "target"
self.tmpdir = "/var/tmp/mic"
self.cachedir = "/var/tmp/mic/cache"
self.destdir = "."
self.target_arch = "noarch"
self._local_pkgs_path = None
# If the kernel is save to the destdir when copy_kernel cmd is called.
self._need_copy_kernel = False
# The compression method for disk image.
self._img_compression_method = None
if createopts:
# Mapping table for variables that have different names.
optmap = {"pkgmgr" : "pkgmgr_name",
"outdir" : "destdir",
"arch" : "target_arch",
"local_pkgs_path" : "_local_pkgs_path",
"compress_disk_image" : "_img_compression_method",
"copy_kernel" : "_need_copy_kernel",
}
# update setting from createopts
for key in createopts.keys():
if key in optmap:
option = optmap[key]
else:
option = key
setattr(self, option, createopts[key])
self.destdir = os.path.abspath(os.path.expanduser(self.destdir))
if 'release' in createopts and createopts['release']:
self.name += '-' + createopts['release']
if os.path.exists(self.destdir):
if msger.ask("Image dir: %s already exists, cleanup and" \
"continue?" % self.destdir):
shutil.rmtree(self.destdir, ignore_errors = True)
else:
raise Abort("Canceled")
# pending FEA: save log by default for --release
self._dep_checks = ["ls", "bash", "cp", "echo", "modprobe", "passwd"]
# Output image file names
self.outimage = []
# A flag to generate checksum
self._genchecksum = False
self._alt_initrd_name = None
self._recording_pkgs = []
# available size in root fs, init to 0
self._root_fs_avail = 0
# Name of the disk image file that is created.
self._img_name = None
self.image_format = None
# Save qemu emulator file name in order to clean up it finally
self.qemu_emulator = None
# No ks provided when called by convertor, so skip the dependency check
if self.ks:
# If we have btrfs partition we need to check that we have toosl for those
for part in self.ks.handler.partition.partitions:
if part.fstype and part.fstype == "btrfs":
self._dep_checks.append("mkfs.btrfs")
break
if self.target_arch and self.target_arch.startswith("arm"):
for dep in self._dep_checks:
if dep == "extlinux":
self._dep_checks.remove(dep)
if not os.path.exists("/usr/bin/qemu-arm") or \
not misc.is_statically_linked("/usr/bin/qemu-arm"):
self._dep_checks.append("qemu-arm-static")
if os.path.exists("/proc/sys/vm/vdso_enabled"):
vdso_fh = open("/proc/sys/vm/vdso_enabled","r")
vdso_value = vdso_fh.read().strip()
vdso_fh.close()
if (int)(vdso_value) == 1:
msger.warning("vdso is enabled on your host, which might "
"cause problems with arm emulations.\n"
"\tYou can disable vdso with following command before "
"starting image build:\n"
"\techo 0 | sudo tee /proc/sys/vm/vdso_enabled")
# make sure the specified tmpdir and cachedir exist
if not os.path.exists(self.tmpdir):
os.makedirs(self.tmpdir)
if not os.path.exists(self.cachedir):
os.makedirs(self.cachedir)
if self._img_compression_method != None and \
self._img_compression_method not in self.zips:
raise CreatorError("Given disk image compression method ('%s') is "
"not valid. Valid values are: %s." \
% (self._img_compression_method,
', '.join(self.zips.keys())))
def __init__(self, createopts=None, pkgmgr=None):
"""Initialize an ImageCreator instance.
ks -- a pykickstart.KickstartParser instance; this instance will be
used to drive the install by e.g. providing the list of packages
to be installed, the system configuration and %post scripts
name -- a name for the image; used for e.g. image filenames or
filesystem labels
"""
self.pkgmgr = pkgmgr
self.__builddir = None
self.__bindmounts = []
self.ks = None
self.name = "target"
self.tmpdir = "/var/tmp/mic"
self.cachedir = "/var/tmp/mic/cache"
self.destdir = "."
self.target_arch = "noarch"
self._local_pkgs_path = None
# If the kernel is save to the destdir when copy_kernel cmd is called.
self._need_copy_kernel = False
# The compression method for disk image.
self._img_compression_method = None
if createopts:
# Mapping table for variables that have different names.
optmap = {
"pkgmgr": "pkgmgr_name",
"outdir": "destdir",
"arch": "target_arch",
"local_pkgs_path": "_local_pkgs_path",
"compress_disk_image": "_img_compression_method",
"copy_kernel": "_need_copy_kernel",
}
# update setting from createopts
for key in createopts.keys():
if key in optmap:
option = optmap[key]
else:
option = key
setattr(self, option, createopts[key])
self.destdir = os.path.abspath(os.path.expanduser(self.destdir))
if 'release' in createopts and createopts['release']:
self.name += '-' + createopts['release']
if os.path.exists(self.destdir):
if msger.ask("Image dir: %s already exists, cleanup and" \
"continue?" % self.destdir):
shutil.rmtree(self.destdir, ignore_errors=True)
else:
raise Abort("Canceled")
# pending FEA: save log by default for --release
self._dep_checks = ["ls", "bash", "cp", "echo", "modprobe", "passwd"]
# Output image file names
self.outimage = []
# A flag to generate checksum
self._genchecksum = False
self._alt_initrd_name = None
self._recording_pkgs = []
# available size in root fs, init to 0
self._root_fs_avail = 0
# Name of the disk image file that is created.
self._img_name = None
self.image_format = None
# Save qemu emulator file name in order to clean up it finally
self.qemu_emulator = None
# No ks provided when called by convertor, so skip the dependency check
if self.ks:
# If we have btrfs partition we need to check that we have toosl for those
for part in self.ks.handler.partition.partitions:
if part.fstype and part.fstype == "btrfs":
self._dep_checks.append("mkfs.btrfs")
break
if self.target_arch and self.target_arch.startswith("arm"):
for dep in self._dep_checks:
if dep == "extlinux":
self._dep_checks.remove(dep)
if not os.path.exists("/usr/bin/qemu-arm") or \
not misc.is_statically_linked("/usr/bin/qemu-arm"):
self._dep_checks.append("qemu-arm-static")
if os.path.exists("/proc/sys/vm/vdso_enabled"):
vdso_fh = open("/proc/sys/vm/vdso_enabled", "r")
vdso_value = vdso_fh.read().strip()
vdso_fh.close()
if (int)(vdso_value) == 1:
msger.warning(
"vdso is enabled on your host, which might "
"cause problems with arm emulations.\n"
"\tYou can disable vdso with following command before "
"starting image build:\n"
"\techo 0 | sudo tee /proc/sys/vm/vdso_enabled")
# make sure the specified tmpdir and cachedir exist
if not os.path.exists(self.tmpdir):
os.makedirs(self.tmpdir)
if not os.path.exists(self.cachedir):
os.makedirs(self.cachedir)
if self._img_compression_method != None and \
self._img_compression_method not in self.zips:
raise CreatorError("Given disk image compression method ('%s') is "
"not valid. Valid values are: %s." \
% (self._img_compression_method,
', '.join(self.zips.keys())))
def checkRepositoryEULA(name, repo):
""" This function is to check the EULA file if provided.
return True: no EULA or accepted
return False: user declined the EULA
"""
proxies = {}
proxy = repo.proxy
if proxy:
proxy_username = repo.proxy_username
proxy_password = repo.proxy_password
if proxy_username:
proxy_netloc = urllib.parse.urlsplit(proxy).netloc
if proxy_password:
proxy = 'http://%s:%s@%s' % (proxy_username, proxy_password,
proxy_netloc)
else:
proxy = 'http://%s@%s' % (proxy_username, proxy_netloc)
else:
proxy = get_proxy_for(repo.baseurl[0])
if proxy:
proxies = {str(repo.baseurl[0].split(':')[0]): str(proxy)}
# download all remote files to one temp dir
baseurl = None
repo_lic_dir = tempfile.mkdtemp(prefix='repolic')
for url in repo.baseurl:
# try to download
repo_eula_url = urllib.parse.urljoin(url, "LICENSE.txt")
repo_eula_path = myurlgrab(repo_eula_url,
os.path.join(repo_lic_dir,
repo.id + '_LICENSE.txt'),
proxies,
ignore_404=True)
if repo_eula_path:
# found
baseurl = url
break
if not baseurl:
shutil.rmtree(repo_lic_dir) #cleanup
return True
# show the license file
msger.info('For the software packages in this yum repo:')
msger.info(' %s: %s' % (name, baseurl))
msger.info(
'There is an "End User License Agreement" file that need to be checked.'
)
msger.info(
'Please read the terms and conditions outlined in it and answer the followed qustions.'
)
msger.pause()
_pager_file(repo_eula_path)
# Asking for the "Accept/Decline"
if not msger.ask(
'Would you agree to the terms and conditions outlined in the above End User License Agreement?'
):
msger.warning('Will not install pkgs from this repo.')
shutil.rmtree(repo_lic_dir) #cleanup
return False
# try to find support_info.html for extra infomation
repo_info_url = urllib.parse.urljoin(baseurl, "support_info.html")
repo_info_path = myurlgrab(repo_eula_url,
os.path.join(repo_lic_dir,
repo.id + '_LICENSE.txt'),
proxies,
ignore_404=True)
if repo_info_path:
msger.info(
'There is one more file in the repo for additional support information, please read it'
)
msger.pause()
_pager_file(repo_info_path)
#cleanup
shutil.rmtree(repo_lic_dir)
return True
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"])
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, 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.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 = LoopImageCreator(creatoropts, pkgmgr, opts.compress_to)
if len(recording_pkgs) > 0:
creator._recording_pkgs = recording_pkgs
if creatoropts['release'] is None:
if opts.compress_to:
imagefile = "%s" % os.path.join(creator.destdir, creator.compress_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.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
${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
# show the license file
msger.info('For the software packages in this yum repo:')
msger.info(' %s: %s' % (name, baseurl))
msger.info(
'There is an "End User License Agreement" file that need to be checked.'
)
msger.info(
'Please read the terms and conditions outlined in it and answer the followed qustions.'
)
msger.pause()
_pager_file(repo_eula_path)
# Asking for the "Accept/Decline"
if not msger.ask(
'Would you agree to the terms and conditions outlined in the above End User License Agreement?'
):
msger.warning('Will not install pkgs from this repo.')
shutil.rmtree(repo_lic_dir) #cleanup
return False
# try to find support_info.html for extra infomation
repo_info_url = urlparse.urljoin(baseurl, "support_info.html")
repo_info_path = _check_and_download_url(
u2opener, repo_info_url,
os.path.join(repo_lic_dir, repo.id + '_support_info.html'))
if repo_info_path:
msger.info(
'There is one more file in the repo for additional support information, please read it'
)
msger.pause()
if not baseurl:
shutil.rmtree(repo_lic_dir) #cleanup
return True
# show the license file
msger.info('For the software packages in this yum repo:')
msger.info(' %s: %s' % (name, baseurl))
msger.info('There is an "End User License Agreement" file that need to be checked.')
msger.info('Please read the terms and conditions outlined in it and answer the followed qustions.')
msger.pause()
_pager_file(repo_eula_path)
# Asking for the "Accept/Decline"
if not msger.ask('Would you agree to the terms and conditions outlined in the above End User License Agreement?'):
msger.warning('Will not install pkgs from this repo.')
shutil.rmtree(repo_lic_dir) #cleanup
return False
# try to find support_info.html for extra infomation
repo_info_url = urlparse.urljoin(baseurl, "support_info.html")
repo_info_path = _check_and_download_url(
u2opener,
repo_info_url,
os.path.join(repo_lic_dir, repo.id + '_support_info.html'))
if repo_info_path:
msger.info('There is one more file in the repo for additional support information, please read it')
msger.pause()
_pager_file(repo_info_path)
def __init__(self, createopts=None, pkgmgr=None):
"""Initialize an ImageCreator instance.
ks -- a pykickstart.KickstartParser instance; this instance will be
used to drive the install by e.g. providing the list of packages
to be installed, the system configuration and %post scripts
name -- a name for the image; used for e.g. image filenames or
filesystem labels
"""
self.pkgmgr = pkgmgr
self.__builddir = None
self.__bindmounts = []
# Eeach image type can change these values as they might be image type
# specific
if not hasattr(self, "_valid_compression_methods"):
self._valid_compression_methods = ["bz2"]
# The compression method for disk image.
self._img_compression_method = None
if createopts:
# A pykickstart.KickstartParser instance."""
self.ks = createopts["ks"]
self.destdir = os.path.abspath(os.path.expanduser(createopts["outdir"]))
# A name for the image."""
self.name = createopts["name"]
if createopts["release"]:
self.name += "-" + createopts["release"]
# check whether destine dir exist
if os.path.exists(self.destdir):
if msger.ask("Image dir: %s already exists, cleanup and continue?" % self.destdir):
shutil.rmtree(self.destdir, ignore_errors=True)
else:
raise Abort("Canceled")
# pending FEA: save log by default for --release
# The directory in which all temporary files will be created."""
self.tmpdir = createopts["tmpdir"]
self.cachedir = createopts["cachedir"]
self.target_arch = createopts["arch"]
self._local_pkgs_path = createopts["local_pkgs_path"]
self._img_compression_method = createopts["compress_disk_image"]
else:
self.ks = None
self.name = "target"
self.tmpdir = "/var/tmp/mic"
self.cachedir = "/var/tmp/mic/cache"
self.destdir = "."
self.target_arch = "noarch"
self._local_pkgs_path = None
self._dep_checks = ["ls", "bash", "cp", "echo", "modprobe", "passwd"]
# FIXME to be obsolete, make it configurable
self.distro_name = "Tizen"
# Output image file names
self.outimage = []
# A flag to generate checksum
self._genchecksum = False
self._alt_initrd_name = None
self._recording_pkgs = []
# available size in root fs, init to 0
self._root_fs_avail = 0
# Name of the disk image file that is created.
self._img_name = None
self.image_format = None
# Save qemu emulator file name in order to clean up it finally
self.qemu_emulator = None
# No ks provided when called by convertor, so skip the dependency check
if self.ks:
# If we have btrfs partition we need to check that we have toosl for those
for part in self.ks.handler.partition.partitions:
if part.fstype and part.fstype == "btrfs":
self._dep_checks.append("mkfs.btrfs")
break
if self.target_arch and self.target_arch.startswith("arm"):
for dep in self._dep_checks:
if dep == "extlinux":
self._dep_checks.remove(dep)
if not os.path.exists("/usr/bin/qemu-arm") or not misc.is_statically_linked("/usr/bin/qemu-arm"):
self._dep_checks.append("qemu-arm-static")
if os.path.exists("/proc/sys/vm/vdso_enabled"):
vdso_fh = open("/proc/sys/vm/vdso_enabled", "r")
vdso_value = vdso_fh.read().strip()
vdso_fh.close()
if (int)(vdso_value) == 1:
msger.warning(
"vdso is enabled on your host, which might cause problems with arm emulations.\n"
"\tYou can disable vdso with following command before starting image build:\n"
"\techo 0 | sudo tee /proc/sys/vm/vdso_enabled"
)
# make sure the specified tmpdir and cachedir exist
if not os.path.exists(self.tmpdir):
os.makedirs(self.tmpdir)
if not os.path.exists(self.cachedir):
os.makedirs(self.cachedir)
if self._img_compression_method != None and self._img_compression_method not in self._valid_compression_methods:
raise CreatorError(
"Given disk image compression method ('%s') is not valid. Valid values are '%s'."
% (self._img_compression_method, " ".join(self._valid_compression_methods))
)
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 __init__(self, createopts = None, pkgmgr = None):
"""Initialize an ImageCreator instance.
ks -- a pykickstart.KickstartParser instance; this instance will be
used to drive the install by e.g. providing the list of packages
to be installed, the system configuration and %post scripts
name -- a name for the image; used for e.g. image filenames or
filesystem labels
"""
self.pkgmgr = pkgmgr
self.__builddir = None
self.__bindmounts = []
# Eeach image type can change these values as they might be image type
# specific
if not hasattr(self, "_valid_compression_methods"):
self._valid_compression_methods = ['bz2']
# The compression method for disk image.
self._img_compression_method = None
if createopts:
# A pykickstart.KickstartParser instance."""
self.ks = createopts['ks']
self.destdir = os.path.abspath(os.path.expanduser(createopts["outdir"]))
# A name for the image."""
self.name = createopts['name']
if createopts['release']:
self.name += '-' + createopts['release']
# check whether destine dir exist
if os.path.exists(self.destdir):
if msger.ask('Image dir: %s already exists, cleanup and continue?' % self.destdir):
shutil.rmtree(self.destdir, ignore_errors = True)
else:
raise Abort('Canceled')
# pending FEA: save log by default for --release
# The directory in which all temporary files will be created."""
self.tmpdir = createopts['tmpdir']
self.cachedir = createopts['cachedir']
self.target_arch = createopts['arch']
self._local_pkgs_path = createopts['local_pkgs_path']
self._img_compression_method = createopts['compress_disk_image']
else:
self.ks = None
self.name = "target"
self.tmpdir = "/var/tmp/mic"
self.cachedir = "/var/tmp/mic/cache"
self.destdir = "."
self.target_arch = "noarch"
self._local_pkgs_path = None
self._dep_checks = ["ls", "bash", "cp", "echo", "modprobe", "passwd"]
#FIXME to be obsolete, make it configurable
self.distro_name = "Tizen"
# Output image file names
self.outimage = []
# A flag to generate checksum
self._genchecksum = False
self._alt_initrd_name = None
self._recording_pkgs = []
# available size in root fs, init to 0
self._root_fs_avail = 0
# Name of the disk image file that is created.
self._img_name = None
self.image_format = None
# Save qemu emulator file name in order to clean up it finally
self.qemu_emulator = None
# No ks provided when called by convertor, so skip the dependency check
if self.ks:
# If we have btrfs partition we need to check that we have toosl for those
for part in self.ks.handler.partition.partitions:
if part.fstype and part.fstype == "btrfs":
self._dep_checks.append("mkfs.btrfs")
break
if self.target_arch and self.target_arch.startswith("arm"):
for dep in self._dep_checks:
if dep == "extlinux":
self._dep_checks.remove(dep)
if not os.path.exists("/usr/bin/qemu-arm") or not misc.is_statically_linked("/usr/bin/qemu-arm"):
self._dep_checks.append("qemu-arm-static")
if os.path.exists("/proc/sys/vm/vdso_enabled"):
vdso_fh = open("/proc/sys/vm/vdso_enabled","r")
vdso_value = vdso_fh.read().strip()
vdso_fh.close()
if (int)(vdso_value) == 1:
msger.warning("vdso is enabled on your host, which might cause problems with arm emulations.\n"
"\tYou can disable vdso with following command before starting image build:\n"
"\techo 0 | sudo tee /proc/sys/vm/vdso_enabled")
# make sure the specified tmpdir and cachedir exist
if not os.path.exists(self.tmpdir):
os.makedirs(self.tmpdir)
if not os.path.exists(self.cachedir):
os.makedirs(self.cachedir)
if self._img_compression_method != None and self._img_compression_method not in self._valid_compression_methods:
raise CreatorError("Given disk image compression method ('%s') is not valid. Valid values are '%s'." % (self._img_compression_method, ' '.join(self._valid_compression_methods)))
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 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 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 chroot(chrootdir, bindmounts=None, execute="/bin/bash"):
def mychroot():
os.chroot(chrootdir)
os.chdir("/")
if configmgr.chroot['saveto']:
savefs = True
saveto = configmgr.chroot['saveto']
wrnmsg = "Can't save chroot fs for dir %s exists" % saveto
if saveto == chrootdir:
savefs = False
wrnmsg = "Dir %s is being used to chroot" % saveto
elif os.path.exists(saveto):
if msger.ask("Dir %s already exists, cleanup and continue?" %
saveto):
shutil.rmtree(saveto, ignore_errors=True)
savefs = True
else:
savefs = False
if savefs:
msger.info("Saving image to directory %s" % saveto)
runner.quiet("cp -af %s %s" % (chrootdir, saveto))
devs = [
'dev/fd', 'dev/stdin', 'dev/stdout', 'dev/stderr', 'etc/mtab'
]
ignlst = [os.path.join(saveto, x) for x in devs]
map(os.unlink, filter(os.path.exists, ignlst))
else:
msger.warning(wrnmsg)
dev_null = os.open("/dev/null", os.O_WRONLY)
files_to_check = ["/bin/bash", "/sbin/init"]
architecture_found = False
""" Register statically-linked qemu-arm if it is an ARM fs """
qemu_emulator = None
for ftc in files_to_check:
ftc = "%s/%s" % (chrootdir, ftc)
# Return code of 'file' is "almost always" 0 based on some man pages
# so we need to check the file existance first.
if not os.path.exists(ftc):
continue
for line in runner.outs(['file', ftc]).splitlines():
if 'ARM' in line:
qemu_emulator = misc.setup_qemu_emulator(chrootdir, "arm")
architecture_found = True
break
if 'Intel' in line:
architecture_found = True
break
if architecture_found:
break
os.close(dev_null)
if not architecture_found:
raise errors.CreatorError("Failed to get architecture from any of the "
"following files %s from chroot." \
% files_to_check)
try:
msger.info("Launching shell. Exit to continue.\n"
"----------------------------------")
globalmounts = setup_chrootenv(chrootdir, bindmounts)
subprocess.call(execute, preexec_fn=mychroot, shell=True)
except OSError, err:
raise errors.CreatorError("chroot err: %s" % str(err))
