#!/usr/bin/python2 ############################################################ # # ONL Root Filesystem Generator # ############################################################ import argparse import os import sys import logging import yaml import tempfile import shutil import pprint import fcntl import subprocess import glob import submodules import StringIO from collections import Iterable import onlyaml import onlu import fileinput import crypt import string import random import re import json logger = onlu.init_logging('onlrfs') def onlu_execute_sudo(*args, **kwargs): kwargs = dict(kwargs) kwargs['sudo'] = True return onlu.execute(*args, **kwargs) def onlu_execute_pivot_root(pivot, cmd, **kwargs): script = "/tmp/pivot_root.sh" with open(script, "w") as f: os.chmod(script, 0700) f.write("""#!/bin/bash -eux rm -rf /tmp/newroot && mkdir /tmp/newroot rm -rf $1/oldroot && mkdir $1/oldroot mount --bind $1 /tmp/newroot cd /tmp/newroot pivot_root . oldroot hash -r # clear cache of commands mount -t proc none /proc mount -t sysfs none /sys mount -t devtmpfs none /dev $2 """) ret = onlu_execute_sudo('unshare -pfm {} {} {}'.format(script, pivot, cmd), **kwargs) os.unlink(script) return ret class OnlRfsError(Exception): """General Error Exception""" def __init__(self, value): self.value = value def __str__(self): return repr(self.value) class OnlRfsSystemAdmin(object): def __init__(self, chroot): self.chroot = chroot @staticmethod def gen_salt(): # return an eight character salt value salt_map = './' + string.digits + string.ascii_uppercase + \ string.ascii_lowercase rand = random.SystemRandom() salt = '' for i in range(0, 8): salt += salt_map[rand.randint(0, 63)] return salt @staticmethod def chmod(mode, file_): onlu_execute_sudo("chmod %s %s" % (mode, file_), ex=OnlRfsError("Could not change permissions (%s) on file %s" % (mode, file_))) @staticmethod def chown(file_, ownspec): onlu_execute_sudo("chown %s %s" % (ownspec, file_), ex=OnlRfsError("Could not change ownership (%s) on file %s" % (ownspec, file_))) def userdel(self, username): pf = os.path.join(self.chroot, 'etc/passwd') sf = os.path.join(self.chroot, 'etc/shadow') self.chmod("a+rwx", os.path.dirname(pf)) self.chmod("a+rw", pf); self.chmod("a+rw", sf); # Can't use the userdel command because of potential uid 0 in-user problems while running ourselves for line in fileinput.input(pf, inplace=True): if not line.startswith('%s:' % username): print line, for line in fileinput.input(sf, inplace=True): if not line.startswith('%s:' % username): print line, self.chmod("go-wx", pf); self.chmod("go-wx", sf); def groupadd(self, group, gid=None, unique=True, system=False, force=False, password=None): args = [ 'groupadd' ] if force: args.append("--force") if system: args.append("--system") if not unique: args.append("--non-unique") if password: args = args + [ '--password', password ] if gid: args = args + [ '--gid', str(gid) ] args.append(group) onlu.execute(args, chroot=self.chroot, ex=OnlRfsError("Adding group '%s' failed." % group)) logger.info("added group %s", group) def useradd(self, username, uid=None, gid=None, password=None, shell='/bin/bash', home=None, groups=None, sudo=False, deleteFirst=True): args = [ 'useradd', '--create-home' ] if uid is not None: args = args + [ '--non-unique', '--uid', str(uid) ] if gid is not None: args = args + [ '--gid', str(gid) ] if password: epassword=crypt.crypt(password, '$1$%s$' % self.gen_salt()); args = args + ['-p', epassword ] if shell: args = args + [ '--shell', shell ] if home: args = args + [ '--home', home ] if groups: args = args + [ '--groups', ','.join(groups) ] if deleteFirst: self.userdel(username) args.append(username) onlu.execute(args, chroot=self.chroot, ex=OnlRfsError("Adding user '%s' failed." % username)) if password is None: onlu.execute("passwd -d %s" % username, chroot=self.chroot, ex=OnlRfsError("Error deleting password for user '%s'" % username)) logger.info("user %s password %s", username, password) if sudo: sudoer = os.path.join(self.chroot, 'etc/sudoers.d', username) self.chmod("777", os.path.dirname(sudoer)) with open(sudoer, "w") as f: f.write("%s ALL=(ALL:ALL) NOPASSWD:ALL\n" % username); self.chmod("0440", sudoer) self.chown(sudoer, "root:root") self.chmod("755", os.path.dirname(sudoer)) def user_password_set(self, username, password): logger.info("user %s password now %s", username, password) epassword=crypt.crypt(password, '$1$%s$' % self.gen_salt()); onlu.execute(['usermod', '-p', epassword, username], chroot=self.chroot, ex=OnlRfsError("Error setting password for user '%s'" % username)) def user_shell_set(self, username, shell): onlu.execute('chsh --shell %s %s' % (shell, username), chroot=self.chroot, ex=OnlRfsError("Error setting shell %s for user %s" % (shell, username))) def user_disable(self, username): self.user_shell_set(username, '/bin/false') class OnlMultistrapConfig(object): def __init__(self, config): self.config = config self.__validate() def __validate_key(self, d, k, type_, required=False): pass def __validate(self): """Validate the contents of our configuration.""" # There must be a General section. general = self.config.get('General', None) if general is None: raise OnlRfsError("Section 'General' is missing from the multistrap configuration.") self.__validate_key(general, 'arch', str, True) self.__validate_key(general, 'debootstrap', str, True) for entry in [ 'debootstrap', 'aptsources' ]: sectionlist = [] for e in general.get(entry, "").split(): if e not in self.config: raise OnlRfsError("Section '%s' is specified in the %s option but does not exist in the configuration." % (e, entry)) if self.config[e].get('arches', None) and general['arch'] not in self.config[e]['arches']: del self.config[e] else: sectionlist.append(e) general[entry] = " ".join(sectionlist) self.localrepos = [] def generate_handle(self, handle): for (name, fields) in self.config.iteritems(): handle.write("[%s]\n" % name) for (k,v) in fields.iteritems(): if type(v) is bool: v = 'true' if v == True else 'false' if type(v) is list: v = " ".join(onlu.sflatten(v)) if k == 'source' and os.path.exists(v): self.localrepos.append(v) v = "copy:%s ./" % v if k == 'packages' and type(v) is list: raise OnlRfsError("packages=%s" % v) handle.write("%s=%s\n" % (k, v)) handle.write("\n") def generate_file(self, fname=None): if fname is None: h = tempfile.NamedTemporaryFile(delete=False) fname = h.name elif fname == '-' or fname == 'stdout': h = sys.stdout else: h = open(fname, "w") self.generate_handle(h) return fname def get_packages(self): pkgs = [] for (name, fields) in self.config.iteritems(): for (k,v) in fields.iteritems(): if k == 'packages': if type(v) is list: pkgs = pkgs + list(onlu.sflatten(v)) else: pkgs = pkgs + v.split() return pkgs def __str__(self): handle = StringIO.StringIO() self.generate_handle(handle) return handle.getvalue() class OnlRfsContext(object): def __init__(self, directory, resolvconf=True): self.directory = directory self.dev = os.path.join(self.directory, "dev") self.proc = os.path.join(self.directory, "proc") self.rc = resolvconf if self.rc: self.resolvconf = os.path.join(self.directory, "etc", "resolv.conf") self.resolvconfb = "%s.onlrfs" % (self.resolvconf) def exists(self, fname): return os.path.islink(fname) or os.path.exists(fname) def __enter__(self): try: onlu_execute_sudo("mount -t devtmpfs dev %s" % self.dev, ex=OnlRfsError("Could not mount dev in rfs.")) onlu_execute_sudo("mount -t proc proc %s" % self.proc, ex=OnlRfsError("Could not mount proc in rfs.")) if self.rc: if self.exists(self.resolvconf): onlu_execute_sudo("mv %s %s" % (self.resolvconf, self.resolvconfb), ex=OnlRfsError("Could not backup resolv.conf")) onlu_execute_sudo("cp --remove-destination /etc/resolv.conf %s" % (self.resolvconf), ex=OnlRfsError("Could install new resolv.conf")) return self except Exception, e: logger.error("Exception %s in OnlRfsContext::__enter__" % e) self.__exit__(None, None, None) raise e def __exit__(self, eType, eValue, eTrace): onlu_execute_sudo("umount -l %s %s" % (self.dev, self.proc), ex=OnlRfsError("Could not unmount dev and proc")) if self.rc: onlu_execute_sudo("rm %s" % (self.resolvconf), ex=OnlRfsError("Could not remove new resolv.conf")) if self.exists(self.resolvconfb): onlu_execute_sudo("mv %s %s" % (self.resolvconfb, self.resolvconf), ex=OnlRfsError("Could not restore resolv.conf")) class OnlRfsBuilder(object): DEFAULTS = dict( DEBIAN_SUITE='wheezy', DEBIAN_MIRROR='mirrors.kernel.org/debian/', APT_CACHE='127.0.0.1:3142/' ) MULTISTRAP='/usr/sbin/multistrap' QEMU_PPC='/usr/bin/qemu-ppc-static' QEMU_ARM='/usr/bin/qemu-arm-static' QEMU_ARM64='/usr/bin/qemu-aarch64-static' BINFMT_PPC='/proc/sys/fs/binfmt_misc/qemu-ppc' def __init__(self, config, arch, **kwargs): self.kwargs = kwargs self.arch = arch self.kwargs['ARCH'] = arch # Hack -- we have to pull powerpc from the archive # This will need a cleaner fix. if arch == 'powerpc': self.DEFAULTS['DEBIAN_MIRROR'] = 'archive.debian.org/debian/' self.kwargs.update(self.DEFAULTS) self.__load(config) self.__validate() def __load(self, config): if not os.path.exists(config): raise OnlRfsError("Configuration file '%s' does not exist." % config) self.config = onlyaml.loadf(config, self.kwargs) def __validate(self): if not os.path.exists(self.MULTISTRAP): raise OnlRfsError("%s is missing." % self.MULTISTRAP) if self.arch == 'powerpc': if not os.path.exists(self.QEMU_PPC): raise OnlRfsError("%s is missing." % self.QEMU_PPC) if self.arch in [ 'armel', 'armhf' ]: if not os.path.exists(self.QEMU_ARM): raise OnlRfsError("%s is missing." % self.QEMU_ARM) if self.arch == 'arm64': if not os.path.exists(self.QEMU_ARM64): raise OnlRfsError("%s is missing." % self.QEMU_ARM64) if not 'Multistrap' in self.config: raise OnlRfsError("The Multistrap configuration section is missing.") self.ms = OnlMultistrapConfig(self.config['Multistrap']) def get_packages(self): return self.ms.get_packages() def msconfig(self, fname): return self.ms.generate_file(fname) def multistrap(self, dir_, use_existing_rootfs=False): msconfig = self.ms.generate_file() # Optional local package updates if os.getenv("ONLRFS_NO_PACKAGE_SCAN") is None: for r in self.ms.localrepos: logger.info("Updating %s" % r) if os.path.exists(os.path.join(r, 'Makefile')): onlu.execute("make -C %s" % r) if os.path.exists(dir_) and not use_existing_rootfs: onlu_execute_sudo("rm -rf %s" % dir_, ex=OnlRfsError("Could not remove target directory.")) if onlu_execute_sudo("unshare -pf --mount-proc %s -d %s -f %s" % (self.MULTISTRAP, dir_, msconfig)) == 100: raise OnlRfsError("Multistrap APT failure.") if os.getenv("MULTISTRAP_DEBUG"): raise OnlRfsError("Multistrap debug.") def dpkg_configure(self, dir_): if self.arch == 'powerpc': onlu.execute('sudo cp %s %s' % (self.QEMU_PPC, os.path.join(dir_, 'usr/bin'))) if self.arch in [ 'armel', 'armhf' ]: onlu.execute('sudo cp %s %s' % (self.QEMU_ARM, os.path.join(dir_, 'usr/bin'))) if self.arch == 'arm64': onlu.execute('sudo cp %s %s' % (self.QEMU_ARM64, os.path.join(dir_, 'usr/bin'))) onlu.execute('sudo cp %s %s' % (os.path.join(os.getenv('ONL'), 'tools', 'scripts', 'base-files.postinst'), os.path.join(dir_, 'var', 'lib', 'dpkg', 'info', 'base-files.postinst'))); # make sure /tmp is writable OnlRfsSystemAdmin.chmod('1777', '%s/tmp' % dir_) script = os.path.join(dir_, "tmp/configure.sh") with open(script, "w") as f: os.chmod(script, 0700) f.write("""#!/bin/bash -ex /bin/echo -e "#!/bin/sh\\nexit 101" >/usr/sbin/policy-rc.d chmod +x /usr/sbin/policy-rc.d export DEBIAN_FRONTEND=noninteractive export DEBCONF_NONINTERACTIVE_SEEN=true echo "127.0.0.1 localhost" >/etc/hosts touch /etc/fstab echo "localhost" >/etc/hostname if [ -f /var/lib/dpkg/info/dash.preinst ]; then /var/lib/dpkg/info/dash.preinst install fi if [ -f /usr/sbin/locale-gen ]; then echo "en_US.UTF-8 UTF-8" >/etc/locale.gen /usr/sbin/locale-gen update-locale LANG=en_US.UTF-8 fi dpkg --configure -a || true dpkg --configure -a # configure any packages that failed the first time and abort on failure. rm -f /usr/sbin/policy-rc.d """) logger.info("dpkg-configure filesystem...") onlu_execute_pivot_root(dir_, '/tmp/configure.sh', ex=OnlRfsError("Post Configuration failed.")) os.unlink(script) def configure(self, dir_): if not os.getenv('NO_DPKG_CONFIGURE'): with OnlRfsContext(dir_): self.dpkg_configure(dir_) with OnlRfsContext(dir_): os_release = os.path.join(dir_, 'etc', 'os-release') os_release_dict = {} if os.path.exists(os_release): # Convert /etc/os-release to /etc/os-release.json import shlex contents = open(os_release).read() os_release_dict = dict(token.split('=') for token in shlex.split(contents)) ua = OnlRfsSystemAdmin(dir_) ua.chmod('a+rwx', os.path.dirname(os_release)) with open(os.path.join(os.path.dirname(os_release), 'os-release.json'), "w") as f: f.write(json.dumps(os_release_dict)) ua.chmod('0755', os.path.dirname(os_release)) Configure = self.config.get('Configure', None) if Configure: for cmd in Configure.get('run', []): onlu_execute_sudo(cmd, ex=OnlRfsError("run command '%s' failed" % cmd), chroot=dir_) for overlay in Configure.get('overlays', []): logger.info("Overlay %s..." % overlay) onlu.execute('tar -C %s -c --exclude "*~" . | sudo tar -C %s -x -v --no-same-owner' % (overlay, dir_), ex=OnlRfsError("Overlay '%s' failed." % overlay)) for update in Configure.get('update-rc.d', []): onlu_execute_sudo("/usr/sbin/update-rc.d %s" % update, ex=OnlRfsError("update-rc.d %s failed." % (update)), chroot=dir_) for script in Configure.get('scripts', []): logger.info("Configuration script %s..." % script) onlu_execute_sudo("unshare -pf --mount-proc %s %s" % (script, dir_), ex=OnlRfsError("script '%s' failed." % script), env=True) for command in Configure.get('commands', []): if '__rfs__' in command: command = command.replace('__rfs__', dir_) logger.info("Configuration command '%s'..." % command) onlu.execute(command, ex=OnlRfsError("Command '%s' failed." % command)) ua = OnlRfsSystemAdmin(dir_) for (group, values) in Configure.get('groups', {}).iteritems(): ua.groupadd(group=group, **values if values else {}) for (user, values) in Configure.get('users', {}).iteritems(): if user == 'root': if 'password' in values: ua.user_password_set(user, values['password']) else: ua.useradd(username=user, **values) options = Configure.get('options', {}) if options.get('clean', False): logger.info("Cleaning Filesystem...") onlu.execute('sudo chroot %s /usr/bin/apt-get clean' % dir_) onlu.execute('sudo chroot %s /usr/sbin/localepurge' % dir_ ) onlu.execute('sudo chroot %s find /usr/share/doc -type f -not -name asr.json -delete' % dir_) onlu.execute('sudo chroot %s find /usr/share/man -type f -delete' % dir_) if 'PermitRootLogin' in options: config = os.path.join(dir_, 'etc/ssh/sshd_config') ua.chmod('a+rw', config) lines = open(config).readlines() with open(config, "w") as f: for line in lines: if line.startswith('PermitRootLogin'): v = options['PermitRootLogin'] logger.info("Setting PermitRootLogin to %s" % v) f.write('PermitRootLogin %s\n' % v) else: f.write(line) ua.chmod('644', config) if not options.get('securetty', True): f = os.path.join(dir_, 'etc/securetty') if os.path.exists(f): logger.info("Removing %s" % f) onlu.execute('sudo rm %s' % f, ex=OnlRfsError('Could not remove file %s' % f)) if os.path.exists(os.path.join(dir_, 'etc/inittab')): if not options.get('ttys', False): f = os.path.join(dir_, 'etc/inittab') ua.chmod('a+w', f) ua.chmod('a+w', os.path.dirname(f)) logger.info("Clearing %s ttys..." % f) for line in fileinput.input(f, inplace=True): if re.match("^[123456]:.*", line): line = "#" + line print line, ua.chmod('go-w', f) ua.chmod('go-w', os.path.dirname(f)) if options.get('console', True): logger.info('Configuring Console Access in %s' % f) f = os.path.join(dir_, 'etc/inittab') ua.chmod('a+w', f) ua.chmod('a+w', os.path.dirname(f)) with open(f, 'a') as h: h.write("T0:23:respawn:/sbin/pgetty\n") ua.chmod('go-w', f) ua.chmod('go-w', os.path.dirname(f)) if options.get('asr', None): asropts = options.get('asr') logger.info("Gathering ASR documentation...") sys.path.append("%s/sm/infra/tools" % os.getenv('ONL')) import asr asro = asr.AimSyslogReference() asro.merge(dir_) asrf = os.path.join(dir_, asropts['file']) OnlRfsSystemAdmin.chmod('777', os.path.dirname(asrf)) asro.format(os.path.join(dir_, asropts['file']), fmt=asropts['format']) for (mf, fields) in Configure.get('manifests', {}).iteritems(): logger.info("Configuring manifest %s..." % mf) if mf.startswith('/'): mf = mf[1:] mname = os.path.join(dir_, mf) onlu_execute_sudo("mkdir -p %s" % os.path.dirname(mname)) onlu_execute_sudo("touch %s" % mname) onlu_execute_sudo("chmod a+w %s" % mname) md = {} md['version'] = json.load(open(fields['version'])) md['arch'] = self.arch md['os-release'] = os_release_dict if os.path.exists(fields['platforms']): md['platforms'] = yaml.load(open(fields['platforms'])) else: md['platforms'] = fields['platforms'].split(',') for (k, v) in fields.get('keys', {}).iteritems(): if k in md: md[k].update(v) else: md[k] = v with open(mname, "w") as f: json.dump(md, f, indent=2) onlu_execute_sudo("chmod a-w %s" % mname) for (fname, v) in Configure.get('files', {}).get('add', {}).iteritems(): if fname.startswith('/'): fname = fname[1:] dst = os.path.join(dir_, fname) onlu_execute_sudo("mkdir -p %s" % os.path.dirname(dst)) onlu_execute_sudo("touch %s" % dst) onlu_execute_sudo("chmod a+w %s" % dst) if os.path.exists(v): shutil.copy(v, dst) else: with open(dst, "w") as f: f.write("%s\n" % v) for fname in Configure.get('files', {}).get('remove', []): if fname.startswith('/'): fname = fname[1:] f = os.path.join(dir_, fname) if os.path.exists(f): onlu_execute_sudo("rm -rf %s" % f) if Configure.get('issue'): issue = Configure.get('issue') fn = os.path.join(dir_, "etc/issue") onlu_execute_sudo("chmod a+w %s" % fn) with open(fn, "w") as f: f.write("%s\n\n" % issue) onlu_execute_sudo("chmod a-w %s" % fn) fn = os.path.join(dir_, "etc/issue.net") onlu_execute_sudo("chmod a+w %s" % fn) with open(fn, "w") as f: f.write("%s\n" % issue) onlu_execute_sudo("chmod a-w %s" % fn) def update(self, dir_, packages): ONLPM = "%s/tools/onlpm.py" % os.getenv('ONL') with OnlRfsContext(dir_): for pspec in packages: for pkg in pspec.split(','): logger.info("updating %s into %s", pkg, dir_) cmd = (ONLPM, '--verbose', '--sudo', '--extract-dir', pkg, dir_,) onlu.execute(cmd, ex=OnlRfsError("update of %s failed" % pkg)) def install(self, dir_, packages): ONLPM = "%s/tools/onlpm.py" % os.getenv('ONL') with OnlRfsContext(dir_): for pspec in packages: for pkg in pspec.split(','): cmd = (ONLPM, '--lookup', pkg,) try: buf = subprocess.check_output(cmd) except subprocess.CalledProcessError as ex: logger.error("cannot find %s", pkg) raise ValueError("update failed") if not buf.strip(): raise ValueError("cannot find %s" % pkg) src = buf.splitlines(False)[0] d, b = os.path.split(src) dst = os.path.join(dir_, "tmp", b) shutil.copy2(src, dst) src2 = os.path.join("/tmp", b) logger.info("installing %s into %s", pkg, dir_) cmd = ('/usr/bin/rfs-dpkg', '-i', src2,) onlu.execute(cmd, chroot=dir_, ex=OnlRfsError("install of %s failed" % pkg)) name, _, _ = pkg.partition(':') logger.info("updating dependencies for %s", pkg) cmd = ('/usr/bin/rfs-apt-get', '-f', 'install', name,) onlu.execute(cmd, chroot=dir_, ex=OnlRfsError("install of %s failed" % pkg)) if __name__ == '__main__': ap = argparse.ArgumentParser(description="ONL Root Filesystem Generator") ap.add_argument("--arch", required=True) ap.add_argument("--config", required=True) ap.add_argument("--dir") ap.add_argument("--show-packages", action='store_true') ap.add_argument("--no-build-packages", action='store_true') ap.add_argument("--only-build-packages", action='store_true') ap.add_argument("--msconfig") ap.add_argument("--multistrap-only", action='store_true') ap.add_argument("--no-multistrap", action='store_true') ap.add_argument("--cpio") ap.add_argument("--squash") ap.add_argument("--enable-root") ap.add_argument("--use-existing-rootfs", action='store_true') ap.add_argument("--no-configure", action='store_true') ap.add_argument("--update", action='append') ap.add_argument("--install", action='append') ops = ap.parse_args() if ops.enable_root: # # Fixme -- this should all be rearranged to naturally support # arbitrary filesystem modifications. # sa = OnlRfsSystemAdmin(ops.dir) sa.user_password_set('root', ops.enable_root) config = os.path.join(ops.dir, 'etc/ssh/sshd_config') sa.chmod('a+rw', config) lines = open(config).readlines() with open(config, "w") as f: for line in lines: if line.startswith('PermitRootLogin'): v = "Yes" logger.info("Setting PermitRootLogin to %s" % v) f.write('PermitRootLogin %s\n' % v) else: f.write(line) sa.chmod('644', config) sys.exit(0) try: x = OnlRfsBuilder(ops.config, ops.arch) if ops.msconfig: x.msconfig(ops.msconfig) sys.exit(0) if ops.show_packages: print "\n".join(x.get_packages()) sys.exit(0) if ops.dir is None: raise OnlRfsError("argument --dir is required") if not ops.no_build_packages: pkgs = x.get_packages() # Invoke onlpm to build all required (local) packages. onlu.execute("%s/tools/onlpm.py --try-arches %s all --skip-missing --require %s" % (os.getenv('ONL'), ops.arch, " ".join(pkgs)), ex=OnlRfsError("Failed to build all required packages.")) if ops.only_build_packages: sys.exit(0) if ops.multistrap_only: x.multistrap(ops.dir, ops.use_exisiting_rootfs) sys.exit(0) if not ops.no_multistrap and not os.getenv('NO_MULTISTRAP'): x.multistrap(ops.dir, ops.use_existing_rootfs) if not ops.no_configure and not os.getenv('NO_CONFIGURE'): x.configure(ops.dir) if ops.update: x.update(ops.dir, ops.update) if ops.install: x.install(ops.dir, ops.install) if ops.cpio: if onlu.execute("%s/tools/scripts/make-cpio.sh %s %s" % (os.getenv('ONL'), ops.dir, ops.cpio)) != 0: raise OnlRfsError("cpio creation failed.") if ops.squash: if os.path.exists(ops.squash): os.unlink(ops.squash) if onlu_execute_sudo("mksquashfs %s %s -no-progress -noappend -comp gzip" % (ops.dir, ops.squash)) != 0: if os.path.exists(ops.squash): os.unlink(ops.squash) raise OnlRfsError("Squash creation failed.") except (OnlRfsError, onlyaml.OnlYamlError), e: logger.error(e.value)