openstack
/
python-troveclient
Code Issues Proposed changes

Add instance_metadata functionality to the trove python library 

Implements: blueprint trove-metadata

Change-Id: I4e498844afd2d2730fad2176dccaf1d61d8798c1
This commit is contained in:
Daniel Salinas 2014-02-15 00:36:07 -06:00
parent d02764e597
commit cb5736433b
9 changed files with 343 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
.gitignore vendored
View File

@ -5,6 +5,7 @@ dist/*
build/*
html/*
*.egg*
.coverage
rdserver.txt
python-troveclient.iml
AUTHORS

4
troveclient/base.py
View File

@ -186,6 +186,10 @@ class Manager(utils.HookableMixin):
resp, body = self.api.client.put(url, body=body)
return body
def _edit(self, url, body):
resp, body = self.api.client.patch(url, body=body)
return body
class ManagerWithFind(six.with_metaclass(abc.ABCMeta, Manager)):
"""Like a `Manager`, but with additional `find()`/`findall()` methods."""

15
troveclient/compat/cli.py
View File

@ -415,6 +415,20 @@ class SecurityGroupCommands(common.AuthedCommandsBase):
self.dbaas.security_group_rules.delete(self.id)
class MetadataCommands(common.AuthedCommandsBase):
"""Commands to create/update/replace/delete/show metadata for an instance
"""
params = [
'instance_id',
'metadata'
]
def show(self):
"""Show instance metadata."""
self._require('instance_id')
self._pretty_print(self.dbaas.metadata.show(self.instance_id))
COMMANDS = {
'auth': common.Auth,
'instance': InstanceCommands,
@ -427,6 +441,7 @@ COMMANDS = {
'root': RootCommands,
'version': VersionCommands,
'secgroup': SecurityGroupCommands,
'metadata': MetadataCommands,
}

2
troveclient/compat/client.py
View File

@ -311,6 +311,7 @@ class Dbaas(object):
from troveclient.v1 import instances
from troveclient.v1 import limits
from troveclient.v1 import management
from troveclient.v1 import metadata
from troveclient.v1 import quota
from troveclient.v1 import root
from troveclient.v1 import security_groups
@ -347,6 +348,7 @@ class Dbaas(object):
self.configurations = configurations.Configurations(self)
config_parameters = configurations.ConfigurationParameters(self)
self.configuration_parameters = config_parameters
self.metadata = metadata.Metadata(self)
class Mgmt(object):
def __init__(self, dbaas):

2
troveclient/compat/tests/test_common.py
View File

@ -230,8 +230,10 @@ class CommandsBaseTest(testtools.TestCase):
self.assertIsNone(self.cmd_base._pretty_print(func))
def test__dumps(self):
orig_dumps = json.dumps
json.dumps = mock.Mock(return_value="test-dump")
self.assertEqual("test-dump", self.cmd_base._dumps("item"))
json.dumps = orig_dumps
def test__pretty_list(self):
func = mock.Mock(return_value=None)

169
troveclient/tests/test_metadata.py Normal file
View File

@ -0,0 +1,169 @@
# Copyright 2014 Rackspace Hosting
# All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
import json
import mock
import testtools
from troveclient.v1 import metadata
class TestMetadata(testtools.TestCase):
def setUp(self):
super(TestMetadata, self).setUp()
self.orig__init = metadata.Metadata.__init__
metadata.Metadata.__init__ = mock.Mock(return_value=None)
self.metadata = metadata.Metadata()
self.metadata.manager = mock.Mock()
self.metadata.api = mock.Mock()
self.metadata.api.client = mock.Mock()
self.instance_uuid = '3fbc8d6d-3f87-41d9-a4a1-060830dc6c4c'
self.metadata_key = 'metakey'
self.new_metadata_key = 'newmetakey'
self.metadata_value = {'metavalue': [1, 2, 3]}
def tearDown(self):
super(TestMetadata, self).tearDown()
metadata.Metadata.__init__ = self.orig__init
def test_list(self):
def side_effect_func(path, config):
return path, config
self.metadata._get = mock.Mock(side_effect=side_effect_func)
path, config = self.metadata.list(self.instance_uuid)
self.assertEqual('/instances/%s/metadata' % self.instance_uuid, path)
self.assertEqual('metadata', config)
def test_show(self):
def side_effect_func(path, config):
return path, config
self.metadata._get = mock.Mock(side_effect=side_effect_func)
path, config = self.metadata.show(self.instance_uuid,
self.metadata_key)
self.assertEqual('/instances/%s/metadata/%s' %
(self.instance_uuid, self.metadata_key), path)
self.assertEqual('metadata', config)
def test_create(self):
def side_effect_func(path, body, config):
return path, body, config
create_body = {
'metadata': {
'value': self.metadata_value
}
}
self.metadata._create = mock.Mock(side_effect=side_effect_func)
path, body, config = self.metadata.create(self.instance_uuid,
self.metadata_key,
self.metadata_value)
self.assertEqual('/instances/%s/metadata/%s' %
(self.instance_uuid, self.metadata_key), path)
self.assertEqual(create_body, body)
self.assertEqual('metadata', config)
def test_edit(self):
def side_effect_func(path, body):
return path, body
edit_body = {
'metadata': {
'value': self.metadata_value
}
}
self.metadata._edit = mock.Mock(side_effect=side_effect_func)
path, body = self.metadata.edit(self.instance_uuid,
self.metadata_key,
self.metadata_value)
self.assertEqual('/instances/%s/metadata/%s' %
(self.instance_uuid, self.metadata_key), path)
self.assertEqual(edit_body, body)
def test_update(self):
def side_effect_func(path, body):
return path, body
update_body = {
'metadata': {
'key': self.new_metadata_key,
'value': self.metadata_value
}
}
self.metadata._update = mock.Mock(side_effect=side_effect_func)
path, body = self.metadata.update(self.instance_uuid,
self.metadata_key,
self.new_metadata_key,
self.metadata_value)
self.assertEqual('/instances/%s/metadata/%s' %
(self.instance_uuid, self.metadata_key), path)
self.assertEqual(update_body, body)
def test_delete(self):
def side_effect_func(path):
return path
self.metadata._delete = mock.Mock(side_effect=side_effect_func)
path = self.metadata.delete(self.instance_uuid, self.metadata_key)
self.assertEqual('/instances/%s/metadata/%s' %
(self.instance_uuid, self.metadata_key), path)
def test_parse_value_valid_json_in(self):
value = {'one': [2, 3, 4]}
ser_value = json.dumps(value)
new_value = self.metadata._parse_value(ser_value)
self.assertEqual(value, new_value)
def test_parse_value_string_in(self):
value = 'this is a string'
new_value = self.metadata._parse_value(value)
self.assertEqual(value, new_value)
def test_parse_value_dict_in(self):
value = {'one': [2, 3, 4]}
new_value = self.metadata._parse_value(value)
self.assertEqual(value, new_value)
def test_parse_value_list_in(self):
value = [2, 3, 4]
new_value = self.metadata._parse_value(value)
self.assertEqual(value, new_value)
def test_parse_value_tuple_in(self):
value = (2, 3, 4)
new_value = self.metadata._parse_value(value)
self.assertEqual(value, new_value)
def test_parse_value_float_in(self):
value = 1.32
new_value = self.metadata._parse_value(value)
self.assertEqual(value, new_value)
def test_parse_value_int_in(self):
value = 1
new_value = self.metadata._parse_value(value)
self.assertEqual(value, new_value)
def test_parse_value_invalid_json_in(self):
# NOTE(imsplitbit): it's worth mentioning here and in the code that
# if you give _parse_value invalid json you get the string passed back
# to you.
value = "{'one': [2, 3, 4]}"
new_value = self.metadata._parse_value(value)
self.assertEqual(value, new_value)

2
troveclient/v1/client.py
View File

@ -22,6 +22,7 @@ from troveclient.v1 import datastores
from troveclient.v1 import flavors
from troveclient.v1 import instances
from troveclient.v1 import limits
from troveclient.v1 import metadata
from troveclient.v1 import root
from troveclient.v1 import security_groups
from troveclient.v1 import users
@ -66,6 +67,7 @@ class Client(object):
self.configurations = configurations.Configurations(self)
config_parameters = configurations.ConfigurationParameters(self)
self.configuration_parameters = config_parameters
self.metadata = metadata.Metadata(self)
#self.hosts = Hosts(self)
#self.quota = Quotas(self)

93
troveclient/v1/metadata.py Normal file
View File

@ -0,0 +1,93 @@
# Copyright 2014 Rackspace Hosting
# All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
import json
from troveclient import base
class MetadataResource(base.Resource):
def __getitem__(self, item):
return self.__dict__[item]
def __contains__(self, item):
if item in self.__dict__:
return True
else:
return False
class Metadata(base.Manager):
resource_class = MetadataResource
def list(self, instance_id):
return self._get('/instances/%s/metadata' % instance_id, 'metadata')
def show(self, instance_id, key):
return self._get('/instances/%s/metadata/%s' % (instance_id, key),
'metadata')
def create(self, instance_id, key, value):
body = {
'metadata': {
'value': self._parse_value(value)
}
}
return self._create(
'/instances/%s/metadata/%s' % (instance_id, key), body, 'metadata')
def update(self, instance_id, key, newkey, value):
body = {
'metadata': {
'key': newkey,
'value': self._parse_value(value)
}
}
return self._update(
'/instances/%s/metadata/%s' % (instance_id, key), body)
def edit(self, instance_id, key, value):
body = {
'metadata': {
'value': self._parse_value(value)
}
}
return self._edit(
'/instances/%s/metadata/%s' % (instance_id, key), body)
def delete(self, instance_id, key):
return self._delete('/instances/%s/metadata/%s' % (instance_id, key))
@staticmethod
def _parse_value(value):
"""This method is used to parse if a string was passed to any of the
methods we should first try to deserialize it using json.loads. This
is needed to facilitate users passing serialized structures from the
cli.
:param value: A value of type dict, list, tuple, int, float, str
:returns value:
"""
# NOTE(imsplitbit): if you give _parse_value invalid json you get
# the string passed back to you.
if isinstance(value, str):
try:
value = json.loads(value)
except ValueError:
# the value passed in was a string but not json
pass
return value

55
troveclient/v1/shell.py
View File

@ -811,3 +811,58 @@ def do_configuration_update(cs, args):
args.values,
args.name,
args.description)
@utils.arg('instance_id', metavar='<instance_id>', help='UUID for instance')
@utils.service_type('database')
def do_metadata_list(cs, args):
"""Shows all metadata for instance <id>."""
result = cs.metadata.list(args.instance_id)
_print_instance(result)
@utils.arg('instance_id', metavar='<instance_id>', help='UUID for instance')
@utils.arg('key', metavar='<key>', help='key to display')
@utils.service_type('database')
def do_metadata_show(cs, args):
"""Shows metadata entry for key <key> and instance <id>."""
result = cs.metadata.show(args.instance_id, args.key)
_print_instance(result)
@utils.arg('instance_id', metavar='<instance_id>', help='UUID for instance')
@utils.arg('key', metavar='<key>', help='Key to replace')
@utils.arg('value', metavar='<value>',
help='New value to assign to <key>')
@utils.service_type('database')
def do_metadata_edit(cs, args):
"""Replaces metadata value with a new one, this is non-destructive."""
cs.metadata.edit(args.instance_id, args.key, args.value)
@utils.arg('instance_id', metavar='<instance_id>', help='UUID for instance')
@utils.arg('key', metavar='<key>', help='Key to update')
@utils.arg('newkey', metavar='<newkey>', help='New key')
@utils.arg('value', metavar='<value>', help='Value to assign to <newkey>')
@utils.service_type('database')
def do_metadata_update(cs, args):
"""Updates metadata, this is destructive."""
cs.metadata.update(args.instance_id, args.key, args.newkey, args.value)
@utils.arg('instance_id', metavar='<instance_id>', help='UUID for instance')
@utils.arg('key', metavar='<key>', help='Key for assignment')
@utils.arg('value', metavar='<value>', help='Value to assign to <key>')
@utils.service_type('database')
def do_metadata_create(cs, args):
"""Creates metadata in the database for instance <id>."""
result = cs.metadata.create(args.instance_id, args.key, args.value)
_print_instance(result)
@utils.arg('instance_id', metavar='<instance_id>', help='UUID for instance')
@utils.arg('key', metavar='<key>', help='Metadata key to delete')
@utils.service_type('database')
def do_metadata_delete(cs, args):
"""Deletes metadata for instance <id>."""
cs.metadata.delete(args.instance_id, args.key)