Synnefo » ./kamaki

<<<<<<< HEAD

from kamaki.cli.utils import print_dict, print_items

from kamaki.cli.errors import raiseCLIError, CLISyntaxError

from kamaki.cli.commands import _command_init

=======

>>>>>>> develop

<<<<<<< HEAD

    """Authenticate a user, show user information"""

    def main(self, token=None):

        super(self.__class__, self).main()

        try:

            reply = self.client.authenticate(token)

        except Exception as err:

            raiseCLIError(err)

        print_dict(reply)

@command(astakos_cmds)

class astakos_admin_userinfo(_astakos_init):

    """Get user info, provided you have admin privileges"""

    def __init__(self, arguments={}):

        super(self.__class__, self).__init__(arguments)

        self.arguments['email'] = ValueArgument('target user email', '--email')

        self.arguments['username'] = ValueArgument('target username',

            '--username')

    def main(self, admin_token=None):

        super(self.__class__, self).main()

        email = self.get_argument('email')

        username = self.get_argument('username')

        try:

            if email and username:

                raise CLISyntaxError(

                    'Arguments %s and %s are mutually exclusive' % (

                        self.arguments['email'].parsed_name,

                        self.arguments['username'].parsed_name

                        ), importance=1)

            elif email:

                reply = self.client.get_user_by_email(email,

                    admin=True,

                    token=admin_token)

            elif username:

                reply = self.client.get_user_by_username(username,

                    admin=True,

                    token=admin_token)

            else:

                raise CLISyntaxError(

                    'Exactly one of %s or %s is obligatory' % (

                        self.arguments['email'].parsed_name,

                        self.arguments['username'].parsed_name

                        ), importance=1)

        except Exception as err:

            raiseCLIError(err)

        print_dict(reply)

@command(astakos_cmds)

class astakos_service_userinfo(_astakos_init):

    """Get user info with service token"""

    def __init__(self, arguments={}):

        super(self.__class__, self).__init__(arguments)

        self.arguments['email'] = ValueArgument('target user email', '--email')

        self.arguments['username'] = ValueArgument('target username',

            '--username')

    def main(self, service_token=None):

        super(self.__class__, self).main()

        email = self.get_argument('email')

        username = self.get_argument('username')

        try:

            if email and username:

                raise CLISyntaxError(

                    'Arguments %s and %s are mutually exclusive' % (

                        self.arguments['email'].parsed_name,

                        self.arguments['username'].parsed_name

                        ), importance=1)

            elif email:

                reply = self.client.get_user_by_email(email,

                    token=service_token)

            elif username:

                reply = self.client.get_user_by_username(username,

                    token=service_token)

            else:

                raise CLISyntaxError(

                    'Exactly one of %s or %s is obligatory' % (

                        self.arguments['email'].parsed_name,

                        self.arguments['username'].parsed_name

                        ), importance=1)

        except Exception as err:

            raiseCLIError(err)

        print_dict(reply)

@command(astakos_cmds)

class astakos_service_list(_astakos_init):

    """List cloud services associated with astakos"""

    def main(self, token=None):

        super(self.__class__, self).main()

        reply = self.client.list_services(token)

        print_items(reply)

=======

>>>>>>> develop

# Copyright 2011 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 argparse import ArgumentParser

import unittest

import time

import datetime

import os

import sys

try:

    from progress.bar import FillingCirclesBar as IncrementalBar

except ImportError:

    print('No progress bars in testing!')

    pass

from kamaki.clients import ClientError

from kamaki.clients.pithos import PithosClient as pithos

from kamaki.clients.cyclades import CycladesClient as cyclades

from kamaki.clients.image import ImageClient as image

from kamaki.clients.astakos import AstakosClient as astakos

from kamaki.cli.config import Config

TEST_ALL = False

cnf = Config()

global_username = None

token = None

def _init_cnf():

    global cnf

    global global_username

    global_username = cnf.get('test', 'account') or\

        cnf.get('global', 'account')

    global token

    token = cnf.get('test', 'token') or cnf.get('global', 'token')

class testAstakos(unittest.TestCase):

    def setUp(self):

        _init_cnf()

        global cnf

        url = cnf.get('test', 'astakos_url') or cnf.get('astakos', 'url')

        global token

        self.client = astakos(url, token)

    def tearDown(self):

        pass

    def test_authenticate(self):

        r = self.client.authenticate()

        for term in ('username',

            'auth_token_expires',

            'auth_token',

            'auth_token_created',

            'groups',

            'uniq',

            'has_credits',

            'has_signed_terms'):

            self.assertTrue(term in r)

    def test_list_services(self):

        r = self.client.list_services()

        self.assertTrue(len(r) > 1)

        for service in r:

            self.assertTrue(set(('id', 'name')).issubset(service.keys()))

class testImage(unittest.TestCase):

    def setUp(self):

        _init_cnf()

        global cnf

        cyclades_url = cnf.get('compute', 'url')

        url = cnf.get('image', 'url')

        global token

        self.token = token

        self.imgid = 'b2dffe52-64a4-48c3-8a4c-8214cc3165cf'

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

        self.imgname = 'img_%s' % self.now

        global global_username

        self.imglocation = 'pithos://%s/pithos/my.img'\

        % global_username

        self.client = image(url, self.token)

        self.cyclades = cyclades(cyclades_url, self.token)

        self._imglist = {}

    def _prepare_img(self):

        global cnf

        global global_username

        username = global_username.split('@')[0]

        imglocalpath =\

        '/home/%s/src/kamaki-settings/files/centos.diskdump' % username

        f = open(imglocalpath, 'rb')

        pithcli = pithos(cnf.get('store', 'url'),

            self.token,

            global_username,

            'pithos')

        print('\t- Upload an image at %s...' % imglocalpath)

        pithcli.upload_object('my.img', f)

        print('\t- ok')

        f.close()

        self.client.register(self.imgname,

            self.imglocation,

            params=dict(is_public=True))

        img = self._get_img_by_name(self.imgname)

        self._imglist[self.imgname] = img

    def tearDown(self):

        for img in self._imglist.values():

            self.cyclades.delete_image(img['id'])

    def _get_img_by_name(self, name):

        r = self.cyclades.list_images()

        for img in r:

            if img['name'] == name:

                return img

        return None

    def assert_dicts_are_deeply_equal(self, d1, d2):

        for k, v in d1.items():

            self.assertTrue(k in d2)

            if isinstance(v, dict):

                self.assert_dicts_are_deeply_equal(v, d2[k])

            else:

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

    def test_list_public(self):

        """Test list_public"""

        r = self.client.list_public()

        r0 = self.client.list_public(order='-')

        self.assertTrue(len(r) > 0)

        for img in r:

            for term in ('status',

                'name',

                'container_format',

                'disk_format',

                'id',

                'size'):

                self.assertTrue(term in img)

        self.assertTrue(len(r), len(r0))

        r0.reverse()

        for i, img in enumerate(r):

            self.assert_dicts_are_deeply_equal(img, r0[i])

        r1 = self.client.list_public(detail=True)

        for img in r1:

            for term in ('status',

                'name',

                'checksum',

                'created_at',

                'disk_format',

                'updated_at',

                'id',

                'location',

                'container_format',

                'owner',

                'is_public',

                'deleted_at',

                'properties',

                'size'):

                self.assertTrue(term in img)

                for interm in (

                    'osfamily',

                    'users',

                    'os',

                    'root_partition',

                    'description'):

                    self.assertTrue(interm in img['properties'])

        size_max = 1000000000

        r2 = self.client.list_public(filters=dict(size_max=size_max))

        self.assertTrue(len(r2) <= len(r))

        for img in r2:

            self.assertTrue(int(img['size']) <= size_max)

    def test_get_meta(self):

        """Test get_meta"""

        r = self.client.get_meta(self.imgid)

        self.assertEqual(r['id'], self.imgid)

        for term in ('status',

            'name',

            'checksum',

            'updated-at',

            'created-at',

            'deleted-at',

            'location',

            'is-public',

            'owner',

            'disk-format',

            'size',

            'container-format'):

            self.assertTrue(term in r)

            for interm in ('kernel',

                'osfamily',

                'users',

                'gui', 'sortorder',

                'root-partition',

                'os',

                'description'):

                self.assertTrue(interm in r['properties'])

    def test_register(self):

        """Test register"""

        self._prepare_img()

        self.assertTrue(len(self._imglist) > 0)

        for img in self._imglist.values():

            self.assertTrue(img != None)

    def test_reregister(self):

        """Test reregister"""

        self._prepare_img()

        self.client.reregister(self.imglocation,

            properties=dict(my_property='some_value'))

    def test_set_members(self):

        """Test set_members"""

        self._prepare_img()

        members = ['%s@fake.net' % self.now]

        for img in self._imglist.values():

            self.client.set_members(img['id'], members)

            r = self.client.list_members(img['id'])

            self.assertEqual(r[0]['member_id'], members[0])

    def test_list_members(self):

        """Test list_members"""

        self.test_set_members()

    def test_remove_members(self):

        """Test remove_members - NO CHECK"""

        return

        self._prepare_img()

        members = ['%s@fake.net' % self.now, '%s_v2@fake.net' % self.now]

        for img in self._imglist.values():

            self.client.set_members(img['id'], members)

            r = self.client.list_members(img['id'])

            self.assertTrue(len(r) > 1)

            self.client.remove_member(img['id'], members[0])

            r0 = self.client.list_members(img['id'])

            self.assertEqual(len(r), 1 + len(r0))

            self.assertEqual(r0[0]['member_id'], members[1])

    def test_list_shared(self):

        """Test list_shared - NOT CHECKED"""

        #No way to test this, if I dont have member images

        pass

class testCyclades(unittest.TestCase):

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

    def setUp(self):

        """okeanos"""

        _init_cnf()

        global cnf

        url = cnf.get('compute', 'url')

        global token

        global global_username

        self.img = 'b2dffe52-64a4-48c3-8a4c-8214cc3165cf'

        self.img_details = {

            u'status': u'ACTIVE',

            u'updated': u'2012-11-19T13:52:16+00:00',

            u'name': u'Debian Base',

            u'created': u'2012-10-16T09:03:12+00:00',

            u'progress': 100,

            u'id': self.img,

            u'metadata': {

                u'values': {

                    u'kernel': u'2.6.32',

                    u'osfamily': u'linux',

                    u'users': u'root',

                    u'gui': u'No GUI',

                    u'sortorder': u'1',

                    u'os': u'debian',

                    u'root_partition': u'1',

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

                }

            }

        self.flavor_details = {u'name': u'C1R1024D20',

            u'ram': 1024,

            u'id': 1,

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

            u'disk': 20,

            u'cpu': 1}

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

        """okeanos.io"""

        """

        self.img = 'b3e68235-3abd-4d60-adfe-1379a4f8d3fe'

        self.img_details = {

            u'status': u'ACTIVE',

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

            u'name': u'Debian Base',

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

            u'progress': 100,

            u'id': self.img,

            u'metadata': {

                u'values': {

                    u'kernel': u'2.6.32',

                    u'osfamily': u'linux',

                    u'users': u'root',

                    u'gui': u'No GUI',

                    u'sortorder': u'1',

                    u'os': u'debian',

                    u'root_partition': u'1',

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

                }

            }

        """

        self.servers = {}

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

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

        self.servname2 = self.servname1 + '_v2'

        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 = cyclades(url, token)

        pass

    def tearDown(self):

        """Destoy servers used in testing"""

        print

        for netid in self.networks.keys():

            self._delete_network(netid)

        if 0 >= len(self.servers):

            return

        print('-> Found %s servers to delete' % len(self.servers))

        for server in self.servers.values():

            self._delete_server(server['id'])

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

        server = self.client.create_server(servername,

            flavorid,

            imageid,

            personality)

        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

        except:

            return

        self.client.delete_server(servid)

        self._wait_for_status(servid, current_state)

    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):

        sys.stdout.write('\tDelete network %s ' % netid)

        self.client.disconnect_network_nics(netid)

        wait = 3

        while True:

            try:

                self.client.delete_network(netid)

                print('\n\tSUCCESFULL COMMIT delete network %s' % netid)

                break

            except ClientError as err:

                self.assertEqual(err.status, 421)

                time.sleep(wait)

                wait += 3

                sys.stdout.write('.')

    def if_not_all(foo):

        global TEST_ALL

        if TEST_ALL:

            return None

        return foo

    def assert_dicts_are_deeply_equal(self, d1, d2):

        for k, v in d1.items():

            self.assertTrue(k in d2)

            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):

        "Prepare a full Cyclades test scenario"

        global TEST_ALL

        TEST_ALL = True

        self.server1 = self._create_server(self.servname1,

            self.flavorid,

            self.img)

        self.server2 = self._create_server(self.servname2,

            self.flavorid + 2,

            self.img)

        print('testing')

        sys.stdout.write(' test create server')

        self._test_create_server()

        print('...ok')

        sys.stdout.write(' test list servers')

        self._test_list_servers()

        print('...ok')

        print('- wait for test servers to build')

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

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

        print('- ok')

        sys.stdout.write(' test get server details')

        self._test_get_server_details()

        print('...ok')

        sys.stdout.write(' test get image details')

        self._test_get_image_details()

        print('...ok')

        sys.stdout.write(' test update_server_name')

        self._test_update_server_name()

        print('...ok')

        sys.stdout.write(' test reboot_server')

        self._test_reboot_server()

        print('...ok')

        print('- wait for test servers to boot')

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

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

        print('- ok')

        sys.stdout.write(' test create_server_metadata')

        self._test_create_server_metadata()

        print('...ok')

        sys.stdout.write(' test get_server_metadata')

        self._test_get_server_metadata()

        print('...ok')

        sys.stdout.write(' test update_server_metadata')

        self._test_update_server_metadata()

        print('...ok')

        sys.stdout.write(' test delete_server_metadata')

        self._test_delete_server_metadata()

        print('...ok')

        sys.stdout.write(' test list_flavors')

        self._test_list_flavors()

        print('...ok')

        sys.stdout.write(' test get_flavor_details')

        self._test_get_flavor_details()

        print('...ok')

        sys.stdout.write(' test list_images')

        self._test_list_images()

        print('...ok')

        sys.stdout.write(' test get_image_details')

        self._test_get_image_details()

        print('...ok')

        sys.stdout.write(' test get_image_metadata')

        self._test_get_image_metadata()

        print('...ok')

        sys.stdout.write(' test shutdown_server')

        self._test_shutdown_server()

        print('...ok')

        sys.stdout.write(' test start_server')

        self._test_start_server()

        print('...ok')

        sys.stdout.write(' test get_server_console')

        self._test_get_server_console()

        print('...ok')

        sys.stdout.write(' test get_firewall_profile')

        print('\tSKIP')

        #self._test_get_firewall_profile()

        print('...ok')

        sys.stdout.write(' test set_firewall_profile')

        print('\tSKIP')

        #self._test_set_firewall_profile()

        print('...ok')

        sys.stdout.write(' test get_server_stats')

        self._test_get_server_stats()

        print('...ok')

        self.network1 = self._create_network(self.netname1)

        sys.stdout.write(' test create_network')

        self._test_create_network()

        print('...ok')

        print('- wait for network to be activated')

        self._wait_for_network(self.network1['id'], 'ACTIVE')

        print('- ok')

        sys.stdout.write(' test connect_server')

        self._test_connect_server()

        print('...ok')

        sys.stdout.write(' test disconnect_server')

        self._test_disconnect_server()

        print('...ok')

        self.network2 = self._create_network(self.netname2)

        print('- wait for network to be activated')

        self._wait_for_network(self.network2['id'], 'ACTIVE')

        print('- ok')

        sys.stdout.write(' test list_server_nics')

        self._test_list_server_nics()

        print('...ok')

        sys.stdout.write(' test list_networks')

        self._test_list_networks()

        print('...ok')

        sys.stdout.write(' test get_network_details')

        self._test_get_network_details()

        print('...ok')

        sys.stdout.write(' test update_network_name')

        self._test_update_network_name()

        print('...ok')

        """Don't have auth for these:

        sys.stdout.write(' test delete_image')

        self._test_delete_image()

        print('...ok')

        sys.stdout.write(' test create_image_metadata')

        self._test_create_image_metadata()

        print('...ok')

        sys.stdout.write(' test update_image_metadata')

        self._test_update_image_metadata()

        print('...ok')

        sys.stdout.write(' test delete_image_metadata')

        self._test_delete_image_metadata()

        print('...ok')

        """

    @if_not_all

    def test_parallel_creation(self):

        """test create with multiple threads"""

        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 _wait_for_network(self, netid, status):

        wait = 3

        limit = 50

        c = ['|', '/', '-', '\\']

        sys.stdout.write('\t- make net %s %s  ' % (netid, status))

        while wait < limit:

            r = self.client.get_network_details(netid)

            if r['status'] == status:

                print('\tOK')

                return True

            sys.stdout.write('\tit is now %s, wait %ss  '\

                % (r['status'], wait))

            for i in range(wait * 4):

                sys.stdout.write('\b%s' % c[i % 4])

                sys.stdout.flush()

                time.sleep(0.25)

            print('\b ')

            wait += 3

        return False

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

        self._wait_for_network(netid, 'ACTIVE')

        c = ['|', '/', '-', '\\']

        limit = 50

        wait = 3

        largetry = 0

        while wait < limit:

            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 True

            dis = '' if in_creation else 'dis'

            sys.stdout.write('\twait nic %s to %sconnect to %s: %ss  '\

                % (netid, dis, servid, wait))

            for i in range(wait * 4):

                sys.stdout.write('\b%s' % c[i % 4])

                sys.stdout.flush()

                time.sleep(0.25)

            print('\b ')

            wait += 3

            if wait >= limit and largetry < 3:

                wait = 3

                largetry += 1

        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):

        withbar = True

        try:

            wait_bar = IncrementalBar('\tServer[%s] in %s ' % (servid, status))

        except NameError:

            withbar = False

        wait_cb = None

        if withbar:

            wait_bar.start()

            def progress_gen(n):

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

                    yield

                yield

            wait_cb = progress_gen

        time.sleep(0.5)

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

        if withbar:

            wait_bar.finish()

    @if_not_all

    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 + 1,

            self.img)

        self._test_list_servers()

    def _test_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)

    @if_not_all

    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_create_server()

    def _test_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")

    @if_not_all

    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_get_server_details()

    def _test_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")

    @if_not_all

    def test_update_server_name(self):

        """Test update_server_name"""

        self.server1 = self._create_server(self.servname1,

            self.flavorid,

            self.img)

        self._test_update_server_name()

    def _test_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

    @if_not_all

    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_reboot_server()

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

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

    def _test_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'))

    @if_not_all

    def test_get_server_metadata(self):

        """Test get server_metadata"""

        self.server1 = self._create_server(self.servname1,

            self.flavorid,

            self.img)

        self._test_get_server_metadata()

    def _test_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')

    @if_not_all

    def test_create_server_metadata(self):

        """Test create_server_metadata"""

        self.server1 = self._create_server(self.servname1,

            self.flavorid,

            self.img)

        self._test_create_server_metadata()

    def _test_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)

    @if_not_all

    def test_update_server_metadata(self):

        """Test update_server_metadata"""

        self.server1 = self._create_server(self.servname1,

            self.flavorid,

            self.img)

        self._test_update_server_metadata()

    def _test_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')

    @if_not_all

    def test_delete_server_metadata(self):

        """Test delete_server_metadata"""

        self.server1 = self._create_server(self.servname1,

            self.flavorid,

            self.img)

        self._test_delete_server_metadata()

    def _test_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)

    @if_not_all

    def test_list_flavors(self):

        """Test flavors_get"""

        self._test_list_flavors()

    def _test_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])

    @if_not_all

    def test_get_flavor_details(self):

        """Test test_get_flavor_details"""

        self._test_get_flavor_details()

    def _test_get_flavor_details(self):

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

        self.assert_dicts_are_deeply_equal(self.flavor_details, r)

    @if_not_all

    def test_list_images(self):

        """Test list_images"""

        self._test_list_images()

    def _test_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)

    @if_not_all

    def test_get_image_details(self):

        """Test image_details"""

        self._test_get_image_details()

    def _test_get_image_details(self):

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

        r.pop('updated')

        self.assert_dicts_are_deeply_equal(r, self.img_details)

    @if_not_all

    def test_get_image_metadata(self):

        """Test get_image_metadata"""

        self._test_get_image_metadata()

    def _test_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)

    @if_not_all

    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_start_server()

    def _test_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')

    @if_not_all

    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_shutdown_server()

    def _test_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')

    @if_not_all

    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_get_server_console()

    def _test_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)

    @if_not_all

    def test_get_firewall_profile(self):

        """Test get_firewall_profile"""

        self.server1 = self._create_server(self.servname1,

            self.flavorid,

            self.img)

        self._test_get_firewall_profile()

    def _test_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)

    @if_not_all

    def test_set_firewall_profile(self):

        """Test set_firewall_profile"""

        self.server1 = self._create_server(self.servname1,

            self.flavorid,

            self.img)

        self._test_set_firewall_profile()

    def _test_set_firewall_profile(self):

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

        PROFILES = ['DISABLED', 'ENABLED', '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

    @if_not_all

    def test_get_server_stats(self):

        self.server1 = self._create_server(self.servname1,

            self.flavorid,

            self.img)

        self._test_get_server_stats()

    def _test_get_server_stats(self):

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

        for term in ('cpuBar',

        'cpuTimeSeries',

        'netBar',

        'netTimeSeries',

        'refresh'):

            self.assertTrue(term in r)

    @if_not_all

    def test_list_networks(self):

        """Test list_network"""

        self.network1 = self._create_network(self.netname1)

        self._wait_for_network(self.network1['id'], 'ACTIVE')

        self._test_list_networks()

    def _test_list_networks(self):

        r = self.client.list_networks()

        self.assertTrue(len(r) > 1)

        ids = [net['id'] for net in r]

        names = [net['name'] for net in r]

        self.assertTrue('1' in ids)

        #self.assertTrue('public' in names)

        self.assertTrue(self.network1['id'] in ids)

        self.assertTrue(self.network1['name'] in names)

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

        ids = [net['id'] for net in r]

        names = [net['name'] for net in r]

        for net in r:

            self.assertTrue(net['id'] in ids)

            self.assertTrue(net['name'] in names)

            for term in ('status', 'updated', 'created'):

                self.assertTrue(term in net.keys())

    @if_not_all

    def test_create_network(self):

        """Test create_network"""

        self.network1 = self._create_network(self.netname1)

        self._test_create_network()

    def _test_create_network(self):

        nets = self.client.list_networks(self.network1['id'])

        chosen = [net for net in nets if net['id'] == self.network1['id']][0]

        chosen.pop('updated')

        net1 = dict(self.network1)

        net1.pop('updated')

        self.assert_dicts_are_deeply_equal(chosen, net1)

    @if_not_all

    def test_connect_server(self):

        """Test connect_server"""

        self.server1 = self._create_server(self.servname1,

            self.flavorid,

            self.img)

        self.network1 = self._create_network(self.netname1)

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

        self._wait_for_network(self.network1['id'], 'ACTIVE')

        self._test_connect_server()

    def _test_connect_server(self):

        self.client.connect_server(self.server1['id'], self.network1['id'])

        self.assertTrue(self._wait_for_nic(self.network1['id'],

            self.server1['id']))

    @if_not_all

    def test_disconnect_server(self):

        """Test disconnect_server"""

        self.test_connect_server()

        self._test_disconnect_server()

    def _test_disconnect_server(self):

        self.client.disconnect_server(self.server1['id'], self.network1['id'])

        self.assertTrue(self._wait_for_nic(self.network1['id'],

            self.server1['id'],

            in_creation=False))

    @if_not_all

    def test_list_server_nics(self):

        """Test list_server_nics"""

        self.server1 = self._create_server(self.servname1,

            self.flavorid,

            self.img)

        self.network2 = self._create_network(self.netname2)

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

        self._wait_for_network(self.network2['id'], 'ACTIVE')

        self._test_list_server_nics()

    def _test_list_server_nics(self):

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

        len0 = len(r)

        self.client.connect_server(self.server1['id'], self.network2['id'])

        self.assertTrue(self._wait_for_nic(self.network2['id'],

            self.server1['id']))

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

        self.assertTrue(len(r) > len0)

    @if_not_all

    def test_get_network_details(self):

        """Test get_network_details"""

        self.network1 = self._create_network(self.netname1)

        self._test_get_network_details()

    def _test_get_network_details(self):

        r = self.client.get_network_details(self.network1['id'])

        net1 = dict(self.network1)

        net1.pop('status')

        net1.pop('updated', None)

        net1.pop('attachments')

        r.pop('status')

        r.pop('updated', None)

        r.pop('attachments')

        self.assert_dicts_are_deeply_equal(net1, r)

    @if_not_all

    def test_update_network_name(self):

        self.network2 = self._create_network(self.netname2)

        self._test_update_network_name()

    def _test_update_network_name(self):

        updated_name = self.netname2 + '_upd'

        self.client.update_network_name(self.network2['id'], updated_name)

        wait = 3

        c = ['|', '/', '-', '\\']

        r = self.client.get_network_details(self.network2['id'])

        while wait < 50:

            if r['name'] == updated_name:

                break

            sys.stdout.write(

                '\twait for %s renaming (%s->%s) %ss  ' % (self.network2['id'],

                self.network2['name'],

                updated_name, wait))

            for i in range(4 * wait):

                sys.stdout.write('\b%s' % c[i % 4])

                sys.stdout.flush()

                time.sleep(0.25)

            print('')

            wait += 3

            r = self.client.get_network_details(self.network2['id'])

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

    """ Don't have auth to test this

    @if_not_all

    def test_delete_image(self):

        ""Test delete_image""

        self._test_delete_image()

    def _test_delete_image(self):

        images = self.client.list_images()

        self.client.delete_image(images[2]['id'])

        try:

            r = self.client.get_image_details(images[2]['id'], success=(400))

        except ClientError as err:

            self.assertEqual(err.status, 404)

    @if_not_all

    def test_create_image_metadata(self):

        ""Test create_image_metadata""

        self._test_create_image_metadata()

    def _test_create_image_metadata(self):

        r = self.client.create_image_metadata(self.img, 'mykey', 'myval')

        self.assertEqual(r['mykey'], 'myval')

    @if_not_all

    def test_update_image_metadata(self):

        ""Test update_image_metadata""

        self._test_update_image_metadata()

    def _test_update_image_metadata(self):

        r = self.client.create_image_metadata(self.img, 'mykey0', 'myval')

        r = self.client.update_image_metadata(self.img, 'mykey0', 'myval0')

        self.assertEqual(r['mykey0'], 'myval0')

    @if_not_all

    def test_delete_image_metadata(self):

        ""Test delete_image_metadata""

        self._test_delete_image_metadata()

    def _test_delete_image_metadata(self):

        self.client.create_image_metadata(self.img, 'mykey1', 'myval1')

        self.client.delete_image_metadata(self.img, 'mykey1')

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

        self.assertNotEqual('mykey1' in r)

    """

class testPithos(unittest.TestCase):

    """Set up a Pithos+ thorough test"""

    def setUp(self):

        _init_cnf()

        global cnf

        url = cnf.get('store', 'url')

        global token

        global global_username

        account = global_username

        """

        url='https://pithos.okeanos.io/v1'

        """

        """

        def add_handler(name, level, prefix=''):

            h = logging.StreamHandler()

            fmt = logging.Formatter(prefix + '%(message)s')

            h.setFormatter(fmt)

            logger = logging.getLogger(name)

            logger.addHandler(h)

            logger.setLevel(level)

        import logging

        sendlog = logging.getLogger('clients.send')

        recvlog = logging.getLogger('clients.recv')

        add_handler('requests', logging.INFO, prefix='* ')

        add_handler('clients.send', logging.INFO, prefix='> ')

        add_handler('clients.recv', logging.INFO, prefix='< ')

        """

        self.fname = None

        container = None

        self.client = pithos(url, token, account, container)

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

        self.c1 = 'c1_' + unicode(self.now)

        self.c2 = 'c2_' + unicode(self.now)

        self.c3 = 'c3_' + unicode(self.now)

        self.client.create_container(self.c1)

        self.client.create_container(self.c2)

        self.client.create_container(self.c3)

        self.makeNewObject(self.c1, 'test')

        self.makeNewObject(self.c2, 'test')

        self.now_unformated = datetime.datetime.utcnow()

        self.makeNewObject(self.c1, 'test1')

        self.makeNewObject(self.c2, 'test1')

        """Prepare an object to be shared - also its container"""

        self.client.container = self.c1

        self.client.object_post('test',

            update=True,

            permissions={'read': 'someUser'})

        self.makeNewObject(self.c1, 'another.test')

    def makeNewObject(self, container, obj):

        self.client.container = container

        self.client.object_put(obj,

            content_type='application/octet-stream',

            data='file %s that lives in %s' % (obj, container),

            metadata={'incontainer': container})

    def forceDeleteContainer(self, container):

        self.client.container = container

        try:

            r = self.client.list_objects()

        except ClientError:

            return

        for obj in r:

            name = obj['name']

            self.client.del_object(name)

        r = self.client.container_delete()

        self.container = ''

    def tearDown(self):

        """Destroy test cases"""

        if self.fname is not None:

            try:

                os.remove(self.fname)

            except OSError:

                pass

            self.fname = None

        self.forceDeleteContainer(self.c1)

        self.forceDeleteContainer(self.c2)

        try:

            self.forceDeleteContainer(self.c3)

        except ClientError:

            pass

        self.client.container = ''

    def test_000(self):

        """Perform a full Pithos+ kamaki support test"""

    def test_account_head(self):

        """Test account_HEAD"""

        r = self.client.account_head()

        self.assertEqual(r.status_code, 204)

        r = self.client.account_head(until='1000000000')

        self.assertEqual(r.status_code, 204)

        r = self.client.get_account_info(until='1000000000')

        datestring = unicode(r['x-account-until-timestamp'])

        self.assertEqual(u'Sun, 09 Sep 2001 01:46:40 GMT', datestring)

        r = self.client.get_account_quota()

        self.assertTrue('x-account-policy-quota' in r)

        r = self.client.get_account_versioning()

        self.assertTrue('x-account-policy-versioning' in r)

        """Check if(un)modified_since"""

        for format in self.client.DATE_FORMATS:

            now_formated = self.now_unformated.strftime(format)

            r1 = self.client.account_head(if_modified_since=now_formated,

                success=(204, 304, 412))

            sc1 = r1.status_code

            r1.release()

            r2 = self.client.account_head(if_unmodified_since=now_formated,

                success=(204, 304, 412))

            sc2 = r2.status_code

            r2.release()

            self.assertNotEqual(sc1, sc2)

    def test_account_get(self):

        """Test account_GET"""

        #r = self.client.account_get()

        #self.assertEqual(r.status_code, 200)

        r = self.client.list_containers()

        fullLen = len(r)

        self.assertTrue(fullLen > 2)

        r = self.client.account_get(limit=1)

        self.assertEqual(len(r.json), 1)

        r = self.client.account_get(marker='c2_')

        temp_c0 = r.json[0]['name']

        temp_c2 = r.json[2]['name']

        r = self.client.account_get(limit=2, marker='c2_')

        conames = [container['name'] for container in r.json \

            if container['name'].lower().startswith('c2_')]

        self.assertTrue(temp_c0 in conames)