Synnefo » snf-image-creator

# interpreted as representing official policies, either expressed

# or implied, of GRNET S.A.

from image_creator import FatalError

import stat

import os

        the Disk instance.

        """

        sourcedev = self.source

        mode = os.stat(self.source).st_mode

        if stat.S_ISDIR(mode):

            success('looks like a block device')

        # Take a snapshot and return it to the user

        size = blockdev('--getsize', sourcedev)

        cowfd, cow = tempfile.mkstemp()

        os.close(cowfd)

    def enable(self):

        """Enable a newly created DiskDevice"""

        self.progressbar.next()

        eh = self.g.set_event_callback(self.progress_callback,

                                                    guestfs.EVENT_PROGRESS)

            self.progressbar.send(100)

            self.progressbar = None

        roots = self.g.inspect_os()

        if len(roots) == 0:

            raise FatalError("No operating system found")

    def mount(self):

        """Mount all disk partitions in a correct order."""

        mps = self.g.inspect_get_mountpoints(self.root)

        # Sort the keys to mount the fs in a correct order.

            try:

                self.g.mount(dev, mp)

            except RuntimeError as msg:

    def umount(self):

        """Umount all mounted filesystems."""

        disk and then updating the partition table. The new disk size

        (in bytes) is returned.

        """

        dev = self.g.part_to_dev(self.root)

        parttype = self.g.part_get_parttype(dev)

        blocksize = 2 ** 22  # 4MB

        size = self.size()

        progress_size = (size + 2 ** 20 - 1) // 2 ** 20  # in MB

        source = open(self.device, "r")

        try:

from image_creator import __version__ as version

from image_creator import FatalError

from image_creator.disk import Disk

import sys

import os

import optparse

        action="store_true", help="overwrite output files if they exist")

    parser.add_option("--no-cleanup", dest="cleanup", default=True,

    parser.add_option("--no-sysprep", dest="sysprep", default=True,

    parser.add_option("--no-shrink", dest="shrink", default=True,

    parser.add_option("-o", "--outfile", type="string", dest="outfile",

        default=None, action="callback", callback=check_writable_dir,

    parser.add_option("-u", "--upload", dest="upload", default=False,

    parser.add_option("-r", "--register", dest="register", default=False,

        help="register the image to ~okeanos", action="store_true")

def image_creator():

    options = parse_options(sys.argv[1:])

    if os.geteuid() != 0:

        raise FatalError("You must run %s as root" \

                        % os.path.basename(sys.argv[0]))

        image_os = osclass(dev.root, dev.g)

        metadata = image_os.get_metadata()

        if options.sysprep:

            image_os.sysprep()

            dev.dump(options.outfile)

    finally:

        disk.cleanup()

    return 0

# interpreted as representing official policies, either expressed

# or implied, of GRNET S.A.

import re

def add_prefix(target):

    def data_cleanup(self):

        """Cleanup sensitive data out of the OS image."""

        is_cleanup = lambda x: x.startswith('data_cleanup_') and \

                                                    callable(getattr(self, x))

        cnt = 0

        for task in tasks:

            cnt += 1

            task()

    def sysprep(self):

        """Prepere system for image creation."""

        is_sysprep = lambda x: x.startswith('sysprep_') and \

                                                    callable(getattr(self, x))

        cnt = 0

        for task in tasks:

            cnt += 1

            task()

# vim: set sta sts=4 shiftwidth=4 sw=4 et ai :

# or implied, of GRNET S.A.

from image_creator.os_type.unix import Unix

import re

import time

        """

        if print_header:

        powerbtn_action = '#!/bin/sh\n\nPATH=/sbin:/bin:/usr/bin\n' \

                                'shutdown -h now \"Power button pressed\"\n'

        """

        if print_header:

        rule_file = '/etc/udev/rules.d/70-persistent-net.rules'

        if self.g.is_file(rule_file):

        """

        if print_header:

        # convert all devices in fstab to persistent

        persistent_root = self._persistent_fstab()

import sys

from image_creator.os_type import OSBase

class Unix(OSBase):

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

        if print_header:

        self.foreach_file('/var/cache', self.g.rm, ftype='r')

        """Remove all files under /tmp and /var/tmp"""

        if print_header:

        self.foreach_file('/tmp', self.g.rm_rf, maxdepth=1)

        self.foreach_file('/var/tmp', self.g.rm_rf, maxdepth=1)

        """Empty all files under /var/log"""

        if print_header:

        self.foreach_file('/var/log', self.g.truncate, ftype='r')

        """Remove all files under /var/mail and /var/spool/mail"""

        if print_header:

        self.foreach_file('/var/spool/mail', self.g.rm_rf, maxdepth=1)

        self.foreach_file('/var/mail', self.g.rm_rf, maxdepth=1)

        homedirs = ['/root'] + self.ls('/home/')

        if print_header:

        for homedir in homedirs:

            for data in self.sensitive_userdata:

# interpreted as representing official policies, either expressed

# or implied, of GRNET S.A.

import pbs

def get_command(command):

def error(msg, new_line=True):

def warn(msg, new_line=True):

def success(msg, new_line=True):

# vim: set sta sts=4 shiftwidth=4 sw=4 et ai :