Allow CRUD metric with an resource_id and an name

This change add support to CRUD metric
with resource_id and metric_name in additional to metric_id

Change-Id: I91b6d6bba96d35c17e39b1b5a3e67b7489e63c66

gnocchiclient/tests/functional/test_metric.py

@@ -16,10 +16,8 @@ from gnocchiclient.tests.functional import base
 class MetricClientTest(base.ClientTestBase):
     def test_metric_scenario(self):
         # PREPARE AN ACHIVE POLICY
-        self.gnocchi(
+        self.gnocchi("archive policy", params="create metric-test "
-            u'archive policy', params=u"create metric-test"
+                     "--back-window 0 -d granularity:1s,points:86400")
-            u" --back-window 0"
-            u" -d granularity:1s,points:86400")
 
         # CREATE
         result = self.gnocchi(
@@ -64,3 +62,53 @@ class MetricClientTest(base.ClientTestBase):
                               fail_ok=True, merge_stderr=True)
         self.assertFirstLineStartsWith(result.split('\n'),
                                        "Not Found (HTTP 404)")
+
+    def test_metric_by_name_scenario(self):
+        # PREPARE REQUIREMENT
+        self.gnocchi("archive policy", params="create metric-test2 "
+                     "--back-window 0 -d granularity:1s,points:86400")
+        self.gnocchi("resource", params="create generic -a id:metric-res")
+
+        # CREATE
+        result = self.gnocchi(
+            u'metric', params=u"create"
+            u" --archive-policy-name metric-test2 -r metric-res metric-name")
+        metric = self.details_multiple(result)[0]
+        self.assertIsNotNone(metric["id"])
+        self.assertEqual(self.clients.project_id,
+                         metric["created_by_project_id"])
+        self.assertEqual(self.clients.user_id, metric["created_by_user_id"])
+        self.assertEqual('metric-name', metric["name"])
+        self.assertNotEqual('None', metric["resource"])
+        self.assertIn("metric-test", metric["archive_policy/name"])
+
+        # GET
+        result = self.gnocchi('metric', params="show metric-name metric-res")
+        metric_get = self.details_multiple(result)[0]
+        self.assertEqual(metric, metric_get)
+
+        # LIST
+        result = self.gnocchi('metric', params="list")
+        metrics = self.parser.listing(result)
+        metric_from_list = [p for p in metrics
+                            if p['archive_policy/name'] == 'metric-test2'][0]
+        for field in ["archive_policy/name", "name"]:
+            # FIXME(sileht): add "resource_id" or "resource"
+            # when LP#1497171 is fixed
+            self.assertEqual(metric[field], metric_from_list[field])
+
+        # DELETE
+        result = self.gnocchi('metric', params="delete metric-name metric-res")
+        self.assertEqual("", result)
+
+        # GET FAIL
+        result = self.gnocchi('metric', params="show metric-name metric-res",
+                              fail_ok=True, merge_stderr=True)
+        self.assertFirstLineStartsWith(result.split('\n'),
+                                       "Not Found (HTTP 404)")
+
+        # DELETE FAIL
+        result = self.gnocchi('metric', params="delete metric-name metric-res",
+                              fail_ok=True, merge_stderr=True)
+        self.assertFirstLineStartsWith(result.split('\n'),
+                                       "Not Found (HTTP 404)")

gnocchiclient/v1/metric.py

@@ -11,6 +11,8 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
+import uuid
+
 from oslo_serialization import jsonutils
 
 from gnocchiclient.v1 import base
@@ -25,35 +27,73 @@ class MetricManager(base.Manager):
         url = self.client._build_url("metric")
         return self.client.api.get(url).json()
 
-    def get(self, name):
+    @staticmethod
+    def _ensure_metric_is_uuid(metric):
+        try:
+            uuid.UUID(metric)
+        except ValueError:
+            raise TypeError("resource_id is required to get a metric by name")
+
+    def get(self, metric, resource_id=None):
         """Get an metric
 
-        :param name: Name of the metric
+        :param metric: ID or Name of the metric
-        :type name: str
+        :type metric: str
+        :param resource_id: ID of the resource (required
+                            to get a metric by name)
+        :type resource_id: str
         """
-        url = self.client._build_url("metric/%s" % name)
+        if resource_id is None:
+            self._ensure_metric_is_uuid(metric)
+            url = self.client._build_url("metric/%s" % metric)
+        else:
+            url = self.client._build_url("resource/generic/%s/metric/%s" % (
+                resource_id, metric))
         return self.client.api.get(url).json()
 
-    def create(self, metric):
+    def create(self, metric, resource_id=None, metric_name=None):
         """Create an metric
 
-        :param metric: the metric
+        :param metric: The metric
-        :type metric: dict
+        :type metric: str
-
+        :param resource_id: ID of the resource (required
+                            to get a metric by name)
+        :type resource_id: str
         """
-        url = self.client._build_url("metric/")
+        if resource_id is None and metric_name is None:
-        metric = self.client.api.post(
+            url = self.client._build_url("metric")
-            url, headers={'Content-Type': "application/json"},
+            metric = self.client.api.post(
-            data=jsonutils.dumps(metric)).json()
+                url, headers={'Content-Type': "application/json"},
-        # FIXME(sileht): create and get have a
+                data=jsonutils.dumps(metric)).json()
-        # different output: LP#1497171
+            # FIXME(sileht): create and get have a
-        return self.get(metric["id"])
+            # different output: LP#1497171
+            return self.get(metric["id"])
+        elif ((resource_id is None and metric_name is not None) or
+                (resource_id is not None and metric_name is None)):
+            raise TypeError("resource_id and metric_name are "
+                            "mutually required")
+        else:
+            url = self.client._build_url("resource/generic/%s/metric" %
+                                         resource_id)
+            metric = {metric_name: metric}
+            metric = self.client.api.post(
+                url, headers={'Content-Type': "application/json"},
+                data=jsonutils.dumps(metric))
+            return self.get(metric_name, resource_id)
 
-    def delete(self, name):
+    def delete(self, metric, resource_id=None):
         """Delete an metric
 
-        :param name: Name of the metric
+        :param metric: ID or Name of the metric
-        :type name: str
+        :type metric: str
+        :param resource_id: ID of the resource (required
+                            to get a metric by name)
+        :type resource_id: str
         """
-        url = self.client._build_url("metric/%s" % name)
+        if resource_id is None:
+            self._ensure_metric_is_uuid(metric)
+            url = self.client._build_url("metric/%s" % metric)
+        else:
+            url = self.client._build_url("resource/generic/%s/metric/%s" % (
+                resource_id, metric))
         self.client.api.delete(url)

gnocchiclient/v1/metric_cli.py

@@ -32,13 +32,16 @@ class CliMetricList(lister.Lister):
 class CliMetricShow(show.ShowOne):
     def get_parser(self, prog_name):
         parser = super(CliMetricShow, self).get_parser(prog_name)
-        parser.add_argument("metric_id", metavar="<ID>",
+        parser.add_argument("metric",
-                            help="ID of the metric")
+                            help="ID or name of the metric")
+        parser.add_argument("resource_id", nargs='?',
+                            help="ID of the resource")
         return parser
 
     def take_action(self, parsed_args):
         metric = self.app.client.metric.get(
-            name=parsed_args.metric_id)
+            metric=parsed_args.metric,
+            resource_id=parsed_args.resource_id)
         utils.format_archive_policy(metric["archive_policy"])
         utils.format_move_dict_to_root(metric, "archive_policy")
         return self.dict2columns(metric)
@@ -48,15 +51,23 @@ class CliMetricCreate(show.ShowOne):
 
     def get_parser(self, prog_name):
         parser = super(CliMetricCreate, self).get_parser(prog_name)
-        parser.add_argument("--archive-policy-name",
+        parser.add_argument("--archive-policy-name", "-a",
                             dest="archive_policy_name",
                             help=("name of the archive policy"))
+        parser.add_argument("--resource", "-r", nargs=2,
+                            metavar=("RESOURCE_ID", "METRIC_NAME"),
+                            help="ID of the resource")
         return parser
 
     def take_action(self, parsed_args):
         metric = utils.dict_from_parsed_args(parsed_args,
                                              ["archive_policy_name"])
-        metric = self.app.client.metric.create(metric=metric)
+        kwds = {'metric': metric}
+        if parsed_args.resource is not None:
+            kwds['resource_id'] = parsed_args.resource[0]
+            kwds['metric_name'] = parsed_args.resource[1]
+
+        metric = self.app.client.metric.create(**kwds)
         utils.format_archive_policy(metric["archive_policy"])
         utils.format_move_dict_to_root(metric, "archive_policy")
         return self.dict2columns(metric)
@@ -65,9 +76,12 @@ class CliMetricCreate(show.ShowOne):
 class CliMetricDelete(command.Command):
     def get_parser(self, prog_name):
         parser = super(CliMetricDelete, self).get_parser(prog_name)
-        parser.add_argument("metric_id", metavar="<ID>",
+        parser.add_argument("metric",
-                            help="ID of the metric")
+                            help="ID or name of the metric")
+        parser.add_argument("resource_id", nargs='?',
+                            help="ID of the resource")
         return parser
 
     def take_action(self, parsed_args):
-        self.app.client.metric.delete(name=parsed_args.metric_id)
+        self.app.client.metric.delete(metric=parsed_args.metric,
+                                      resource_id=parsed_args.resource_id)