Synnefo » ./kamaki

Kamaki is based on python-objpool. The objpool package is easy to install from source, even on windows platforms:

    $ tar xvfz kamaki-0.7.tar.gz

Kamaki can run on Windows, either on standard Windows console, or inside an improved command line shell. The present guide presents a tested method for setting up kamaki in windows

        Finished processing dependencies for kamaki==0.7

    * If desired, progress version should be 1.0.2 or better

The livetest suite

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

Kamaki contains a live test suite for the kamaki.clients API, where "live" means that the tests are performed against active services that up and running. The live test package is named "livetest", it is accessible as kamaki.clients.livetest and it is designed to check the actual relation between kamaki and synnefo services.

The livetest suite can be activated with the following option on the configuration file::

    [livetest]

    cli=livetest_cli

In most tests, livetest will run as long as an Astakos identity manager service is accessible and kamaki is set up to authenticate a valid token on this server.

In specific, a setup file needs at least the following mandatory settings in the configuration file:

* If authentication information is used for default kamaki clients::

    [astakos]

    url=<Astakos Identity Manager URL>

    token=<A valid user token>

* else if this authentication information is only for testing add this under [livetest]::

    astakos_url=<Astakos Identity Manager URL>

    astakos_token=<A valid user token>

Each service tested in livetest might need some more options under the [livetest] label, as shown bellow:

* kamaki livetest astakos::

    astakos_email = <The valid email of testing user>

    astakos_name = <The exact "real" name of testing user>

    astakos_username = <The username of the testing user>

    astakos_uuid = <The valid unique user id of the testing user>

* kamaki livetest pithos::

    astakos_uuid = <The valid unique user id of the testing user>

* kamaki livetest cyclades / image::

    image_id = <A valid image id used for testing>

    image_local_path = <The local path of the testing image>

    image_details = <A text file containing testing image details in a python dict>

    - example image.details content:

    {

        u'id': u'b3e68235-3abd-4d60-adfe-1379a4f8d3fe',

        u'metadata': {

            u'values': {

                u'description': u'Debian 6.0.6 (Squeeze) Base System',

                u'gui': u'No GUI',

                u'kernel': u'2.6.32',

                u'os': u'debian',

                u'osfamily': u'linux',

                u'root_partition': u'1',

                u'sortorder': u'1',

                u'users': u'root'

            }

        },

        u'name': u'Debian Base',

        u'progress': u'100',

        u'status': u'ACTIVE',

        u'created': u'2012-11-19T14:54:57+00:00',

        u'updated': u'2012-11-19T15:29:51+00:00'

    }

    flavor_details = <A text file containing the testing images' flavor details in a python dict>

    - example flavor.details content:

    {

        u'name': u'C1R1drbd',

        u'ram': 1024,

        u'id': 1,

        u'SNF:disk_template': u'drbd',

        u'disk': 20,

        u'cpu': 1

    }

After setup, kamaki can run all tests::

    $ kamaki livetest all

a specific test (e.g. astakos)::

    $ kamaki livetest astakos

or a specific method from a service (e.g. astakos authenticate)::

    $ kamaki livetest astakos authenticate

The quotaholder client

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

A quotaholder client is introduced as an advanced feature. Quotaholder client is mostly used as a client library for accessing a synnefo quota service, but it can also be allowed as a kamaki command set, but setting the quotaholder.cli and quotaholder.url methods::

Quotaholder is not tested in livetest

# Copyright 2012-2013 GRNET S.A. All rights reserved.

#

# Redistribution and use in source and binary forms, with or

# without modification, are permitted provided that the following

# conditions are met:

#

#   1. Redistributions of source code must retain the above

#      copyright notice, this list of conditions and the following

#      disclaimer.

#

#   2. Redistributions in binary form must reproduce the above

#      copyright notice, this list of conditions and the following

#      disclaimer in the documentation and/or other materials

#      provided with the distribution.

#

# THIS SOFTWARE IS PROVIDED BY GRNET S.A. ``AS IS'' AND ANY EXPRESS

# OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL GRNET S.A OR

# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF

# USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED

# AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN

# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

# POSSIBILITY OF SUCH DAMAGE.

#

# The views and conclusions contained in the software and

# documentation are those of the authors and should not be

# interpreted as representing official policies, either expressed

# or implied, of GRNET S.A.command

from kamaki.cli.commands import errors

from kamaki.cli import command

from kamaki.cli.commands import _command_init

from kamaki.cli.command_tree import CommandTree

from kamaki.clients import livetest

from kamaki.cli.errors import raiseCLIError

livetest_cmds = CommandTree('livetest', 'Test clients on live servers')

_commands = [livetest_cmds]

class _livetest_init(_command_init):

    def _run(self, client, method=None):

        if method:

            livetest._main([client, method], config=self.config)

        else:

            livetest._main([client], config=self.config)

    def main(self, client, method=None):

        return self._run(client, method)

@command(livetest_cmds)

class livetest_error(_livetest_init):

    """Create an error message with optional message"""

    @errors.generic.all

    def _run(self, errmsg='', importance=0, index=0):

        l = [1, 2]

        try:

            l[int(index)]

        except Exception as err:

            raiseCLIError(err, errmsg, importance)

        raiseCLIError(None, errmsg, importance)

    def main(self, errmsg='', importance=0, index=0):

        self._run(errmsg, importance, index)

@command(livetest_cmds)

class livetest_args(_livetest_init):

    """Test how arguments are treated by kamaki"""

    @errors.generic.all

    def _run(self, *args):

        print(args)

    def main(self, *args):

        self._run(args)

@command(livetest_cmds)

class livetest_all(_livetest_init):

    """test all clients"""

    @errors.generic.all

    def _run(self):

        for client in ('pithos', 'cyclades', 'image', 'astakos'):

            super(self.__class__, self)._run(client)

    def main(self):

        self._run()

@command(livetest_cmds)

class livetest_pithos(_livetest_init):

    """ test Pithos client"""

    @errors.generic.all

    def _run(self, method=None):

        super(self.__class__, self)._run('pithos', method)

    def main(self, method=None):

        self._run(method)

@command(livetest_cmds)

class livetest_cyclades(_livetest_init):

    """ test Cyclades client"""

    @errors.generic.all

    def _run(self, method=None):

        super(self.__class__, self)._run('cyclades', method)

    def main(self, method=None):

        self._run(method)

@command(livetest_cmds)

class livetest_image(_livetest_init):

    """ test Image client"""

    @errors.generic.all

    def _run(self, method=None):

        super(self.__class__, self)._run('image', method)

    def main(self, method=None):

        self._run(method)

@command(livetest_cmds)

class livetest_astakos(_livetest_init):

    """ test Astakos client"""

    @errors.generic.all

    def _run(self, method=None):

        super(self.__class__, self)._run('astakos', method)

    def main(self, method=None):

        self._run(method)

@command(livetest_cmds)

class livetest_prints(_livetest_init):

    """ user-test print methods for lists and dicts"""

    d1 = {'key0a': 'val0a', 'key0b': 'val0b', 'key0c': 'val0c'}

    l1 = [1, 'string', '3', 'many (2 or 3) numbers and strings combined', 5]

    d2 = {'id': 'val0a', 'key0b': d1, 'title': l1}

    l2 = [d2, l1, d1]

    spr_msg = 'long key of size 75 characters is used to check the effects on'

    spr_msg += ' total result for long messages that drive pep8 completely mad'

    d3 = {'dict 1': d1, 'dict 2': d2, 'list2': l2, spr_msg: l1}

    @errors.generic.all

    def _run(self):

        from kamaki.cli.utils import print_dict, print_list, print_items

        print('Test simple dict:\n- - -')

        print_dict(self.d1)

        print('- - -\n')

        print('\nTest simple list:\n- - -')

        print_list(self.l1)

        print('- - -\n')

        print('\nTest 2-level dict:\n- - -')

        print_dict(self.d2)

        print('- - -\n')

        print('\nTest non-trivial list:\n- - -')

        print_list(self.l2)

        print('- - -')

        print('\nTest extreme dict:\n- - -')

        print_dict(self.d3)

        print('- - -\n')

        print('Test simple enumerated dict:\n- - -')

        print_dict(self.d1, with_enumeration=True)

        print('- - -\n')

        print('\nTest simple enumerated list:\n- - -')

        print_list(self.l1, with_enumeration=True)

        print('- - -\n')

        print('Test non-trivial deep-enumerated dict:\n- - -')

        print_dict(self.d2, with_enumeration=True, recursive_enumeration=True)

        print('- - -\n')

        print('\nTest non-trivial enumerated list:\n- - -')

        print_list(self.l2, with_enumeration=True)

        print('- - -\n')

        print('\nTest print_items with id:\n- - -')

        print_items([

            {'id': '42', 'title': 'lalakis 1', 'content': self.d1},

            {'id': '142', 'title': 'lalakis 2', 'content': self.d2}])

        print('- - -')

        print('\nTest print_items with id and enumeration:\n- - -')

        print_items(

            [

                {'id': '42', 'title': 'lalakis 1', 'content': self.d1},

                {'id': '142', 'title': 'lalakis 2', 'content': self.d2}],

            with_enumeration=True)

        print('- - -')

        print('\nTest print_items with id, title and redundancy:\n- - -')

        print_items(

            [

                {'id': '42', 'title': 'lalakis 1', 'content': self.d1},

                {'id': '142', 'title': 'lalakis 2', 'content': self.d2}],

            title=('id', 'title'),

            with_redundancy=True)

        print('- - -')

        print('\nTest print_items with lists- - -')

        print_items([['i00', 'i01', 'i02'], [self.l2, 'i11', self.d1], 3])

        print('- - -')

    def main(self):

        self._run()

# Copyright 2012-2013 GRNET S.A. All rights reserved.

#

# Redistribution and use in source and binary forms, with or

# without modification, are permitted provided that the following

# conditions are met:

#

#   1. Redistributions of source code must retain the above

#      copyright notice, this list of conditions and the following

#      disclaimer.

#

#   2. Redistributions in binary form must reproduce the above

#      copyright notice, this list of conditions and the following

#      disclaimer in the documentation and/or other materials

#      provided with the distribution.

#

# THIS SOFTWARE IS PROVIDED BY GRNET S.A. ``AS IS'' AND ANY EXPRESS

# OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL GRNET S.A OR

# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF

# USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED

# AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN

# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

# POSSIBILITY OF SUCH DAMAGE.

#

# The views and conclusions contained in the software and

# documentation are those of the authors and should not be

# interpreted as representing official policies, either expressed

# or implied, of GRNET S.A.

import inspect

from unittest import TestCase, TestSuite, TextTestRunner

from argparse import ArgumentParser

from sys import stdout

from kamaki.cli.config import Config

from kamaki.cli.utils import spiner

def _add_value(foo, value):

    def wrap(self):

        return foo(self, value)

    return wrap

class Generic(TestCase):

    _waits = []

    _cnf = None

    _grp = None

    _fetched = {}

    def __init__(self, specific=None, config=None, group=None):

        super(Generic, self).__init__(specific)

        self._cnf = config or Config()

        self._grp = group

        self._waits.append(0.71828)

        for i in range(10):

            self._waits.append(self._waits[-1] * 2.71828)

    def __getitem__(self, key):

        key = self._key(key)

        try:

            r = self._fetched[key]

            return r

            return self._fetched[key]

        except KeyError:

            r = self._get_from_cnf(key)

            return r

            return self._get_from_cnf(key)

    def _key(self, key):

        return ('', key) if isinstance(key, str)\

            else ('', key[0]) if len(key) == 1\

            else key

    def _get_from_cnf(self, key):

        val = 0

        if key[0]:

            keystr = '%s_%s' % key

            val = self._cnf.get('livetest', keystr) or self._cnf.get(*key)

        if not val:

            val = self._cnf.get('livetest', key[1]) or self._cnf.get(

                'global',

                key[1])

        self._fetched[key] = val

        return val

    def _safe_progress_bar(self, msg):

        """Try to get a progress bar, but do not raise errors"""

        try:

            from progress.bar import ShadyBar

            wait_bar = ShadyBar(msg)

            def wait_gen(n):

                for i in wait_bar.iter(range(int(n))):

                    yield

                yield

            wait_cb = wait_gen

        except Exception:

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

            (wait_bar, wait_cb) = (None, spiner)

        return (wait_bar, wait_cb)

    def _safe_progress_bar_finish(self, progress_bar):

        try:

            progress_bar.finish()

        except Exception:

            print('\b DONE')

    def do_with_progress_bar(self, action, msg, items):

        if not items:

            print('%s: DONE' % msg)

            return

        (action_bar, action_cb) = self._safe_progress_bar(msg)

        action_gen = action_cb(len(items))

        try:

            action_gen.next()

        except Exception:

            pass

        for item in items:

            action(item)

            action_gen.next()

        self._safe_progress_bar_finish(action_bar)

    def assert_dicts_are_deeply_equal(self, d1, d2):

        (st1, st2) = (set(d1.keys()), set(d2.keys()))

        diff1 = st1.difference(st2)

        diff2 = st2.difference(st1)

        self.assertTrue(

            not (diff1 or diff2),

            'Key differences:\n\td1-d2=%s\n\td2-d1=%s' % (diff1, diff2))

        for k, v in d1.items():

            if isinstance(v, dict):

                self.assert_dicts_are_deeply_equal(v, d2[k])

            else:

                self.assertEqual(unicode(v), unicode(d2[k]))

    def test_000(self):

        print('')

        methods = [method for method in inspect.getmembers(

            self,

            predicate=inspect.ismethod) if method[0].startswith('_test_')]

        failures = 0

        for method in methods:

            stdout.write('Test %s ' % method[0][6:])

            stdout.flush()

            try:

                method[1]()

                print(' ...ok')

            except AssertionError:

                print('  FAIL: %s (%s)' % (method[0], method[1]))

                failures += 1

        if failures:

            raise AssertionError('%s failures' % failures)

def init_parser():

    parser = ArgumentParser(add_help=False)

    parser.add_argument(

        '-h', '--help',

        dest='help',

        action='store_true',

        default=False,

        help="Show this help message and exit")

    return parser

def main(argv):

    _main(argv, config=None)

def _main(argv, config=None):

    suiteFew = TestSuite()

    if len(argv) == 0 or argv[0] == 'pithos':

        from kamaki.clients.livetest.pithos import Pithos

        test_method = 'test_%s' % (argv[1] if len(argv) > 1 else '000')

        suiteFew.addTest(Pithos(test_method, config))

    if len(argv) == 0 or argv[0] == 'cyclades':

        from kamaki.clients.livetest.cyclades import Cyclades

        test_method = 'test_%s' % (argv[1] if len(argv) > 1 else '000')

        suiteFew.addTest(Cyclades(test_method, config))

    if len(argv) == 0 or argv[0] == 'image':

        from kamaki.clients.livetest.image import Image

        test_method = 'test_%s' % (argv[1] if len(argv) > 1 else '000')

        suiteFew.addTest(Image(test_method, config))

    if len(argv) == 0 or argv[0] == 'astakos':

        from kamaki.clients.livetest.astakos import Astakos

        test_method = 'test_%s' % (argv[1] if len(argv) > 1 else '000')

        suiteFew.addTest(Astakos(test_method, config))

    TextTestRunner(verbosity=2).run(suiteFew)

if __name__ == '__main__':

    parser = init_parser()

    args, argv = parser.parse_known_args()

    if len(argv) > 2 or getattr(args, 'help') or len(argv) < 1:

        raise Exception('\tusage: livetest <group> [command]')

    main(argv)

# Copyright 2012-2013 GRNET S.A. All rights reserved.

#

# Redistribution and use in source and binary forms, with or

# without modification, are permitted provided that the following

# conditions are met:

#

#   1. Redistributions of source code must retain the above

#      copyright notice, this list of conditions and the following

#      disclaimer.

#

#   2. Redistributions in binary form must reproduce the above

#      copyright notice, this list of conditions and the following

#      disclaimer in the documentation and/or other materials

#      provided with the distribution.

#

# THIS SOFTWARE IS PROVIDED BY GRNET S.A. ``AS IS'' AND ANY EXPRESS

# OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL GRNET S.A OR

# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF

# USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED

# AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN

# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

# POSSIBILITY OF SUCH DAMAGE.

#

# The views and conclusions contained in the software and

# documentation are those of the authors and should not be

# interpreted as representing official policies, either expressed

# or implied, of GRNET S.A.

from kamaki.clients import livetest

from kamaki.clients.astakos import AstakosClient

class Astakos(livetest.Generic):

    def setUp(self):

        self.client = AstakosClient(

            self['astakos', 'url'],

            self['astakos', 'token'])

    def test_authenticate(self):

        self._test_0010_authenticate()

    def _test_0010_authenticate(self):

        r = self.client.authenticate()

        for term in (

                'name',

                'username',

                'auth_token_expires',

                'auth_token_created',

                'uuid',

                'id',

                'email'):

            self.assertTrue(term in r)

    def test_info(self):

        self._test_0020_info()

    def _test_0020_info(self):

        self.assertTrue(set([

            'name',

            'username',

            'uuid']).issubset(self.client.info().keys()))

    def test_get(self):

        self._test_0020_get()

    def _test_0020_get(self):

        for term in ('uuid', 'name', 'username'):

            self.assertEqual(

                self.client.term(term, self['astakos', 'token']),

                self['astakos', term])

        self.assertTrue(self['astakos', 'email'] in self.client.term('email'))

    def test_list(self):

        self.client.authenticate()

        self._test_0020_list()

    def _test_0020_list(self):

        terms = set(['name', 'username', 'uuid', 'email', 'auth_token'])

        uuid = 0

        for r in self.client.list():

            self.assertTrue(terms.issubset(r.keys()))

            self.assertTrue(uuid != r['uuid'] if uuid else True)

            uuid = r['uuid']

# Copyright 2012-2013 GRNET S.A. All rights reserved.

#

# Redistribution and use in source and binary forms, with or

# without modification, are permitted provided that the following

# conditions are met:

#

#   1. Redistributions of source code must retain the above

#      copyright notice, this list of conditions and the following

#      disclaimer.

#

#   2. Redistributions in binary form must reproduce the above

#      copyright notice, this list of conditions and the following

#      disclaimer in the documentation and/or other materials

#      provided with the distribution.

#

# THIS SOFTWARE IS PROVIDED BY GRNET S.A. ``AS IS'' AND ANY EXPRESS

# OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL GRNET S.A OR

# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF

# USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED

# AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN

# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

# POSSIBILITY OF SUCH DAMAGE.

#

# The views and conclusions contained in the software and

# documentation are those of the authors and should not be

# interpreted as representing official policies, either expressed

# or implied, of GRNET S.A.

import time

from kamaki.clients import livetest, ClientError

from kamaki.clients.cyclades import CycladesClient

class Cyclades(livetest.Generic):

    """Set up a Cyclades thorough test"""

    def setUp(self):

        print

        with open(self['image', 'details']) as f:

            self.img_details = eval(f.read())

        self.img = self.img_details['id']

        with open(self['flavor', 'details']) as f:

            self._flavor_details = eval(f.read())

        self.PROFILES = ('ENABLED', 'DISABLED', 'PROTECTED')

        self.servers = {}

        self.now = time.mktime(time.gmtime())

        self.servname1 = 'serv' + unicode(self.now)

        self.servname2 = self.servname1 + '_v2'

        self.servname1 += '_v1'

        self.flavorid = 1

        #servers have to be created at the begining...

        self.networks = {}

        self.netname1 = 'net' + unicode(self.now)

        self.netname2 = 'net' + unicode(self.now) + '_v2'

        self.client = CycladesClient(self['compute', 'url'], self['token'])

    def tearDown(self):

        """Destoy servers used in testing"""

        for net in self.networks.keys():

            self._delete_network(net)

        for server in self.servers.values():

            self._delete_server(server['id'])

            print('DEL VM %s (%s)' % (server['id'], server['name']))

    def test_000(self):

        "Prepare a full Cyclades test scenario"

        self.server1 = self._create_server(

            self.servname1,

            self.flavorid,

            self.img)

        self.server2 = self._create_server(

            self.servname2,

            self.flavorid + 2,

            self.img)

        super(self.__class__, self).test_000()

    def _create_server(self, servername, flavorid, imageid, personality=None):

        server = self.client.create_server(

            servername,

            flavorid,

            imageid,

            personality)

        print('CREATE VM %s (%s)' % (server['id'], server['name']))

        self.servers[servername] = server

        return server

    def _delete_server(self, servid):

        try:

            current_state = self.client.get_server_details(servid)

            current_state = current_state['status']

            if current_state == 'DELETED':

                return

            self.client.delete_server(servid)

            self._wait_for_status(servid, current_state)

            self.client.delete_server(servid)

        except:

            return

    def _create_network(self, netname, **kwargs):

        net = self.client.create_network(netname, **kwargs)

        self.networks[net['id']] = net

        return net

    def _delete_network(self, netid):

        if not netid in self.networks:

            return None

        print('Disconnect nics of network %s' % netid)

        self.client.disconnect_network_nics(netid)

        def netwait(wait):

            try:

                self.client.delete_network(netid)

            except ClientError:

                time.sleep(wait)

        self.do_with_progress_bar(

            netwait,

            'Delete network %s' % netid,

            self._waits[:7])

        return self.networks.pop(netid)

    def _wait_for_network(self, netid, status):

        def netwait(wait):

            r = self.client.get_network_details(netid)

            if r['status'] == status:

                return

            time.sleep(wait)

        self.do_with_progress_bar(

            netwait,

            'Wait network %s to reach status %s' % (netid, status),

            self._waits[:5])

    def _wait_for_nic(self, netid, servid, in_creation=True):

        self._wait_for_network(netid, 'ACTIVE')

        def nicwait(wait):

            nics = self.client.list_server_nics(servid)

            for net in nics:

                found_nic = net['network_id'] == netid

                if (in_creation and found_nic) or not (

                        in_creation or found_nic):

                    return

            time.sleep(wait)

        self.do_with_progress_bar(

            nicwait,

            'Wait nic-%s-%s to %sconnect' % (

                netid,

                servid,

                '' if in_creation else 'dis'),

            self._waits[:5])

        for net in self.client.list_server_nics(servid):

            if netid == net['network_id']:

                return True

        return False

    def _has_status(self, servid, status):

        r = self.client.get_server_details(servid)

        return r['status'] == status

    def _wait_for_status(self, servid, status):

        (wait_bar, wait_cb) = self._safe_progress_bar(

            'Server %s in %s' % (servid, status))

        self.client.wait_server(servid, status, wait_cb=wait_cb)

        self._safe_progress_bar_finish(wait_bar)

    def test_parallel_creation(self):

        """test create with multiple threads

        Do not use this in regular livetest

        """

        from kamaki.clients import SilentEvent

        c1 = SilentEvent(

            self._create_server,

            self.servname1,

            self.flavorid,

            self.img)

        c2 = SilentEvent(

            self._create_server,

            self.servname2,

            self.flavorid + 2,

            self.img)

        c3 = SilentEvent(

            self._create_server,

            self.servname1,

            self.flavorid,

            self.img)

        c4 = SilentEvent(

            self._create_server,

            self.servname2,

            self.flavorid + 2,

            self.img)

        c5 = SilentEvent(

            self._create_server,

            self.servname1,

            self.flavorid,

            self.img)

        c6 = SilentEvent(

            self._create_server,

            self.servname2,

            self.flavorid + 2,

            self.img)

        c7 = SilentEvent(

            self._create_server,

            self.servname1,

            self.flavorid,

            self.img)

        c8 = SilentEvent(

            self._create_server,

            self.servname2,

            self.flavorid + 2,

            self.img)

        c1.start()

        c2.start()

        c3.start()

        c4.start()

        c5.start()

        c6.start()

        c7.start()

        c8.start()

    def test_create_server(self):

        """Test create_server"""

        self.server1 = self._create_server(

            self.servname1,

            self.flavorid,

            self.img)

        self._wait_for_status(self.server1['id'], 'BUILD')

        self._test_0010_create_server()

    def _test_0010_create_server(self):

        self.assertEqual(self.server1["name"], self.servname1)

        self.assertEqual(self.server1["flavorRef"], self.flavorid)

        self.assertEqual(self.server1["imageRef"], self.img)

        self.assertEqual(self.server1["status"], "BUILD")

    def test_list_servers(self):

        """Test list servers"""

        self.server1 = self._create_server(

            self.servname1,

            self.flavorid,

            self.img)

        self.server2 = self._create_server(

            self.servname2,

            self.flavorid + 2,

            self.img)

        self._test_0020_list_servers()

    def _test_0020_list_servers(self):

        servers = self.client.list_servers()

        dservers = self.client.list_servers(detail=True)

        """detailed and simple are same size"""

        self.assertEqual(len(dservers), len(servers))

        for i in range(len(servers)):

            for field in (

                    'created',

                    'flavorRef',

                    'hostId',

                    'imageRef',

                    'progress',

                    'status',

                    'updated'):

                self.assertFalse(field in servers[i])

                self.assertTrue(field in dservers[i])

        """detailed and simple contain same names"""

        names = sorted(map(lambda x: x["name"], servers))

        dnames = sorted(map(lambda x: x["name"], dservers))

        self.assertEqual(names, dnames)

    def _test_0030_wait_test_servers_to_build(self):

        """Pseudo-test to wait for VMs to load"""

        print('')

        self._wait_for_status(self.server1['id'], 'BUILD')

        self._wait_for_status(self.server2['id'], 'BUILD')

    def test_get_server_details(self):

        """Test get_server_details"""

        self.server1 = self._create_server(

            self.servname1,

            self.flavorid,

            self.img)

        self._wait_for_status(self.server1['id'], 'BUILD')

        self._test_0040_get_server_details()

    def _test_0040_get_server_details(self):

        r = self.client.get_server_details(self.server1['id'])

        self.assertEqual(r["name"], self.servname1)

        self.assertEqual(r["flavorRef"], self.flavorid)

        self.assertEqual(r["imageRef"], self.img)

        self.assertEqual(r["status"], "ACTIVE")

    def test_update_server_name(self):

        """Test update_server_name"""

        self.server1 = self._create_server(

            self.servname1,

            self.flavorid,

            self.img)

        self._test_0050_update_server_name()

    def _test_0050_update_server_name(self):

        new_name = self.servname1 + '_new_name'

        self.client.update_server_name(self.server1['id'], new_name)

        r = self.client.get_server_details(

            self.server1['id'],

            success=(200, 400))

        self.assertEqual(r['name'], new_name)

        changed = self.servers.pop(self.servname1)

        changed['name'] = new_name

        self.servers[new_name] = changed

    def test_reboot_server(self):

        """Test reboot server"""

        self.server1 = self._create_server(

            self.servname1,

            self.flavorid,

            self.img)

        self._wait_for_status(self.server1['id'], 'BUILD')

        self.server2 = self._create_server(

            self.servname2,

            self.flavorid + 1,

            self.img)

        self._wait_for_status(self.server2['id'], 'BUILD')

        self._test_0060_reboot_server()

        self._wait_for_status(self.server1['id'], 'REBOOT')

        self._wait_for_status(self.server2['id'], 'REBOOT')

    def _test_0060_reboot_server(self):

        self.client.reboot_server(self.server1['id'])

        self.assertTrue(self._has_status(self.server1['id'], 'REBOOT'))

        self.client.reboot_server(self.server2['id'], hard=True)

        self.assertTrue(self._has_status(self.server2['id'], 'REBOOT'))

    def _test_0070_wait_test_servers_to_reboot(self):

        """Pseudo-test to wait for VMs to load"""

        print('')

        self._wait_for_status(self.server1['id'], 'REBOOT')

        self._wait_for_status(self.server2['id'], 'REBOOT')

    def test_create_server_metadata(self):

        """Test create_server_metadata"""

        self.server1 = self._create_server(

            self.servname1,

            self.flavorid,

            self.img)

        self._test_0080_create_server_metadata()

    def _test_0080_create_server_metadata(self):

        r1 = self.client.create_server_metadata(

            self.server1['id'],

            'mymeta',

            'mymeta val')

        self.assertTrue('mymeta' in r1)

        r2 = self.client.get_server_metadata(self.server1['id'], 'mymeta')

        self.assert_dicts_are_deeply_equal(r1, r2)

    def test_get_server_metadata(self):

        """Test get server_metadata"""

        self.server1 = self._create_server(

            self.servname1,

            self.flavorid,

            self.img)

        self._test_0090_get_server_metadata()

    def _test_0090_get_server_metadata(self):

        self.client.create_server_metadata(

            self.server1['id'],

            'mymeta_0',

            'val_0')

        r = self.client.get_server_metadata(self.server1['id'], 'mymeta_0')

        self.assertEqual(r['mymeta_0'], 'val_0')

    def test_update_server_metadata(self):

        """Test update_server_metadata"""

        self.server1 = self._create_server(

            self.servname1,

            self.flavorid,

            self.img)

        self._test_0100_update_server_metadata()

    def _test_0100_update_server_metadata(self):

        r1 = self.client.create_server_metadata(

            self.server1['id'],

            'mymeta3',

            'val2')

        self.assertTrue('mymeta3'in r1)

        r2 = self.client.update_server_metadata(

            self.server1['id'],

            mymeta3='val3')

        self.assertTrue(r2['mymeta3'], 'val3')

    def test_delete_server_metadata(self):

        """Test delete_server_metadata"""

        self.server1 = self._create_server(

            self.servname1,

            self.flavorid,

            self.img)

        self._test_0110_delete_server_metadata()

    def _test_0110_delete_server_metadata(self):

        r1 = self.client.create_server_metadata(

            self.server1['id'],

            'mymeta',

            'val')

        self.assertTrue('mymeta' in r1)

        self.client.delete_server_metadata(self.server1['id'], 'mymeta')

        try:

            self.client.get_server_metadata(self.server1['id'], 'mymeta')

            raise ClientError('Wrong Error', status=100)

        except ClientError as err:

            self.assertEqual(err.status, 404)

    def test_list_flavors(self):

        """Test flavors_get"""

        self._test_0120_list_flavors()

    def _test_0120_list_flavors(self):

        r = self.client.list_flavors()

        self.assertTrue(len(r) > 1)

        r = self.client.list_flavors(detail=True)

        self.assertTrue('SNF:disk_template' in r[0])

    def test_get_flavor_details(self):

        """Test test_get_flavor_details"""

        self._test_0130_get_flavor_details()

    def _test_0130_get_flavor_details(self):

        r = self.client.get_flavor_details(self.flavorid)

        self.assert_dicts_are_deeply_equal(self._flavor_details, r)

    def test_list_images(self):

        """Test list_images"""

        self._test_0140_list_images()

    def _test_0140_list_images(self):

        r = self.client.list_images()

        self.assertTrue(len(r) > 1)

        r = self.client.list_images(detail=True)

        for detailed_img in r:

            if detailed_img['id'] == self.img:

                break

        self.assert_dicts_are_deeply_equal(detailed_img, self.img_details)

    def test_get_image_details(self):

        """Test image_details"""

        self._test_0150_get_image_details()

    def _test_0150_get_image_details(self):

        r = self.client.get_image_details(self.img)

        self.assert_dicts_are_deeply_equal(r, self.img_details)

    def test_get_image_metadata(self):

        """Test get_image_metadata"""

        self._test_0160_get_image_metadata()

    def _test_0160_get_image_metadata(self):

        r = self.client.get_image_metadata(self.img)

        self.assert_dicts_are_deeply_equal(

            self.img_details['metadata']['values'], r)

        for key, val in self.img_details['metadata']['values'].items():

            r = self.client.get_image_metadata(self.img, key)

            self.assertEqual(r[key], val)

    def test_shutdown_server(self):

        """Test shutdown_server"""

        self.server1 = self._create_server(

            self.servname1,

            self.flavorid,

            self.img)

        self._wait_for_status(self.server1['id'], 'BUILD')

        self._test_0170_shutdown_server()

    def _test_0170_shutdown_server(self):

        self.client.shutdown_server(self.server1['id'])

        self._wait_for_status(self.server1['id'], 'ACTIVE')

        r = self.client.get_server_details(self.server1['id'])

        self.assertEqual(r['status'], 'STOPPED')

    def test_start_server(self):

        """Test start_server"""

        self.server1 = self._create_server(

            self.servname1,

            self.flavorid,

            self.img)

        self._wait_for_status(self.server1['id'], 'BUILD')

        self.client.shutdown_server(self.server1['id'])

        self._wait_for_status(self.server1['id'], 'ACTIVE')

        self._test_0180_start_server()

    def _test_0180_start_server(self):

        self.client.start_server(self.server1['id'])

        self._wait_for_status(self.server1['id'], 'STOPPED')

        r = self.client.get_server_details(self.server1['id'])

        self.assertEqual(r['status'], 'ACTIVE')

    def test_get_server_console(self):

        """Test get_server_console"""

        self.server2 = self._create_server(

            self.servname2,

            self.flavorid + 2,

            self.img)

        self._wait_for_status(self.server2['id'], 'BUILD')

        self._test_0190_get_server_console()

    def _test_0190_get_server_console(self):

        r = self.client.get_server_console(self.server2['id'])

        self.assertTrue('host' in r)

        self.assertTrue('password' in r)

        self.assertTrue('port' in r)

        self.assertTrue('type' in r)

    def test_get_firewall_profile(self):

        """Test get_firewall_profile"""

        self.server1 = self._create_server(

            self.servname1,

            self.flavorid,

            self.img)

        self._test_0200_get_firewall_profile()

    def _test_0200_get_firewall_profile(self):

        self._wait_for_status(self.server1['id'], 'BUILD')

        fprofile = self.client.get_firewall_profile(self.server1['id'])

        self.assertTrue(fprofile in self.PROFILES)

    def test_set_firewall_profile(self):

        """Test set_firewall_profile"""

        self.server1 = self._create_server(

            self.servname1,

            self.flavorid,

            self.img)

        self._test_0210_set_firewall_profile()

    def _test_0210_set_firewall_profile(self):

        self._wait_for_status(self.server1['id'], 'BUILD')

        PROFILES = ['DISABLED', 'ENABLED', 'DISABLED', 'PROTECTED']

        fprofile = self.client.get_firewall_profile(self.server1['id'])

        print('')

        count_success = 0

        for counter, fprofile in enumerate(PROFILES):

            npos = counter + 1

            try:

                nprofile = PROFILES[npos]

            except IndexError:

                nprofile = PROFILES[0]

            print('\tprofile swap %s: %s -> %s' % (npos, fprofile, nprofile))

            self.client.set_firewall_profile(self.server1['id'], nprofile)

            time.sleep(0.5)

            self.client.reboot_server(self.server1['id'], hard=True)

            time.sleep(1)

            self._wait_for_status(self.server1['id'], 'REBOOT')

            time.sleep(0.5)

            changed = self.client.get_firewall_profile(self.server1['id'])

            try:

                self.assertEqual(changed, nprofile)

            except AssertionError as err:

                if count_success:

                    print('\tFAIL in swap #%s' % npos)

                    break

                else:

                    raise err

            count_success += 1

    def test_get_server_stats(self):

        self.server1 = self._create_server(

            self.servname1,

            self.flavorid,

            self.img)