Synnefo » ./kamaki

    - server: firewall, metadata

- Add a _format_image_headers method and use it in image_register and get_meta

    for uniform image meta output [#3797]

Features:

# interpreted as representing official policies, either expressed

# or implied, of GRNET S.A.command

from kamaki.cli.utils import print_json, print_items

from kamaki.cli.argument import FlagArgument

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

    )

    @errors.generic.all

    @errors.cyclades.connection

    @errors.cyclades.date

    def _run(self):

        servers = self.client.list_servers(self['detail'], self['since'])

        kwargs = dict(with_enumeration=self['enum'])

        if self['more']:

            kwargs['page_size'] = self['limit'] if self['limit'] else 10

    - hardware flavor and os image ids

    """

    @errors.generic.all

    @errors.cyclades.connection

    @errors.cyclades.server_id

    def _run(self, server_id):

    def main(self, server_id):

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

    @errors.plankton.id

    @errors.cyclades.flavor_id

    def _run(self, name, flavor_id, image_id):

    def main(self, name, flavor_id, image_id):

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

    @errors.cyclades.connection

    @errors.cyclades.server_id

    def _run(self, server_id):

    def main(self, server_id):

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

    @errors.cyclades.metadata

    def _run(self, server_id, key=''):

        self._print(

    def main(self, server_id, key=''):

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

                        '/server metadata set <server id>'

                        'key1=value1 key2=value2'])

        self._print(

    def main(self, server_id, *key_equals_val):

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

    @errors.cyclades.connection

    @errors.cyclades.server_id

    def _run(self, server_id):

    def main(self, server_id):

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

    @errors.cyclades.connection

    @errors.cyclades.flavor_id

    def _run(self, flavor_id):

    def main(self, flavor_id):

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

    To get a list of available networks and network ids, try /network list

    """

    @errors.generic.all

    @errors.cyclades.connection

    @errors.cyclades.network_id

    def _run(self, network_id):

        network = self.client.get_network_details(int(network_id))

        self._print(network, print_dict, exclude=('id'))

    def main(self, network_id):

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

    )

    @errors.generic.all

    @errors.cyclades.connection

    def _run(self):

        networks = self.client.list_networks(self['detail'])

        kwargs = dict(with_enumeration=self['enum'])

        if self['more']:

            kwargs['page_size'] = self['limit'] or 10

    @errors.cyclades.connection

    @errors.cyclades.network_max

    def _run(self, name):

            name,

            cidr=self['cidr'],

            gateway=self['gateway'],

            dhcp=self['dhcp'],

    def main(self, name):

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

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

    )

    @errors.generic.all

    @errors.cyclades.connection

    def _run(self):

        images = self.client.list_images(self['detail'])

        kwargs = dict(with_enumeration=self['enum'])

        if self['more']:

            kwargs['page_size'] = self['limit'] or 10

            images = images[:self['limit']]

        self._print(images, **kwargs)

    @errors.plankton.id

    def _run(self, image_id):

        image = self.client.get_image_details(image_id)

    def main(self, image_id):

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

# interpreted as representing official policies, either expressed

# or implied, of GRNET S.A.

log = get_logger('kamaki.cli')

        """

        command = path4url('metadata', key)

        r = self.servers_get(server_id, command)

    def create_server_metadata(self, server_id, key, val):

        """

        :returns: dict of updated key:val metadata

        """

        r = self.servers_put(

            server_id,

            'metadata/' + key,

            json_data=req,

            success=201)

    def update_server_metadata(self, server_id, **metadata):

        """

        """

        :param detail: (bool) detailed flavor info if set, short if not

        """

        r = self.flavors_get(command='detail' if detail else '')

        return r.json['flavors']

        """

        command = path4url('metadata', key)

        r = self.images_get(image_id, command)

    def create_image_metadata(self, image_id, key, val):

        """

        :returns: (dict) updated metadata

        """

        r = self.images_put(image_id, 'metadata/' + key, json_data=req)

    def update_image_metadata(self, image_id, **metadata):

        """

    suspended=False,

    progress=0,

    id=31173,

img_recv = dict(image=dict(

    status="ACTIVE",

    updated="2013-02-26T11:10:14+00:00",

    created="2013-02-26T11:03:29+00:00",

    progress=100,

    id=img_ref,

        partition_table="msdos",

        kernel="2.6.32",

        osfamily="linux",

        sortorder="1",

        os="debian",

        root_partition="1",

    dict(name='n1', id=1),

    dict(id=41, name="C1R1024D20"),

    dict(id=42, name="C1R1024D40"),

    dict(name="maelstrom", id="0fb03e45-7d5a-4515-bd4e-e6bbf6457f06"),

    dict(name="edx_saas", id="1357163d-5fd8-488e-a117-48734c526206"),

    dict(name="Debian_Wheezy_Base", id="1f8454f0-8e3e-4b6c-ab8e-5236b728dffe"),

    dict(name="Ubuntu Desktop", id="37bc522c-c479-4085-bfb9-464f9b9e2e31"),

    dict(name="Ubuntu 12.10", id="3a24fef9-1a8c-47d1-8f11-e07bd5e544fd"),

    dict(name="Debian Base", id="40ace203-6254-4e17-a5cb-518d55418a7d"),

class FR(object):

            r = self.client.list_servers(detail)

            self.assertEqual(SG.mock_calls[-1], call(

                command='detail' if detail else ''))

                self.assert_dicts_are_equal(r[i], vm)

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

    def test_create_server_metadata(self, SP):

        vm_id = vm_recv['server']['id']

        metadata = dict(m1='v1', m2='v2', m3='v3')

        for k, v in metadata.items():

            r = self.client.create_server_metadata(vm_id, k, v)

            self.assert_dicts_are_equal(r, vm_recv['server'])

            self.assertEqual(SP.mock_calls[-1], call(

    @patch('%s.servers_get' % compute_pkg, return_value=FR())

    def test_get_server_metadata(self, SG):

        vm_id = vm_recv['server']['id']

        metadata = dict(m1='v1', m2='v2', m3='v3')

        r = self.client.get_server_metadata(vm_id)

        self.assert_dicts_are_equal(r, metadata)

        for k, v in metadata.items():

            r = self.client.get_server_metadata(vm_id, k)

            self.assert_dicts_are_equal(r, {k: v})

    @patch('%s.servers_post' % compute_pkg, return_value=FR())

    def test_update_server_metadata(self, SP):

        r = self.client.update_server_metadata(vm_id, **metadata)

        self.assert_dicts_are_equal(r, metadata)

        SP.assert_called_once_with(

            json_data=dict(metadata=metadata), success=201)

    @patch('%s.servers_delete' % compute_pkg, return_value=FR())

        vm_id = vm_recv['server']['id']

        key = 'metakey'

        self.client.delete_server_metadata(vm_id, key)

    @patch('%s.flavors_get' % compute_pkg, return_value=FR())

    def test_list_flavors(self, FG):

        for cmd in ('', 'detail'):

            r = self.client.list_flavors(detail=(cmd == 'detail'))

            self.assertEqual(FG.mock_calls[-1], call(command=cmd))

    @patch('%s.flavors_get' % compute_pkg, return_value=FR())

    def test_get_flavor_details(self, FG):

        r = self.client.get_flavor_details(fid)

        FG.assert_called_once_with(fid)

    @patch('%s.images_get' % compute_pkg, return_value=FR())

    def test_list_images(self, IG):

        for cmd in ('', 'detail'):

            r = self.client.list_images(detail=(cmd == 'detail'))

            self.assertEqual(IG.mock_calls[-1], call(command=cmd))

            for i in range(len(r)):

                self.assert_dicts_are_equal(expected[i], r[i])

    @patch('%s.images_get' % compute_pkg, return_value=FR())

    def test_get_image_metadata(self, IG):

        for key in ('', '50m3k3y'):

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

            self.assertEqual(IG.mock_calls[-1], call(

                '%s' % img_ref,

            self.assert_dicts_are_equal(img_recv['image'], r)

    @patch('%s.servers_delete' % compute_pkg, return_value=FR())

    @patch('%s.images_put' % compute_pkg, return_value=FR())

    def test_create_image_metadata(self, IP):

        (key, val) = ('k1', 'v1')

        r = self.client.create_image_metadata(img_ref, key, val)

        IP.assert_called_once_with(

        self.assert_dicts_are_equal(r, img_recv['image'])

    @patch('%s.images_post' % compute_pkg, return_value=FR())

        FR.json = dict(metadata=metadata)

        r = self.client.update_image_metadata(img_ref, **metadata)

        IP.assert_called_once_with(

            json_data=dict(metadata=metadata))

        self.assert_dicts_are_equal(r, metadata)

    def test_delete_image_metadata(self, ID):

        key = 'metakey'

        self.client.delete_image_metadata(img_ref, key)

if __name__ == '__main__':

    suspended=False,

    progress=0,

    id=31173,

    dict(name='n1', id=1),

net_send = dict(network=dict(dhcp=False, name='someNet'))

net_recv = dict(network=dict(

    status="PENDING",

    cidr="192.168.1.0/24",

    type="MAC_FILTERED",

    gateway=None,

    dict(id=1, name='n1'),

    dict(id=2, name='n2'),

class FR(object):

            self.assertEqual(SG.mock_calls[-1], call(

                command='detail' if detail else '',

                changes_since=since))

            for i, vm in enumerate(r):

                self.assert_dicts_are_equal(vm, expected[i])

            self.assertEqual(i + 1, len(expected))

    def test_get_firewall_profile(self):

        vm_id = vm_recv['server']['id']

        with patch.object(

                cyclades.CycladesClient, 'get_server_details',

                return_value=firewalls) as GSD:

    @patch('%s.servers_post' % cyclades_pkg, return_value=FR())

    def test_set_firewall_profile(self, SP):

        vm_id = vm_recv['server']['id']

        self.client.set_firewall_profile(vm_id, v)

        SP.assert_called_once_with(

            vm_id, 'action',

    @patch('%s.servers_get' % cyclades_pkg, return_value=FR())

    def test_list_server_nics(self, SG):

        vm_id = vm_recv['server']['id']

        FR.json = nics

        r = self.client.list_server_nics(vm_id)

        SG.assert_called_once_with(vm_id, 'ips')

        for i in range(len(r)):

            self.assert_dicts_are_equal(r[i], expected[i])

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

    @patch('%s.networks_get' % cyclades_pkg, return_value=FR())

    def test_list_networks(self, NG):

        FR.json = net_list

        for detail in ('', 'detail'):

            r = self.client.list_networks(detail=True if detail else False)

            self.assertEqual(NG.mock_calls[-1], call(command=detail))

        FR.json = net_recv

        r = self.client.list_network_nics(net_id)

        NG.assert_called_once_with(network_id=net_id)

        for i in range(len(r)):

            self.assert_dicts_are_equal(r[i], expected[i])