Synnefo » snf-image-creator

        mpoints = []

        for entry in self._read_fstable('/proc/mounts'):

            if entry.mpoint.startswith(os.path.abspath(target)):

        mpoints.sort()

        for mpoint in reversed(mpoints):

                continue

            dirname = mpoint

            found_ancestor = False

            while dirname != '/':

                if dirname in excluded:

                    found_ancestor = True

                    break

    ("File injection", ["EnforcePersonality"], ["windows", "linux"])

]

class MetadataMonitor(object):

    """Monitors image metadata chages"""

                if len(Kamaki.get_clouds()):

                    default_item = "Cloud"

                else:

            else:

        elif choice == "Cloud":

            default_item = "Cloud"

            clouds = Kamaki.get_clouds()

def sysprep_params(session):

    d = session['dialog']

    image = session['image']

    for name in names:

        param = needed[name]

        default = available[name] if name in available else ""

    txt = "Please provide the following system preparation parameters:"

    code, output = d.form(txt, height=13, width=WIDTH, form_height=len(fields),

    if code in (d.DIALOG_CANCEL, d.DIALOG_ESC):

        return False

    for i in range(len(fields)):

        param = needed[names[i]]

        if param.validator(output[i]):

            image.os.sysprep_params[names[i]] = output[i]

        else:

            d.msgbox("The value you provided for parameter: %s is not valid" %

            return False

    return True

PAGE_WIDTH = 70

PAGE_HEIGHT = 10

class WizardExit(Exception):

        field_lenght = len(self.fields())

        form_height = field_lenght if field_lenght < PAGE_HEIGHT - 4 \

        (code, output) = d.form(

            self.text, width=PAGE_WIDTH, height=PAGE_HEIGHT,

        for name in param_names:

            text = needed[name].description

            default = available[name] if name in available else ""

        return fields

    def sysprep_params_validate(answer):

def add_prefix(target):

    def wrapper(self, *args):

        prefix = args[0]

    return wrapper

def sysprep(message, enabled=True, **kwargs):

    """Decorator for system preparation tasks"""

        for key, val in kwargs.items():

        def inner(self, print_message=True):

            if print_message:

                self.out.output(message)

        return inner

    return wrapper

    """

        def inner(self, *args, **kwargs):

        return inner

    return wrapper

def del_sysprep_param(name):

    """

    def wrapper(func):

        @wraps(func)

        def inner(self, *args, **kwargs):

            func(self, *args, **kwargs)

        return inner

    return wrapper

class OSBase(object):

    """Basic operating system class"""

    def __init__(self, image, **kargs):

        self.image = image

        self.g = image.g

        self.out = image.out

        self.sysprep_params = \

            kargs['sysprep_params'] if 'sysprep_params' in kargs else {}

        self.meta = {}

    def collect_metadata(self):

        """Collect metadata about the OS"""

        """Print enabled and disabled system preparation operations."""

        syspreps = self.list_syspreps()

        wrapper = textwrap.TextWrapper()

        wrapper.subsequent_indent = '\t'

        self.out.output("Needed system preparation parameters:")

            self.out.output("(none)")

            return

            self.out.output("\t%s (%s): %s" %

                             self.sysprep_params else "(none)"))

    def do_sysprep(self):

            self.out.output('Preparing system for image creation:')

            size = len(enabled)

            cnt = 0

        # libguestfs can't handle correct freebsd partitions on a GUID

        # Partition Table. We have to do the translation to linux device names

        # ourselves

        mopts = "ufstype=ufs2,%s" % ('ro' if readonly else 'rw')

        for mp, dev in self._mountpoints():

    def _get_passworded_users(self):

        """Returns a list of non-locked user accounts"""

        users = []

        for line in self.g.cat('/etc/shadow').splitlines():

            match = regexp.match(line)

"""This module hosts OS-specific code common to all Unix-like OSs."""

from image_creator.os_type import OSBase, sysprep

        return True

    def cleanup_cache(self):

        """Remove all regular files under /var/cache"""

Windows OSs."""

from image_creator.os_type import OSBase, sysprep, add_sysprep_param

from image_creator.winexe import WinEXE, WinexeTimeout

import hivex

class Windows(OSBase):

    """OS class for Windows"""

    def __init__(self, image, **kargs):

        super(Windows, self).__init__(image, **kargs)

        assert self.system_drive

        self.product_name = self.g.inspect_get_product_name(self.root)

    @sysprep('Disabling IPv6 privacy extensions')

    def disable_ipv6_privacy_extensions(self):

            return

        self._guest_exec(

    @sysprep('Shrinking the last filesystem')

    def shrink(self):

            raise FatalError("Image is already syspreped!")

        txt = "System preparation parameter: `%s' is needed but missing!"

                raise FatalError(txt % param)

        self.mount(readonly=False)

        # guestfs_shutdown which is the prefered way to shutdown the backend

        # process was introduced in version 1.19.16

        if check_guestfs_version(self.g, 1, 19, 16) >= 0:

        else:

        self.out.success('done')

            self.out.output('Preparing system for image creation:')

            tasks = self.list_syspreps()

            size = len(enabled)

            # Make sure shrink runs in the end, before ms sysprep

            if len(enabled) != size:

                enabled.append(self.shrink)

            # Make sure the ms sysprep is the last task to run if it is enabled

            ms_sysprep_enabled = False

            if len(enabled) != size:

    def _wait_vm_boot(self, vm, fname, msg):

        """Wait until a message appears on a file or the vm process dies"""

            time.sleep(1)

            with open(fname) as f:

                for line in f:

        path = "%s/system32/config/%s" % (systemroot, regfile)

        try:

            path = self.g.case_sensitive_path(path)

            raise FatalError("Unable to retrieve registry file: %s. Reason: %s"

        return path

    def _enable_os_monitor(self):

    def _get_users(self):

        """Returns a list of users found in the images"""

        samfd, sam = tempfile.mkstemp()

        try:

            os.close(samfd)

            h = hivex.Hivex(sam)

                log.file.write(stdout)

            finally:

                log.close()

            if i < CONNECTION_RETRIES - 1:

                self.out.output("Retrying ...", False)

        raise FatalError("Connection to the VM failed after %d retries" %

        self.serial = serial

        def random_mac():

            mac = [0x00, 0x16, 0x3e,

                   random.randint(0x00, 0x7f),

                   random.randint(0x00, 0xff),

                   random.randint(0x00, 0xff)]

        # Use ganeti's VNC port range for a random vnc port

        self.display = random.randint(11000, 14999) - 5900

            if self.isalive():

                self.process.kill()

            self.process.wait()

            raise FatalError("VM destroy timed-out")

        signal.signal(signal.SIGALRM, handler)