Synnefo » snf-image-creator

Options

-------

--disable-sysprep=SYSPREP

	prevent SYSPREP operation from running on the input media

	dump image to FILE

--public

--print-sysprep

	print the enabled and disabled system preparation operations for this

	input media

-r IMAGENAME, --register=IMAGENAME

-s, --silent

	output only errors

-t TOKEN, --token=TOKEN

--tmpdir=DIR

	create large temporary image files under DIR

-u FILENAME, --upload=FILENAME

--version

	show program's version number and exit

     -f, --force           overwrite output files if they exist

     -s, --silent          output only errors

     -u FILENAME, --upload=FILENAME

     -r IMAGENAME, --register=IMAGENAME

     -m KEY=VALUE, --metadata=KEY=VALUE

                           add custom KEY=VALUE metadata to the image

     -t TOKEN, --token=TOKEN

                           media

     --no-sysprep          don't perform any system preparation operation

     --no-shrink           don't shrink any partition

     --tmpdir=DIR          create large temporary image files under DIR

Most input options are self-describing. If you want to save a local copy of

the image you create, provide a filename using the *-o* option. To upload the

registered as *private*. Only the user that registers the image can create

VM's out of it. If you want the image to be visible by other user too, use the

*--public* option.

   (ex. "Slackware Linux 14.0 with KDE")

 * Registration Type: Private or Public

For most users the functionality this mode provides should be sufficient.

In the *Register* sub-menu the user can provide:

 * Which cloud account to use

By choosing the *Extract* menu entry, the user can dump the image to the local

file system. Finally, if the user selects *Reset*, the system will ignore

.. image:: /snapshots/wizard.png

.. image:: /snapshots/confirm.png

Limitations

===========

Para-virtualized drivers

------------------------

Many popular Linux distributions, like Ubuntu and Debian, will automatically

create a generic initial ramdisk file that contains many different modules,

def upload_image(session):

    d = session["dialog"]

    image = session['image']

    meta = session['metadata']

    if "account" not in session:

        d.msgbox("You need to select a valid cloud before you can upload "

        return False

    while 1:

                overwrite.append(f)

        if len(overwrite) > 0:

                       "\n".join(overwrite), width=WIDTH, defaultno=1):

                continue

                out.success("done")

            except ClientError as e:

                if 'pithos_uri' in session:

                    del session['pithos_uri']

                return False

    finally:

        gauge.cleanup()

             width=SMALL_WIDTH)

    return True

def register_image(session):

    d = session["dialog"]

    is_public = False

    if "account" not in session:

        d.msgbox("You need to select a valid cloud before you "

        return False

    if "pithos_uri" not in session:

        return False

    while 1:

        out.add(gauge)

        try:

            try:

                kamaki = Kamaki(session['account'], out)

                result = kamaki.register(name, session['pithos_uri'], metadata,

                                         is_public)

                    kamaki.share("%s.md5sum" % session['upload'])

                    out.success('done')

            except ClientError as e:

                return False

        finally:

            out.remove(gauge)

    finally:

        gauge.cleanup()

             % (img_type.title(), session['upload'], name), width=SMALL_WIDTH)

    return True

        choices = [("Add/Edit", "Add/Edit cloud accounts"),

                   ("Delete", "Delete existing cloud accounts"),

                   ("Cloud", "Select cloud account to use: %s" % cloud),

        (code, choice) = d.menu(

            text="Choose one of the following or press <Back> to go back.",

            text="Choose one of the following or press <Exit> to exit.",

            width=WIDTH, choices=choices, cancel="Exit", height=13,

            default_item=default_item, menu_height=len(choices),

                  version)

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

        out.output()

        try:

            account = Kamaki.get_account(wizard['Cloud'])

            assert account, "Cloud: %s is not valid" % wizard['Cloud']

            kamaki = Kamaki(account, out)

            is_public = True if wizard['ImageRegistration'] == "Public" else \

                False

                       wizard['ImageRegistration'].lower(), False)

            result = kamaki.register(wizard['ImageName'], pithos_file,

                                     metadata, is_public)

            out.output()

        except ClientError as e:

    finally:

        out.remove(with_progress)

        extract_image(session)

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

     This is a space-seperated list of users, whose password will

     be reset during deployment.

 - SWAP=<n>:<size>

     This property only makes sense for Linux images.

----------------------------------------------

 - OS

     The value of this property is used to associate the image

                                      self.CONTAINER, path)

    def register(self, name, location, metadata, public=False):

        # Convert all metadata to strings

        str_metadata = {}

    parser.add_option("-u", "--upload", dest="upload", type="string",

                      default=False,

                      metavar="FILENAME")

    parser.add_option("-r", "--register", dest="register", type="string",

                      default=False,

                      metavar="IMAGENAME")

    parser.add_option("-m", "--metadata", dest="metadata", default=[],

                      help="don't shrink any partition", action="store_false")

    parser.add_option("--public", dest="public", default=False,

                      action="store_true")

    parser.add_option("--tmpdir", dest="tmp", type="string", default=None,

    if options.upload and not options.force:

        if kamaki.object_exists(options.upload):

                             "(use --force to overwrite it)." % options.upload)

        if kamaki.object_exists("%s.md5sum" % options.upload):

    if options.register and not options.force:

        if kamaki.object_exists("%s.meta" % options.upload):

                             "(use --force to overwrite it)." % options.upload)

    disk = Disk(options.source, out, options.tmp)

        try:

            uploaded_obj = ""

            if options.upload:

                with open(snapshot, 'rb') as f:

                    uploaded_obj = kamaki.upload(

                        f, size, options.upload,

            if options.register:

                img_type = 'public' if options.public else 'private'

                result = kamaki.register(options.register, uploaded_obj,

                                         metadata, options.public)

                out.success('done')

                out.output()

        except ClientError as e:

    finally:

        out.output('cleaning up ...')