Merge pull request Azure#454 from necusjz/identity-subcommand-patch

support get + patch on identity subcommand

Author: necusjz

src/aaz_dev/cli/templates/aaz/command/_cmd.py.j2

@@ -489,6 +489,18 @@ class {{ leaf.cls_name }}(
 
         @property
         def content(self):
+            {%- if op.content.ref is not none and op.content._json.schema is not none -%}
+
+            {%- if op.method == "PATCH" %}
+            {%- set valid_ops = leaf.operations | selectattr("is_selector_variant") | list %}
+            {%- if valid_ops %}
+            {%- set temp_op = valid_ops[0] %}
+            identity = self.serialize_content({{ temp_op.variant_key }}.required())
+            return {"identity": identity}
+            {%- endif %}
+            {%- endif %}
+
+            {%- else %}
             {{ op.content.VALUE_NAME}}, {{ op.content.BUILDER_NAME }} = self.new_content_builder(
                 {{ op.content.arg_key }},
                 {%- if op.content.ref is not none %}
@@ -546,6 +558,7 @@ class {{ leaf.cls_name }}(
             {%- endif %}
 
             return self.serialize_content({{ op.content.VALUE_NAME }})
+            {%- endif %}
         {%- endif %}
 
         {%- if op.form_content is not none %}

src/aaz_dev/command/controller/cfg_reader.py

@@ -744,10 +744,74 @@ def find_sub_schema(cls, schema, idx):
 
         return None
 
+    @classmethod
+    def trim_identity_schema_by_idx(cls, schema, idx):  # only keep identity and its parents
+        if not schema:
+            return
+
+        current_idx = idx[0] if idx else None
+        remain_idx = idx[1:] if idx else None
+
+        identity_schema = schema.__class__(raw_data=schema.to_native())
+        if isinstance(identity_schema, CMDObjectSchemaBase):
+            if current_idx == '{}':
+                if identity_schema.additional_props and identity_schema.additional_props.item:
+                    identity_schema.additional_props.item = cls.trim_identity_schema_by_idx(identity_schema.additional_props.item, remain_idx)
+
+            elif identity_schema.props:
+                if current_idx:
+                    props = []
+                    for prop in identity_schema.props:
+                        if current_idx == prop.name:
+                            props.append(cls.trim_identity_schema_by_idx(prop, remain_idx))
+                    identity_schema.props = props
+                else:
+                    identity_schema.props = None
+                    if isinstance(identity_schema, CMDIdentityObjectSchema):
+                        identity_schema.system_assigned = None
+                        identity_schema.user_assigned = None
+
+            elif identity_schema.discriminators:
+                if current_idx:
+                    discriminators = []
+                    for disc in identity_schema.discriminators:
+                        if current_idx == disc.get_safe_value():
+                            discriminators.append(cls.trim_identity_schema_by_idx(disc, remain_idx))
+                    identity_schema.discriminators = discriminators
+                else:
+                    identity_schema.discriminators = None
+
+        elif isinstance(identity_schema, CMDObjectSchemaDiscriminator):
+            if identity_schema.props:
+                if current_idx:
+                    props = []
+                    for prop in identity_schema.props:
+                        if current_idx == prop.name:
+                            props.append(cls.trim_identity_schema_by_idx(prop, remain_idx))
+                    identity_schema.props = props
+                else:
+                    identity_schema.props = None
+
+            elif identity_schema.discriminators:
+                if current_idx:
+                    discriminators = []
+                    for disc in identity_schema.discriminators:
+                        if current_idx == disc.get_safe_value():
+                            discriminators.append(cls.trim_identity_schema_by_idx(disc, remain_idx))
+                    identity_schema.discriminators = discriminators
+                else:
+                    identity_schema.discriminators = None
+
+        elif isinstance(identity_schema, CMDArraySchemaBase):
+            if current_idx == '[]':
+                identity_schema.item = cls.trim_identity_schema_by_idx(identity_schema.item, remain_idx)
+
+        return identity_schema
+
     @classmethod
     def find_identity_schema_in_command(cls, command):
         for operation in command.operations:
-            if isinstance(operation, CMDInstanceUpdateOperation):
+            if isinstance(operation, CMDInstanceUpdateOperation) or isinstance(operation, CMDHttpOperation):
                 for match in cls.iter_schema_in_update_operation_by_identity(operation):
                     return operation, *match
 
@@ -759,11 +823,17 @@ def schema_filter(_parent, _schema, _schema_idx):
                 return (_parent, _schema, _schema_idx), False
             return None, False
 
-        for parent, schema, schema_idx in cls._iter_schema_in_json(
-                operation.instance_update.json, schema_filter=schema_filter):
-            if schema:
-                schema_idx = [_SchemaIdxEnum.Instance, _SchemaIdxEnum.Update, *schema_idx]
-                yield parent, schema, schema_idx
+        if isinstance(operation, CMDInstanceUpdateOperation):
+            for parent, schema, schema_idx in cls._iter_schema_in_json(operation.instance_update.json, schema_filter=schema_filter):
+                if schema:
+                    schema_idx = [_SchemaIdxEnum.Instance, _SchemaIdxEnum.Update, *schema_idx]
+                    yield parent, schema, schema_idx
+
+        else:
+            for parent, schema, schema_idx in cls._iter_schema_in_request(operation.http.request, schema_filter=schema_filter):
+                if schema:
+                    schema_idx = [_SchemaIdxEnum.Instance, _SchemaIdxEnum.Update, *schema_idx]
+                    yield parent, schema, schema_idx
 
     @classmethod
     def iter_schema_in_command_by_arg_var(cls, command, arg_var):

src/aaz_dev/command/controller/workspace_cfg_editor.py

@@ -1064,14 +1064,14 @@ def remove_subresource_commands(self, resource_id, version, subresource):
         self.reformat()
         return commands
 
-    def build_identity_subresource(self, resource_id, temp_generic_update_cmd=None):
+    def build_identity_subresource(self, resource_id, temp_update_cmd=None):
         update_cmd_info = self.get_update_cmd(resource_id)
         if not update_cmd_info:
             return
         update_cmd_names, update_cmd, update_by = update_cmd_info
-        if update_by == "PatchOnly" and temp_generic_update_cmd is not None:
-            # generate temp update command using generic update
-            update_cmd = temp_generic_update_cmd
+        if update_by == "PatchOnly" and temp_update_cmd is not None:
+            # generate temp update command using get + patch
+            update_cmd = temp_update_cmd
             update_cmd.name = ' '.join(update_cmd_names)
         elif update_by != "GenericOnly":
             return
@@ -1405,7 +1405,9 @@ def _generate_sub_commands(cls, schema, subresource_idx, update_cmd, ref_args_op
     def _build_sub_command_base(cls, update_cmd, subresource_idx, **kwargs):
         get_op = None
         put_op = None
+        patch_op = None
         update_op = None
+
         for operation in update_cmd.operations:
             if isinstance(operation, CMDInstanceUpdateOperation):
                 update_op = operation
@@ -1414,8 +1416,11 @@ def _build_sub_command_base(cls, update_cmd, subresource_idx, **kwargs):
                     get_op = operation
                 if operation.http.request.method == "put":
                     put_op = operation
+                if operation.http.request.method == "patch":
+                    patch_op = operation
+
         assert get_op is not None
-        assert put_op is not None
+        assert put_op is not None or patch_op is not None
         assert update_op is not None
 
         # find response body
@@ -1440,7 +1445,11 @@ def _build_sub_command_base(cls, update_cmd, subresource_idx, **kwargs):
         _sub_command.resources = [_resource]
         _sub_command.subresource_selector = cls._build_subresource_selector(
             response_json, update_json, subresource_idx, **kwargs)
-        return _sub_command, get_op, put_op, update_json
+
+        if patch_op is not None:
+            return _sub_command, get_op, patch_op, update_json
+        if put_op is not None:
+            return _sub_command, get_op, put_op, update_json
 
     @classmethod
     def _build_subresource_list_or_show_command(cls, update_cmd, subresource_idx, ref_args, ref_options):
@@ -1491,7 +1500,7 @@ def _build_subresource_create_command(cls, update_cmd, subresource_idx, ref_args
 
     @classmethod
     def _build_subresource_update_command(cls, update_cmd, subresource_idx, ref_args, ref_options, action=None):
-        _sub_command, get_op, put_op, update_json = cls._build_sub_command_base(update_cmd, subresource_idx)
+        _sub_command, get_op, update_op, update_json = cls._build_sub_command_base(update_cmd, subresource_idx)
 
         _instance_op = CMDInstanceUpdateOperation()
         _instance_op.instance_update = CMDJsonInstanceUpdateAction()
@@ -1519,10 +1528,14 @@ def _build_subresource_update_command(cls, update_cmd, subresource_idx, ref_args
         _instance_op_schema.required = True
         _instance_op.instance_update.json.schema = _instance_op_schema
 
+        put_or_patch = update_op.__class__(raw_data=update_op.to_native())
+        if update_op.http.request.method == "patch":
+            put_or_patch.http.request.body.json.schema = cls.trim_identity_schema_by_idx(put_or_patch.http.request.body.json.schema, subresource_idx)
+
         _sub_command.operations = [
             get_op.__class__(raw_data=get_op.to_native()),
             _instance_op,
-            put_op.__class__(raw_data=put_op.to_native()),
+            put_or_patch
         ]
         _sub_command.generate_args(ref_args=ref_args, ref_options=ref_options)
         _sub_command.generate_outputs(ref_outputs=update_cmd.outputs)

src/aaz_dev/command/controller/workspace_manager.py

@@ -666,13 +666,13 @@ def _add_new_resources(self, command_generator, resources, resource_options):
                     aaz_ref[' '.join(cmd_names)] = aaz_version
 
             update_cmd_info = cfg_editor.get_update_cmd(resource.id)
-            temp_generic_update_cmd = None
-            if update_cmd_info and options.get('update_by', None) == "PatchOnly":
-                temp_cfg_editor = self._build_draft_cfg_editor(command_generator, resource, {"update_by": "GenericOnly", "methods": ('get', 'put')})
+            temp_update_cmd = None
+            if update_cmd_info and options.get('update_by', None) == "PatchOnly" and cfg_editor.find_identity_schema_in_command(update_cmd_info[1]):
+                temp_cfg_editor = self._build_draft_cfg_editor(command_generator, resource, {"update_by": "PatchOnly", "methods": ('get', 'patch'), "is_identity": True})
                 temp_update_cmd_info = temp_cfg_editor.get_update_cmd(resource.id)
                 if temp_update_cmd_info:
-                    _, temp_generic_update_cmd, _ = temp_update_cmd_info
-            cfg_editor.build_identity_subresource(resource.id, temp_generic_update_cmd)
+                    _, temp_update_cmd, _ = temp_update_cmd_info
+            cfg_editor.build_identity_subresource(resource.id, temp_update_cmd)
             cfg_editors.append(cfg_editor)
 
         # add cfg_editors
@@ -789,17 +789,18 @@ def _reload_resources(self, command_generator, reload_resource_map):
                 options['methods'] = methods
             update_cmd_info = cfg_editor.get_update_cmd(resource_id)
             if update_cmd_info:
-                _, _, update_by = update_cmd_info
+                _, command, update_by = update_cmd_info
                 options['update_by'] = update_by
             new_cfg_editor = self._build_draft_cfg_editor(command_generator, resource, options)
             new_cfg_editor.inherit_modification(cfg_editor)
-            temp_generic_update_cmd = None
-            if update_cmd_info and update_by == "PatchOnly":
-                temp_cfg_editor = self._build_draft_cfg_editor(command_generator, resource, {"update_by": "GenericOnly", "methods": ('get', 'put')})
+            temp_update_cmd = None
+            if update_cmd_info and update_by == "PatchOnly" and cfg_editor.find_identity_schema_in_command(command):
+                temp_cfg_editor = self._build_draft_cfg_editor(command_generator, resource, {"update_by": "PatchOnly", "methods": ('get', 'patch'), "is_identity": True})
                 temp_update_cmd_info = temp_cfg_editor.get_update_cmd(resource_id)
                 if temp_update_cmd_info:
-                    _, temp_generic_update_cmd, _ = temp_update_cmd_info
-            new_cfg_editor.build_identity_subresource(resource_id, temp_generic_update_cmd)
+                    _, temp_update_cmd, _ = temp_update_cmd_info
+
+            new_cfg_editor.build_identity_subresource(resource_id, temp_update_cmd)
             new_cfg_editors.append(new_cfg_editor)
 
         # remove old cfg editor

src/aaz_dev/swagger/controller/command_generator.py

@@ -102,6 +102,52 @@ def generate_generic_update_command(cls, path_item, resource, instance_var, cmd_
         command.name = f"{group_name} update"
         return command
 
+    @classmethod
+    def generate_specific_update_command(cls, path_item, resource, instance_var, cmd_builder, get_op, patch_op):
+        command = CMDCommand()
+        command.version = cls.generate_command_version(resource)
+        command.resources = [
+            resource.to_cmd() if not isinstance(resource, CMDResource) else resource
+        ]
+        assert path_item.get is not None
+        assert path_item.patch is not None
+
+        cmd_builder.apply_cls_definitions(get_op, patch_op)
+
+        if patch_op.http.request.body is None:
+            return None
+
+        if not cls._set_api_version_parameter(get_op.http.request, api_version=resource.version):
+            logger.warning(f"Cannot Find api version parameter: {resource.path}, 'get' : {path_item.traces}")
+        if not cls._set_api_version_parameter(patch_op.http.request, api_version=resource.version):
+            logger.warning(f"Cannot Find api version parameter: {resource.path}, 'patch' : {path_item.traces}")
+
+        if not command.build_output_by_operation(get_op):
+            return None
+
+        if not command.build_output_by_operation(patch_op):
+            return None
+
+        cls._filter_generic_update_parameters(get_op, patch_op)
+
+        command.description = patch_op.description
+        json_update_op = cls._generate_instance_patch_operation(patch_op, instance_var)
+        command.operations = [
+            get_op,
+            json_update_op,
+            patch_op
+        ]
+
+        command.generate_args()
+        command.generate_outputs()
+
+        assert command.outputs
+
+        group_name = cls.generate_command_group_name_by_resource(
+            resource_path=resource.path, rp_name=resource.rp_name)
+        command.name = f"{group_name} update"
+        return command
+
     @staticmethod
     def _set_api_version_parameter(request, api_version):
         assert isinstance(request, CMDHttpRequest)
@@ -254,6 +300,17 @@ def _generate_instance_update_operation(put_op, instance_var):
         put_op.http.request.body.json.schema = None
         return json_update_op
 
+    @staticmethod
+    def _generate_instance_patch_operation(patch_op, instance_var):
+        json_update_op = CMDInstanceUpdateOperation()
+        json_update_op.instance_update = CMDJsonInstanceUpdateAction()
+        json_update_op.instance_update.ref = instance_var
+        json_update_op.instance_update.json = CMDRequestJson()
+        json_update_op.instance_update.json.schema = patch_op.http.request.body.json.schema
+
+        patch_op.http.request.body.json.ref = instance_var
+        return json_update_op
+
     @staticmethod
     def _filter_generic_update_parameters(get_op, put_op):
         """Get operation may contain useless query or header parameters for update, ignore them"""
@@ -470,11 +527,24 @@ def create_draft_command_group(self, resource,
                     raise exceptions.InvalidAPIUsage(f"Invalid update_by resource: resource needs to have 'patch' operation: '{resource}'")
                 if 'patch' not in methods:
                     raise exceptions.InvalidAPIUsage(f"Invalid update_by resource: '{resource}': 'patch' not in methods: '{methods}'")
-                cmd_builder = CMDBuilder(path=resource.path, method='patch', mutability=MutabilityEnum.Update,
-                                         parameterized_host=parameterized_host)
-                op = self.generate_operation(cmd_builder, path_item, instance_var)
-                patch_update_command = self.generate_command(path_item, resource, instance_var, cmd_builder, op)
-                command_group.commands.append(patch_update_command)
+
+                if kwargs.get('is_identity', False) is True:
+                    cmd_builder = CMDBuilder(path=resource.path, parameterized_host=parameterized_host)
+                    get_op = self.generate_operation(cmd_builder, path_item, instance_var, method='get', mutability=MutabilityEnum.Read)
+                    patch_op = self.generate_operation(cmd_builder, path_item, instance_var, method='patch', mutability=MutabilityEnum.Update)
+                    specific_update_command = self.generate_specific_update_command(path_item, resource, instance_var, cmd_builder, get_op, patch_op)
+
+                    if specific_update_command is None:
+                        raise exceptions.InvalidAPIUsage(f"Invalid update_by resource: failed to generate specific update: '{resource}'")
+
+                    command_group.commands.append(specific_update_command)
+
+                else:
+                    cmd_builder = CMDBuilder(path=resource.path, method='patch', mutability=MutabilityEnum.Update,
+                                             parameterized_host=parameterized_host)
+                    op = self.generate_operation(cmd_builder, path_item, instance_var)
+                    patch_update_command = self.generate_command(path_item, resource, instance_var, cmd_builder, op)
+                    command_group.commands.append(patch_update_command)
             # elif update_by == 'GenericAndPatch':
             #     # TODO: add support for generic and patch merge
             #     if path_item.get is None or path_item.put is None or path_item.patch is None: