From a95c0ae05f91c81de061c6e1460189259f7717fe Mon Sep 17 00:00:00 2001 From: Sabari Kumar Murugesan Date: Tue, 17 Feb 2015 20:16:56 -0800 Subject: [PATCH] Add get_datastore_by_ref method to oslo.vmware Two methods are added as part of this patch:- 1. get_datastore_by_ref - returns a Datastore object given a datastore reference. 2. get_object_properties_dict - a vim utility method to retrieve properties of an object as a dictionary. Currently, Glance needs these methods to find datastore objects from datastore references. Change-Id: I516536ea4098357540531105b4f97e6668fb3f08 --- oslo_vmware/objects/datastore.py | 24 +++++++++++++++++++++ oslo_vmware/vim_util.py | 36 +++++++++++++++++++++++++++++++ tests/objects/test_datastore.py | 15 +++++++++++++ tests/test_vim_util.py | 37 ++++++++++++++++++++++++++++++++ 4 files changed, 112 insertions(+) diff --git a/oslo_vmware/objects/datastore.py b/oslo_vmware/objects/datastore.py index 3d0188f3..dd3b7b9f 100644 --- a/oslo_vmware/objects/datastore.py +++ b/oslo_vmware/objects/datastore.py @@ -28,6 +28,30 @@ LOG = logging.getLogger(__name__) random = _random.SystemRandom() +def get_datastore_by_ref(session, ds_ref): + """Returns a datastore object for a given reference. + + :param session: a vmware api session object + :param ds_ref: managed object reference of a datastore + :rtype : a datastore object + """ + lst_properties = ["summary.type", + "summary.name", + "summary.capacity", + "summary.freeSpace"] + props = session.invoke_api( + vim_util, + "get_object_properties_dict", + session.vim, + ds_ref, + lst_properties) + # TODO(sabari): Instantiate with datacenter info. + return Datastore(ds_ref, props["summary.name"], + capacity=props.get("summary.capacity"), + freespace=props.get("summary.freeSpace"), + type=props.get("summary.type")) + + class Datastore(object): def __init__(self, ref, name, capacity=None, freespace=None, diff --git a/oslo_vmware/vim_util.py b/oslo_vmware/vim_util.py index fd43ab56..4631d7e9 100644 --- a/oslo_vmware/vim_util.py +++ b/oslo_vmware/vim_util.py @@ -17,9 +17,15 @@ The VMware API utility module. """ +import logging + from suds import sudsobject from oslo.utils import timeutils +from oslo_vmware._i18n import _LW + + +LOG = logging.getLogger(__name__) def get_moref(value, type_): @@ -316,6 +322,36 @@ def get_object_properties(vim, moref, properties_to_collect): return retrieve_result.objects +def get_object_properties_dict(vim, moref, properties_to_collect): + """Get properties of the given managed object as a dict. + + :param vim: Vim object + :param moref: managed object reference + :param properties_to_collect: names of the managed object properties to be + collected + :returns: a dict of properties of the given managed object + :raises: VimException, VimFaultException, VimAttributeException, + VimSessionOverLoadException, VimConnectionException + """ + obj_contents = get_object_properties(vim, moref, properties_to_collect) + if obj_contents is None: + return {} + property_dict = {} + if hasattr(obj_contents[0], 'propSet'): + dynamic_properties = obj_contents[0].propSet + if dynamic_properties: + for prop in dynamic_properties: + property_dict[prop.name] = prop.val + # The object may have information useful for logging + if hasattr(obj_contents[0], 'missingSet'): + for m in obj_contents[0].missingSet: + LOG.warning(_LW("Unable to retrieve value for %(path)s " + "Reason: %(reason)s"), + {'path': m.path, + 'reason': m.fault.localizedMessage}) + return property_dict + + def _get_token(retrieve_result): """Get token from result to obtain next set of results. diff --git a/tests/objects/test_datastore.py b/tests/objects/test_datastore.py index 2d66ccff..aa88a22d 100644 --- a/tests/objects/test_datastore.py +++ b/tests/objects/test_datastore.py @@ -383,3 +383,18 @@ class DatastoreURLTestCase(base.TestCase): ticket = ds_url.get_transfer_ticket(session, 'PUT') self.assertEqual('%s="%s"' % (constants.CGI_COOKIE_KEY, 'fake_id'), ticket) + + def test_get_datastore_by_ref(self): + session = mock.Mock() + ds_ref = mock.Mock() + expected_props = {'summary.name': 'datastore1', + 'summary.type': 'NFS', + 'summary.freeSpace': 1000, + 'summary.capacity': 2000} + session.invoke_api = mock.Mock() + session.invoke_api.return_value = expected_props + ds_obj = datastore.get_datastore_by_ref(session, ds_ref) + self.assertEqual(expected_props['summary.name'], ds_obj.name) + self.assertEqual(expected_props['summary.type'], ds_obj.type) + self.assertEqual(expected_props['summary.freeSpace'], ds_obj.freespace) + self.assertEqual(expected_props['summary.capacity'], ds_obj.capacity) diff --git a/tests/test_vim_util.py b/tests/test_vim_util.py index 44b65267..b19cd48e 100644 --- a/tests/test_vim_util.py +++ b/tests/test_vim_util.py @@ -253,6 +253,43 @@ class VimUtilTest(base.TestCase): self.assertTrue(res is retrieve_result.objects) cancel_retrieval.assert_called_once_with(vim, retrieve_result) + @mock.patch('oslo_vmware.vim_util.get_object_properties') + def test_get_object_properties_dict_empty(self, mock_obj_prop): + mock_obj_prop.return_value = None + vim = mock.Mock() + moref = mock.Mock() + res = vim_util.get_object_properties_dict(vim, moref, None) + self.assertEqual({}, res) + + @mock.patch('oslo_vmware.vim_util.get_object_properties') + def test_get_object_properties_dict(self, mock_obj_prop): + expected_prop_dict = {'name': 'vm01'} + mock_obj_content = mock.Mock() + prop = mock.Mock() + prop.name = "name" + prop.val = "vm01" + mock_obj_content.propSet = [prop] + del mock_obj_content.missingSet + mock_obj_prop.return_value = [mock_obj_content] + vim = mock.Mock() + moref = mock.Mock() + res = vim_util.get_object_properties_dict(vim, moref, None) + self.assertEqual(expected_prop_dict, res) + + @mock.patch('oslo_vmware.vim_util.get_object_properties') + def test_get_object_properties_dict_missing(self, mock_obj_prop): + mock_obj_content = mock.Mock() + missing_prop = mock.Mock() + missing_prop.path = "name" + missing_prop.fault = mock.Mock() + mock_obj_content.missingSet = [missing_prop] + del mock_obj_content.propSet + mock_obj_prop.return_value = [mock_obj_content] + vim = mock.Mock() + moref = mock.Mock() + res = vim_util.get_object_properties_dict(vim, moref, None) + self.assertEqual({}, res) + @mock.patch('oslo_vmware.vim_util._get_token') def test_cancel_retrieval(self, get_token): token = mock.Mock()