python-openstackclient 6.3.0__py3-none-any.whl → 6.5.0__py3-none-any.whl

openstackclient/image/v2/metadef_namespaces.py

@@ -42,6 +42,7 @@ def _format_namespace(namespace):
         'owner',
         'protected',
         'schema',
+        'updated_at',
         'visibility',
     ]
 
@@ -61,7 +62,7 @@ def _format_namespace(namespace):
     return info
 
 
-class CreateMetadefNameSpace(command.ShowOne):
+class CreateMetadefNamespace(command.ShowOne):
     _description = _("Create a metadef namespace")
 
     def get_parser(self, prog_name):
@@ -130,20 +131,21 @@ class CreateMetadefNameSpace(command.ShowOne):
             kwargs['visibility'] = parsed_args.visibility
 
         data = image_client.create_metadef_namespace(**kwargs)
+        info = _format_namespace(data)
 
-        return zip(*sorted(data.items()))
+        return zip(*sorted(info.items()))
 
 
-class DeleteMetadefNameSpace(command.Command):
+class DeleteMetadefNamespace(command.Command):
     _description = _("Delete metadef namespace")
 
     def get_parser(self, prog_name):
         parser = super().get_parser(prog_name)
         parser.add_argument(
-            "namespace_name",
-            metavar="<namespace_name>",
+            "namespace",
+            metavar="<namespace>",
             nargs="+",
-            help=_("An identifier (a name) for the namespace"),
+            help=_("Metadef namespace(s) to delete (name)"),
         )
         return parser
 
@@ -151,9 +153,9 @@ class DeleteMetadefNameSpace(command.Command):
         image_client = self.app.client_manager.image
 
         result = 0
-        for i in parsed_args.namespace_name:
+        for ns in parsed_args.namespace:
             try:
-                namespace = image_client.get_metadef_namespace(i)
+                namespace = image_client.get_metadef_namespace(ns)
                 image_client.delete_metadef_namespace(namespace.id)
             except Exception as e:
                 result += 1
@@ -162,18 +164,18 @@ class DeleteMetadefNameSpace(command.Command):
                         "Failed to delete namespace with name or "
                         "ID '%(namespace)s': %(e)s"
                     ),
-                    {'namespace': i, 'e': e},
+                    {'namespace': ns, 'e': e},
                 )
 
         if result > 0:
-            total = len(parsed_args.namespace_name)
+            total = len(parsed_args.namespace)
             msg = _(
                 "%(result)s of %(total)s namespace failed " "to delete."
             ) % {'result': result, 'total': total}
             raise exceptions.CommandError(msg)
 
 
-class ListMetadefNameSpaces(command.Lister):
+class ListMetadefNamespace(command.Lister):
     _description = _("List metadef namespaces")
 
     def get_parser(self, prog_name):
@@ -215,7 +217,7 @@ class ListMetadefNameSpaces(command.Lister):
         )
 
 
-class SetMetadefNameSpace(command.Command):
+class SetMetadefNamespace(command.Command):
     _description = _("Set metadef namespace properties")
 
     def get_parser(self, prog_name):
@@ -223,7 +225,7 @@ class SetMetadefNameSpace(command.Command):
         parser.add_argument(
             "namespace",
             metavar="<namespace>",
-            help=_("Namespace (name) for the namespace"),
+            help=_("Metadef namespace to modify (name)"),
         )
         parser.add_argument(
             "--display-name",
@@ -241,14 +243,16 @@ class SetMetadefNameSpace(command.Command):
             action="store_const",
             const="public",
             dest="visibility",
-            help=_("Set namespace visibility 'public'"),
+            help=_("Metadef namespace is accessible to the public"),
         )
         visibility_group.add_argument(
             "--private",
             action="store_const",
             const="private",
             dest="visibility",
-            help=_("Set namespace visibility 'private'"),
+            help=_(
+                "Metadef namespace is inaccessible to the public (default)"
+            ),
         )
         protected_group = parser.add_mutually_exclusive_group()
         protected_group.add_argument(
@@ -289,24 +293,24 @@ class SetMetadefNameSpace(command.Command):
         image_client.update_metadef_namespace(namespace, **kwargs)
 
 
-class ShowMetadefNameSpace(command.ShowOne):
+class ShowMetadefNamespace(command.ShowOne):
     _description = _("Show a metadef namespace")
 
     def get_parser(self, prog_name):
         parser = super().get_parser(prog_name)
         parser.add_argument(
-            "namespace_name",
-            metavar="<namespace_name>",
-            help=_("Namespace (name) for the namespace"),
+            "namespace",
+            metavar="<namespace>",
+            help=_("Metadef namespace to show (name)"),
         )
         return parser
 
     def take_action(self, parsed_args):
         image_client = self.app.client_manager.image
 
-        namespace_name = parsed_args.namespace_name
+        namespace = parsed_args.namespace
 
-        data = image_client.get_metadef_namespace(namespace_name)
+        data = image_client.get_metadef_namespace(namespace)
         info = _format_namespace(data)
 
         return zip(*sorted(info.items()))

openstackclient/image/v2/metadef_objects.py

@@ -0,0 +1,189 @@
+#   Copyright 2023 Red Hat
+#
+#   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.
+#
+
+"""Image V2 Action Implementations"""
+
+import logging
+
+from osc_lib.command import command
+from osc_lib import exceptions
+from osc_lib import utils
+
+from openstackclient.i18n import _
+
+
+LOG = logging.getLogger(__name__)
+
+
+def _format_object(md_object):
+    fields_to_show = (
+        'created_at',
+        'description',
+        'name',
+        'namespace_name',
+        'properties',
+        'required',
+        'updated_at',
+    )
+
+    return (
+        fields_to_show,
+        utils.get_item_properties(
+            md_object,
+            fields_to_show,
+        ),
+    )
+
+
+class CreateMetadefObjects(command.ShowOne):
+    _description = _("Create a metadef object")
+
+    def get_parser(self, prog_name):
+        parser = super().get_parser(prog_name)
+        parser.add_argument(
+            "--namespace",
+            metavar="<namespace>",
+            help=_("Metadef namespace to create the object in (name)"),
+        )
+        parser.add_argument(
+            "name",
+            metavar='<metadef-object-name>',
+            help=_('New metadef object name'),
+        )
+        return parser
+
+    def take_action(self, parsed_args):
+        image_client = self.app.client_manager.image
+
+        namespace = image_client.get_metadef_namespace(
+            parsed_args.namespace,
+        )
+        data = image_client.create_metadef_object(
+            namespace=namespace.namespace,
+            name=parsed_args.name,
+        )
+
+        fields, value = _format_object(data)
+
+        return fields, value
+
+
+class ShowMetadefObjects(command.ShowOne):
+    _description = _("Show a particular metadef object")
+
+    def get_parser(self, prog_name):
+        parser = super().get_parser(prog_name)
+        parser.add_argument(
+            "namespace",
+            metavar="<namespace>",
+            help=_("Metadef namespace of the object (name)"),
+        )
+        parser.add_argument(
+            "object",
+            metavar="<object>",
+            help=_("Metadef object to show"),
+        )
+        return parser
+
+    def take_action(self, parsed_args):
+        image_client = self.app.client_manager.image
+
+        namespace = parsed_args.namespace
+        object = parsed_args.object
+
+        data = image_client.get_metadef_object(object, namespace)
+
+        fields, value = _format_object(data)
+
+        return fields, value
+
+
+class DeleteMetadefObject(command.Command):
+    _description = _("Delete metadata definitions object(s)")
+
+    def get_parser(self, prog_name):
+        parser = super().get_parser(prog_name)
+        parser.add_argument(
+            "namespace",
+            metavar="<namespace>",
+            help=_("Metadef namespace of the object (name)"),
+        )
+        parser.add_argument(
+            "objects",
+            metavar="<object>",
+            nargs="+",
+            help=_("Metadef object(s) to delete (name)"),
+        )
+        return parser
+
+    def take_action(self, parsed_args):
+        image_client = self.app.client_manager.image
+
+        namespace = parsed_args.namespace
+
+        result = 0
+        for obj in parsed_args.objects:
+            try:
+                object = image_client.get_metadef_object(obj, namespace)
+                image_client.delete_metadef_object(object, namespace)
+            except Exception as e:
+                result += 1
+                LOG.error(
+                    _(
+                        "Failed to delete object with name or "
+                        "ID '%(object)s': %(e)s"
+                    ),
+                    {'object': obj, 'e': e},
+                )
+
+        if result > 0:
+            total = len(parsed_args.namespace)
+            msg = _("%(result)s of %(total)s object failed to delete.") % {
+                'result': result,
+                'total': total,
+            }
+            raise exceptions.CommandError(msg)
+
+
+class ListMetadefObjects(command.Lister):
+    _description = _("List metadef objects inside a specific namespace.")
+
+    def get_parser(self, prog_name):
+        parser = super().get_parser(prog_name)
+        parser.add_argument(
+            "namespace",
+            metavar="<namespace>",
+            help=_("Namespace (name) for the namespace"),
+        )
+        return parser
+
+    def take_action(self, parsed_args):
+        image_client = self.app.client_manager.image
+
+        namespace = parsed_args.namespace
+        columns = ['name', 'description']
+
+        md_objects = list(image_client.metadef_objects(namespace))
+        column_headers = columns
+        return (
+            column_headers,
+            (
+                utils.get_item_properties(
+                    md_object,
+                    columns,
+                )
+                for md_object in md_objects
+            ),
+        )

openstackclient/image/v2/metadef_properties.py

@@ -0,0 +1,284 @@
+# Copyright 2023 Red Hat, Inc.
+#
+# 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 logging
+
+from osc_lib.command import command
+from osc_lib import exceptions
+from osc_lib import utils
+
+from openstackclient.i18n import _
+
+
+LOG = logging.getLogger(__name__)
+
+
+def _format_property(prop):
+    prop = prop.to_dict(ignore_none=True, original_names=True)
+    return {
+        key: prop[key]
+        for key in [
+            'namespace_name',
+            'name',
+            'type',
+            'title',
+            'description',
+            'operators',
+            'default',
+            'is_readonly',
+            'minimum',
+            'maximum',
+            'enum',
+            'pattern',
+            'min_length',
+            'max_length',
+            'items',
+            'require_unique_items',
+            'min_items',
+            'max_items',
+            'allow_additional_items',
+        ]
+        if key in prop
+    }
+
+
+class CreateMetadefProperty(command.ShowOne):
+    _description = _("Create a metadef property")
+
+    def get_parser(self, prog_name):
+        parser = super().get_parser(prog_name)
+        parser.add_argument(
+            "--name",
+            required=True,
+            help=_("Internal name of the property"),
+        )
+        parser.add_argument(
+            "--title",
+            required=True,
+            help=_("Property name displayed to the user"),
+        )
+        parser.add_argument(
+            "--type",
+            required=True,
+            help=_("Property type"),
+        )
+        parser.add_argument(
+            "--schema",
+            required=True,
+            help=_("Valid JSON schema of the property"),
+        )
+        parser.add_argument(
+            "namespace",
+            help=_("Name of namespace the property will belong."),
+        )
+        return parser
+
+    def take_action(self, parsed_args):
+        image_client = self.app.client_manager.image
+
+        kwargs = {
+            'name': parsed_args.name,
+            'title': parsed_args.title,
+            'type': parsed_args.type,
+        }
+        try:
+            kwargs.update(json.loads(parsed_args.schema))
+        except json.JSONDecodeError as e:
+            raise exceptions.CommandError(
+                _("Failed to load JSON schema: %(e)s")
+                % {
+                    'e': e,
+                }
+            )
+
+        data = image_client.create_metadef_property(
+            parsed_args.namespace, **kwargs
+        )
+        info = _format_property(data)
+
+        return zip(*sorted(info.items()))
+
+
+class DeleteMetadefProperty(command.Command):
+    _description = _("Delete metadef propert(ies)")
+
+    def get_parser(self, prog_name):
+        parser = super().get_parser(prog_name)
+        parser.add_argument(
+            "namespace",
+            metavar="<namespace>",
+            help=_("Metadef namespace of the property (name)"),
+        )
+        parser.add_argument(
+            "properties",
+            metavar="<property>",
+            nargs="+",
+            help=_("Metadef propert(ies) to delete (name)"),
+        )
+        return parser
+
+    def take_action(self, parsed_args):
+        image_client = self.app.client_manager.image
+
+        result = 0
+        for prop in parsed_args.properties:
+            try:
+                image_client.delete_metadef_property(
+                    prop,
+                    parsed_args.namespace,
+                    ignore_missing=False,
+                )
+            except Exception as e:
+                result += 1
+                LOG.error(
+                    _(
+                        "Failed to delete property with name or ID "
+                        "'%(property)s' from namespace '%(namespace)s': %(e)s"
+                    ),
+                    {
+                        'property': prop,
+                        'namespace': parsed_args.namespace,
+                        'e': e,
+                    },
+                )
+
+        if result > 0:
+            total = len(parsed_args.namespace)
+            msg = _("%(result)s of %(total)s properties failed to delete.") % {
+                'result': result,
+                'total': total,
+            }
+            raise exceptions.CommandError(msg)
+
+
+class ListMetadefProperties(command.Lister):
+    _description = _("List metadef properties")
+
+    def get_parser(self, prog_name):
+        parser = super().get_parser(prog_name)
+        parser.add_argument(
+            "namespace",
+            metavar="<namespace>",
+            help=_("An identifier (a name) for the namespace"),
+        )
+        return parser
+
+    def take_action(self, parsed_args):
+        image_client = self.app.client_manager.image
+        props = image_client.metadef_properties(parsed_args.namespace)
+        columns = ['name', 'title', 'type']
+        return (
+            columns,
+            (
+                utils.get_item_properties(
+                    prop,
+                    columns,
+                )
+                for prop in props
+            ),
+        )
+
+
+class SetMetadefProperty(command.Command):
+    _description = _("Update metadef namespace property")
+
+    def get_parser(self, prog_name):
+        parser = super().get_parser(prog_name)
+        parser.add_argument(
+            "--name",
+            help=_("Internal name of the property"),
+        )
+        parser.add_argument(
+            "--title",
+            help=_("Property name displayed to the user"),
+        )
+        parser.add_argument(
+            "--type",
+            help=_("Property type"),
+        )
+        parser.add_argument(
+            "--schema",
+            help=_("Valid JSON schema of the property"),
+        )
+        parser.add_argument(
+            "namespace",
+            help=_("Namespace of the namespace to which the property belongs"),
+        )
+        parser.add_argument(
+            "property",
+            help=_("Property to update"),
+        )
+        return parser
+
+    def take_action(self, parsed_args):
+        image_client = self.app.client_manager.image
+
+        # We need to pass the values for *all* attributes as kwargs to
+        # update_metadef_property(), otherwise the attributes that are not
+        # listed will be reset.
+        data = image_client.get_metadef_property(
+            parsed_args.property,
+            parsed_args.namespace,
+        )
+        kwargs = _format_property(data)
+        for key in ['name', 'title', 'type']:
+            argument = getattr(parsed_args, key, None)
+            if argument is not None:
+                kwargs[key] = argument
+
+        if parsed_args.schema:
+            try:
+                kwargs.update(json.loads(parsed_args.schema))
+            except json.JSONDecodeError as e:
+                raise exceptions.CommandError(
+                    _("Failed to load JSON schema: %(e)s")
+                    % {
+                        'e': e,
+                    }
+                )
+
+        image_client.update_metadef_property(
+            parsed_args.property,
+            parsed_args.namespace,
+            **kwargs,
+        )
+
+
+class ShowMetadefProperty(command.ShowOne):
+    _description = _("Show a particular metadef property")
+
+    def get_parser(self, prog_name):
+        parser = super().get_parser(prog_name)
+        parser.add_argument(
+            "namespace",
+            metavar="<namespace>",
+            help=_("Metadef namespace of the property (name)"),
+        )
+        parser.add_argument(
+            "property",
+            metavar="<property>",
+            help=_("Property to show"),
+        )
+        return parser
+
+    def take_action(self, parsed_args):
+        image_client = self.app.client_manager.image
+        data = image_client.get_metadef_property(
+            parsed_args.property,
+            parsed_args.namespace,
+        )
+        info = _format_property(data)
+
+        return zip(*sorted(info.items()))