Synnefo » ./kamaki

from sys import path, stderr

import os

try:

    from objpool.http import PooledHTTPConnection

    PooledHTTPConnection

except ImportError:

try:

    from progress.bar import ShadyBar

    ShadyBar

except ImportError:

path.insert(0, os.path.join(os.path.abspath(os.path.dirname(__file__)), '..'))

    $ sudo apt-get install python-mock=1.0.1

    *livetest* command group:

    .. code-block:: console

        $ kamaki config set livetest_cli livetest

.. _installing-from-pypi-ref:

Installing from pypi

Setup a virtual enviroment (optional)

"""""""""""""""""""""""""""""""""""""

environment.

.. code-block:: console

        $ kamaki config set livetest_cli livetest

Mac OS X

--------

at :ref:`installing-from-pypi-ref`.

Windows

* Setuptools (`Official versions and workarounds <http://pypi.python.org/pypi/setuptools>`_)

another project) may skip Python and / or setuptools installation.

Install Python

`python org page <http://pypi.python.org/pypi/setuptools>`_, the setuptools

installer doesn't currently work on 64bit machines.

    installer

    `ez_setup.py <http://peak.telecommunity.com/dist/ez_setup.py>`_ script and

    install it from a command shell. In the following example, the script was

    downloaded at C:\\Downloads::

Quick Setup

-----------

Kamaki has to be configured for a specific Synnefo deployment, with an

authentication url and user token pair. Users should also pick an alias to name

.. code-block:: console

Since version 0.14, Synnefo supports a single authentication URL for retrieving

all API endpoints. This URL is retrieved from the Synnefo Web UI and should be

set as the cloud URL for kamaki. All service-specific URLs are retrieved and

This section refers to running installations of kamaki version <= 0.8.X. To

check the current kamaki version:

Existing kamaki users should convert their configuration files to v9. To do

that, kamaki 0.9 can inspect the configuration file and suggests a list of

.. code-block:: console

    :emphasize-lines: 1

    Overwrite file /home/exampleuser/.kamakirc ? [Y, y]

At this point, we should examine the kamaki output. Most options are renamed to

Let's take a look at the discarded options:

    meaningless and therefore omitted.

* `global.data_log` option has never been a valid kamaki config option.

.. code-block:: console

    :emphasize-lines: 1

The following refers to users of multiple Synnefo and/or Open Stack

deployments. In the following, a Synnefo or Open Stack cloud deployment will

Once a user has retrieved one URL/token pair per cloud, it is time to assign a

For example, let the user have access to two clouds with the following authentication information ::

    authentication token: my73571ng70k3n==

.. note:: the cloud alias is arbitrary and decided by the user. It is just a

The user should let kamaki know about these setups:

.. code-block:: console

     cloud.default.url = https://example.com/astakos.identity/v2.0/

     cloud.devel.url = https://devel.example.com/astakos/identity/v2.0/

     cloud.devel.token = myd3v3170k3n==

     cloud.testing.url = https://testing.example.com/astakos/identity/v2.0/

        name       :  Default User

    $

the **- - cloud** option.

Optional features

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

    * Allow unit tests to run on kamaki.clients package

    * Needs mock version 1.X or better

Any of the above features can be installed at any time before or after kamaki

installation.

* kamaki-related (global)

    interface settings and constants of the kamaki internal mechanism, e.g.,

* cloud-related

    information needed to connect and use one or more clouds. There are some

Modifying options at runtime

^^^^^^^^^^^^^^^^^^^^^^^^^^^^

.. code-block:: console

will invoke *kamaki file list* with the specified options, but the initial

global.pithos_container values will not be modified.

Editing options

^^^^^^^^^^^^^^^

Kamaki config command allows users to see and manage all configuration options.

* kamaki config list

* kamaki config get <group.option>

    show the value of a specific configuration option. Options must be of the

* kamaki config set <group.option> <value>

    *global*.

* kamaki config delete <group.option>

    *global*

The above commands cause option values to be permanently stored in the Kamaki configuration file.

        delete the <option> and its value from the cloud cloud aliased as

        <cloud alias>

    .. code-block:: console

        $ kamaki config get default_cloud

Editing the configuration file

^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

The configuration file is a simple text file that can be created by the user.

A simple way to create the configuration file is to set a configuration option

using the kamaki config command. For example:

    url =

    token =

Available options

^^^^^^^^^^^^^^^^^

settings, namely command cli specifications, the thread limit, console colors,

history and log files, log detail options and pithos-specific options.

    allow kamaki to log http data (by default, it logs only method, URL and

    headers)

* global.file_cli <UI command specifications for file>

    a special package that is used to load storage commands to kamaki UIs.

    Don't touch this unless if you know what you are doing.

Additional features

^^^^^^^^^^^^^^^^^^^

    [global]

    livetest_cli=livetest

or with this kamaki command::

Here is a list of settings needed:

* for astakos client::

    * livetest.astakos_details = <A file with an authentication output>

        To create this file, pipeline the output of an authentication command

        .. code-block:: console

            $ kamaki user authenticate -j > astakos.details

    * livetest.astakos_id = <The valid unique user id of the testing user>

* for image client:

        To create this file, pipeline the output of an image metadata command

        .. code-block:: console

* for flavors (part of the compute client):

    * livetest.flavor_details = <A file with the flavor details>

        To create this file, pipeline the output of a flavor info command

        .. code-block:: console

    $ kamaki livetest all

The unit testing system

"""""""""""""""""""""""

Kamaki container a set of finegrained unit tests for the kamaki.clients

package. This set is not used when kamaki is running. Instead, it is aimed to

`Going Agile <developers/extending-clients-api.html#going-agile>`_ entry at the

`developers section <developers/extending-clients-api.html>`_.

`Commands <commands.html>`_ section. This guide covers the generic usage of

both interfaces.

`Clients lib <developers/code.html#the-clients-api>`_ section.

Quick Setup

Shell vs one-command

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

Kamaki users can access Synnefo services through either the interactive shell

command set implementations and API clients, with identical responses and error

messages. Still, there are some differences.

* tab completion for commands (if supported by the user's shell)

* session history with ↑ or ↓ keys (if supported by the user's shell)

* shorter commands with command context switching

* re-run old commands with /history

* can be used along with advanced shell features (pipelines, redirection, etc.)

* can be used in shell scripts

    $ kamaki

.. code-block:: console

    :emphasize-lines: 1

.. code-block:: console

    :emphasize-lines: 1

    $ kamaki server list

    Options:

     - - - -

    create  :  Create a server (aka Virtual Machine)

    ip      :  Manage floating IPs for the servers

    info    :  Detailed information on a Virtual Machine

    list    :  List Virtual Machines accessible by user

    metadata:  Manage Server metadata (key:value pairs of server attributes)

    resize  :  Set a different flavor for an existing server

    wait    :  Wait for server to finish [BUILD, STOPPED, REBOOT, ACTIVE]

    --more                output results in pages (-n to set items per page,

                          default 10)

    -n LIMIT, --number LIMIT

    -j, --json            show headers in json

.. _using-history-ref:

    [file]: exit

    [kamaki]: server

    [server]: list

    [server]: exit

    [kamaki]:

    [kamaki]: file list

    ... (storage container listing) ...

    [kamaki]: server list

    [kamaki]:

Using Help

    [context]: /anothercontext cmd1 cmd2 ... cmdN

An example (4.3.1) that showcases how top-level access improves user experience

command is called with three parameters:

* the flavor id

* the image id

It is often the case that a user who works in the context command, needs to

the id of that flavor or image. Therefore, it is necessary to list all

available flavors (flavor-list) or images (image-compute-list). Both commands

belong to different contexts.

.. code-block:: console

    :emphasize-lines: 1

    [server]: create -h

    create <name> <flavor id> <image id> ...

    \n* to set authentication token: /config set cloud.<cloud>.token <token>'

howto_personality = [

    'syntax:  PATH,[SERVER_PATH,[OWNER,[GROUP,[MODE]]]]',

    '  PATH: local file to be injected (relative or absolute)',

    '  SERVER_PATH: destination location inside server Image',

    '  MODEL: permition in octal (e.g. 0777 or o+rwx)']

        since=DateArgument(

            'show only items since date (\' d/m/Y H:M:S \')',

            '--since'),

        more=FlagArgument(

            'output results in pages (-n to set items per page, default 10)',

            '--more'),

@command(server_cmds)

class server_rename(_init_cyclades, _optional_output_cmd):

    """

    @errors.generic.all

@command(server_cmds)

class server_delete(_init_cyclades, _optional_output_cmd, _server_wait):

    arguments = dict(

        wait=FlagArgument('Wait server to be destroyed', ('-w', '--wait'))

@command(server_cmds)

class server_reboot(_init_cyclades, _optional_output_cmd, _server_wait):

    arguments = dict(

        hard=FlagArgument(

@command(server_cmds)

class server_start(_init_cyclades, _optional_output_cmd, _server_wait):

    arguments = dict(

        wait=FlagArgument('Wait server to be destroyed', ('-w', '--wait'))

@command(server_cmds)

class server_shutdown(_init_cyclades, _optional_output_cmd, _server_wait):

    arguments = dict(

        wait=FlagArgument('Wait server to be destroyed', ('-w', '--wait'))

@command(server_cmds)

class server_console(_init_cyclades, _optional_json):

    Console connection information provided (at least):

    - host: (url or address) a VNC host

    - password: for VNC authorization

    """

@command(server_cmds)

class server_firewall(_init_cyclades):

@command(server_cmds)

class server_firewall_set(_init_cyclades, _optional_output_cmd):

    Values for profile:

    - DISABLED: Shutdown firewall

    - ENABLED: Firewall in normal mode

@command(server_cmds)

class server_firewall_get(_init_cyclades):

    @errors.generic.all

    @errors.cyclades.connection

@command(server_cmds)

class server_addr(_init_cyclades, _optional_json):

    arguments = dict(

        enum=FlagArgument('Enumerate results', '--enumerate')

@command(server_cmds)

class server_metadata_set(_init_cyclades, _optional_json):

    Metadata should be given in key/value pairs in key=value format

    For example: /server metadata set <server id> key1=value1 key2=value2

    Old, unreferenced metadata will remain intact

@command(server_cmds)

class server_metadata_delete(_init_cyclades, _optional_output_cmd):

    @errors.generic.all

    @errors.cyclades.connection

@command(server_cmds)

class server_stats(_init_cyclades, _optional_json):

    @errors.generic.all

    @errors.cyclades.connection

                elif network_id or ce.status == 421:

                    msg = 'Network with id %s is in use' % network_id,

                    raiseCLIError(ce, msg, details=[

                        '* to get nics: /network info %s' % network_id,

                        '.  (under "attachments" section)',

                        '* to disconnect: /network disconnect <nic id>'])

                server_id = int(server_id)

                return foo(self, *args, **kwargs)

            except ValueError as ve:

                details = ['id must be a positive integer'],

                raiseCLIError(ve, msg, details=details, importance=1)

            except ClientError as ce:

                ) or (

                    ce.status == 400 and 'not found' in err_msg

                ):

                    raiseCLIError(ce, msg, details=[

                raise

        return _raise

                    'network interface' in ('%s' % ce).lower()

                ):

                    server_id = kwargs.get('server_id', '<no server>')

                        nic_id,

                        server_id)

                    raiseCLIError(ce, err_msg, details=[

                            server_id,

                            server_id),

                        '      /server addr %s' % server_id])

                raise

        return _raise

                if key and ce.status == 404 and (

                    'metadata' in ('%s' % ce).lower()

                ):

                raise

        return _raise

        :param flavor_id: integer id denoting a preset hardware configuration

        :param metadata: (dict) vm metadata

        :param personality: a list of (file path, file contents) tuples,

        :raises ClientError: wraps request errors

        """

    def update_server_name(self, server_id, new_name):

        """Update the name of the server as reported by the API (does not

        :param server_id: integer (str or int)

        :param flavor_id: integer id denoting a preset hardware configuration

        :param metadata: (dict) vm metadata updated by os/users image metadata

        :param personality: a list of (file path, file contents) tuples,

        :raises ClientError: wraps request errors

        """

        """

        :param server_id: integer (str or int)

        """

        req = {'console': {'type': 'vnc'}}

        r = self.servers_action_post(server_id, json_data=req, success=200)

from sys import stdout

from kamaki.cli.config import Config

def _add_value(foo, value):

            wait_cb = wait_gen

        except Exception:

            stdout.write('%s:' % msg)

        return (wait_bar, wait_cb)

    def _safe_progress_bar_finish(self, progress_bar):