Added support for the Capabilities resource

Introduce the Capabilities resource, fill in its
resources, and implement API calls to support
the Cinder v3 API.

Task: 41852
Story: 2008619
Task: 41950
Story: 2008621
Change-Id: I695c53fe2551565cbdf0428b518523220935c594

openstack/block_storage/v3/_proxy.py

@@ -13,6 +13,7 @@
 from openstack.block_storage import _base_proxy
 from openstack.block_storage.v3 import availability_zone
 from openstack.block_storage.v3 import backup as _backup
+from openstack.block_storage.v3 import capabilities as _capabilities
 from openstack.block_storage.v3 import limits as _limits
 from openstack.block_storage.v3 import snapshot as _snapshot
 from openstack.block_storage.v3 import stats as _stats
@@ -525,6 +526,18 @@ class Proxy(_base_proxy.BaseBlockStorageProxy):
         """
         return self._get(_limits.Limit, requires_id=False)
 
+    def get_capabilities(self, host):
+        """Get a backend's capabilites
+
+        :param host: Specified backend to obtain volume stats and properties.
+
+        :returns: One :class:
+            `~openstack.block_storage.v3.capabilites.Capabilities` instance.
+        :raises: :class:`~openstack.exceptions.ResourceNotFound` when no
+            resource can be found.
+        """
+        return self._get(_capabilities.Capabilities, host)
+
     def availability_zones(self):
         """Return a generator of availability zones
 

openstack/block_storage/v3/capabilities.py

@@ -0,0 +1,45 @@
+# 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.
+
+from openstack import resource
+
+
+class Capabilities(resource.Resource):
+    base_path = "/capabilities"
+
+    # Capabilities
+    allow_fetch = True
+
+    #: Properties
+    #: The capabilities description
+    description = resource.Body("description")
+    #: The name of volume backend capabilities.
+    display_name = resource.Body("display_name")
+    #: The driver version.
+    driver_version = resource.Body("driver_version")
+    #: The storage namespace, such as OS::Storage::Capabilities::foo.
+    namespace = resource.Body("namespace")
+    #: The name of the storage pool.
+    pool_name = resource.Body("pool_name")
+    #: The backend volume capabilites list, which consists of cinder
+    #: standard capabilities and vendor unique properties.
+    properties = resource.Body("properties", type=dict)
+    #: A list of volume backends used to replicate volumes on this backend.
+    replication_targets = resource.Body("replication_targets", type=list)
+    #: The storage backend for the backend volume.
+    storage_protocol = resource.Body("storage_protocol")
+    #: The name of the vendor.
+    vendor_name = resource.Body("vendor_name")
+    #: The volume type access.
+    visibility = resource.Body("visibility")
+    #: The name of the back-end volume.
+    volume_backend_name = resource.Body("volume_backend_name")

openstack/tests/functional/block_storage/v3/test_capabilities.py

@@ -0,0 +1,36 @@
+# 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.
+
+
+from openstack.tests.functional.block_storage.v3 import base
+from openstack import proxy
+
+
+class TestCapabilities(base.BaseBlockStorageTest):
+
+    def test_get(self):
+        response = (
+            proxy._json_response(self.conn.block_storage.get('/os-hosts')))
+        host = response['hosts'][0]['host_name']
+
+        sot = self.conn.block_storage.get_capabilities(host)
+        self.assertIn('description', sot)
+        self.assertIn('display_name', sot)
+        self.assertIn('driver_version', sot)
+        self.assertIn('namespace', sot)
+        self.assertIn('pool_name', sot)
+        self.assertIn('properties', sot)
+        self.assertIn('replication_targets', sot)
+        self.assertIn('storage_protocol', sot)
+        self.assertIn('vendor_name', sot)
+        self.assertIn('visibility', sot)
+        self.assertIn('volume_backend_name', sot)

openstack/tests/unit/block_storage/v3/test_capabilities.py

@@ -0,0 +1,92 @@
+# 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.
+
+from openstack.block_storage.v3 import capabilities
+from openstack.tests.unit import base
+
+CAPABILITIES = {
+    "namespace": "OS::Storage::Capabilities::fake",
+    "vendor_name": "OpenStack",
+    "volume_backend_name": "lvmdriver-1",
+    "pool_name": "pool",
+    "driver_version": "2.0.0",
+    "storage_protocol": "iSCSI",
+    "display_name": "Capabilities of Cinder LVM driver",
+    "description": "These are volume type options",
+    "visibility": "public",
+    "replication_targets": [],
+    "properties": {
+        "compression": {
+            "title": "Compression",
+            "description": "Enables compression.",
+            "type": "boolean"
+        },
+        "qos": {
+            "title": "QoS",
+            "description": "Enables QoS.",
+            "type": "boolean"
+        },
+        "replication": {
+            "title": "Replication",
+            "description": "Enables replication.",
+            "type": "boolean"
+        },
+        "thin_provisioning": {
+            "title": "Thin Provisioning",
+            "description": "Sets thin provisioning.",
+            "type": "boolean"
+        }
+    }
+}
+
+
+class TestCapabilites(base.TestCase):
+
+    def test_basic(self):
+        capabilities_resource = capabilities.Capabilities()
+        self.assertEqual(None, capabilities_resource.resource_key)
+        self.assertEqual(None, capabilities_resource.resources_key)
+        self.assertEqual("/capabilities", capabilities_resource.base_path)
+        self.assertTrue(capabilities_resource.allow_fetch)
+        self.assertFalse(capabilities_resource.allow_create)
+        self.assertFalse(capabilities_resource.allow_commit)
+        self.assertFalse(capabilities_resource.allow_delete)
+        self.assertFalse(capabilities_resource.allow_list)
+
+    def test_make_capabilities(self):
+        capabilities_resource = capabilities.Capabilities(**CAPABILITIES)
+        self.assertEqual(
+            CAPABILITIES["description"], capabilities_resource.description)
+        self.assertEqual(
+            CAPABILITIES["display_name"], capabilities_resource.display_name)
+        self.assertEqual(
+            CAPABILITIES["driver_version"],
+            capabilities_resource.driver_version)
+        self.assertEqual(
+            CAPABILITIES["namespace"], capabilities_resource.namespace)
+        self.assertEqual(
+            CAPABILITIES["pool_name"], capabilities_resource.pool_name)
+        self.assertEqual(
+            CAPABILITIES["properties"], capabilities_resource.properties)
+        self.assertEqual(
+            CAPABILITIES["replication_targets"],
+            capabilities_resource.replication_targets)
+        self.assertEqual(
+            CAPABILITIES["storage_protocol"],
+            capabilities_resource.storage_protocol)
+        self.assertEqual(
+            CAPABILITIES["vendor_name"], capabilities_resource.vendor_name)
+        self.assertEqual(
+            CAPABILITIES["visibility"], capabilities_resource.visibility)
+        self.assertEqual(
+            CAPABILITIES["volume_backend_name"],
+            capabilities_resource.volume_backend_name)

openstack/tests/unit/block_storage/v3/test_proxy.py

@@ -13,6 +13,7 @@ from unittest import mock
 
 from openstack.block_storage.v3 import _proxy
 from openstack.block_storage.v3 import backup
+from openstack.block_storage.v3 import capabilities
 from openstack.block_storage.v3 import limits
 from openstack.block_storage.v3 import snapshot
 from openstack.block_storage.v3 import stats
@@ -236,3 +237,6 @@ class TestVolumeProxy(test_proxy_base.TestProxyBase):
         self.verify_get(
             self.proxy.get_limits, limits.Limit, ignore_value=True,
             expected_kwargs={'requires_id': False})
+
+    def test_capabilites_get(self):
+        self.verify_get(self.proxy.get_capabilities, capabilities.Capabilities)