Synnefo » ./kamaki

called *kamaki.clients* and serves as a lib.

A showcase of an application built on *kamaki.clients* is *kamaki.cli*, the

command line interface of kamaki.

the *compute*, *storage* and *image* modules are client implementations for the

OpenStack compute and OpenStack object-store APIs, respectively. The rest of the

modules implement the Synnefo extensions (i.e., *cyclades* and 

*cyclades_rest_api* extents *compute*, *pithos* and *pithos_rest_api* extent

*storage*) or novel Synnefo services (*image* for *plankton*).

There is a client for every API, therefore an external applications should

instantiate they kamaki clients they need. For example, to manage virtual

servers and stored objects / files, an application would probably need to

instantiate the CycladesClient and PithosClient respectively.

    Example 1.1: Instantiate Cyclades and Pithos clients

.. note:: *cyclades* and *pithos* clients inherit ComputeClient from *compute*

    and StorageClient from *storage*, respectively. Separate ComputeClient or

    StorageClient objects should be used only when implementing applications for

    strict OpenStack Compute or Storage services.

In OpenStack, each service (e.g., `compute`, `object-store`, etc.) has a number

of `endpoints`. These `endpoints` are actually URIs that are used by kamaki as

prefixes to form the corresponding API calls. Client applications need just

one of these these `endpoints`, namely the `publicURL`, which is also referred

to as `base_url` in kamaki client libraries.

Here are instructions for getting the base_url for a service::

is an identity server that implements the OpenStack identity API. Therefore, it

can be used to get the `base_url` values needed for initializing kamaki clients.

Kamaki simplifies this process with the astakos client library.

The ``get_service_endpoints`` method is called with the service name as an

argument. Here are the service names for the kamaki clients::

    storage.StorageClient, pithos.PithosClient      -->     object-store

    compute.ComputeClient, cyclades.CycladesClient  -->     compute

    image.ImageClient                               -->     image

    astakos.AstakosClient                           -->     identity, account

At this point we assume that we can initialize a client, so the initialization

step will be omitted in most of the examples that follow.

The next step is to take a look at the member methods of each particular client.

A detailed catalog of the member methods for all client classes can be found at

:ref:`the-client-api-ref`

are used to extract some information through the remote service APIs. The information is then printed to the standard output.

    * A run of examples 1.1 + 1.4 *

The *kamaki.clients* error class is ClientError. A ClientError is raised for

any kind of *kamaki.clients* errors (errors reported by servers, type errors in

    status      An optional error code, e.g., after a server error.

    from kamaki.clients import ClientError

        my_astakos_client.authenticate()

Two servers and a private network

'''''''''''''''''''''''''''''''''

.. code-block:: python

    #! /user/bin/python

    from kamaki.clients.astakos import AstakosClient

    from kamaki.clients.cyclades import CycladesClient

    AUTHENTICATION_URL = 'https://accounts.example.com/identity/v2.0'

    TOKEN = 'replace this with your token'

    astakos = AstakosClient(AUTHENTICATION_URL, TOKEN)

    cyclades_endpoints = user.get_service_endpoints('compute')

    CYCLADES_URL = cyclades_endpoints['publicURL']

    FLAVOR_ID = 'put your flavor id here'

    IMAGE_ID = 'put your image id here'

    cyclades = CycladesClient(CYCLADES_URL, TOKEN)

    srv1 = cyclades.create_server('server 1', FLAVOR_ID, IMAGE_ID)

    srv2 = cyclades.create_server('server 2', FLAVOR_ID, IMAGE_ID)

    srv_state1 = cyclades.wait_server(srv1['id'])

    assert srv_state1 in ('ACTIVE'), 'Server 1 built failure'

    srv_state2 = cyclades.wait_server(srv2['id'])

    assert srv_state2 in ('ACTIVE'), 'Server 2 built failure'

    net = cyclades.create_network('My private network')

    net_state = cyclades.wait_network(net['id'])

    assert net_state in ('ACTIVE', ), 'Network built failure'

    cyclades.connect_server(srv1['id'], net['id'])

    cyclades.connect_server(srv2['id'], net['id'])