def _complete_command_wait_info()

in src/aaz_dev/cli/controller/az_atomic_profile_builder.py [0:0]

• 97 lines of code
• 38 McCabe index (conditional complexity)

    def _complete_command_wait_info(cls, command_group):
        assert command_group.commands
        wait_cmd_rids = {}
        for command in command_group.commands.values():
            lro_list = []
            for operation in command.cfg.operations:
                if isinstance(operation, CMDHttpOperation):
                    if operation.long_running:
                        lro_list.append(operation)

            if len(lro_list) == 1:
                # support no wait if there are only one long running operation
                # not support multiple long running operations
                command.support_no_wait = True
                if command.register_info is not None:
                    # command is registered
                    rid = swagger_resource_path_to_resource_id(lro_list[0].http.path)
                    if rid not in wait_cmd_rids:
                        wait_cmd_rids[rid] = {
                            "methods": set()
                        }

        if not wait_cmd_rids:
            return

        # build wait command
        for command in command_group.commands.values():
            for operation in command.cfg.operations:
                # find get operations for wait command
                if not isinstance(operation, CMDHttpOperation):
                    continue
                rid = swagger_resource_path_to_resource_id(operation.http.path)
                if rid not in wait_cmd_rids:
                    continue
                if operation.http.request.method != 'get':
                    wait_cmd_rids[rid]['methods'].add(operation.http.request.method)
                    continue
                if 'get_op' in wait_cmd_rids[rid]:
                    continue

                # verify operation response has provisioning state field
                if not cls._has_provisioning_state(operation):
                    continue

                wait_cmd_rids[rid]['get_op'] = operation.__class__(operation.to_primitive())
                wait_cmd_rids[rid]['args'] = {}
                for resource in command.resources:
                    if rid == resource.id:
                        wait_cmd_rids[rid]['resource'] = resource.__class__(resource.to_primitive())

                params = []
                if operation.http.request.path and operation.http.request.path.params:
                    params += operation.http.request.path.params
                if operation.http.request.query and operation.http.request.query.params:
                    params += operation.http.request.query.params
                if operation.http.request.header and operation.http.request.header.params:
                    params += operation.http.request.header.params
                for param in params:
                    if not param.arg:
                        continue
                    assert param.arg.startswith("$"), f"Not support path arg name: '{param.arg}'"
                    arg, arg_idx = CfgReader.find_arg_in_command_by_var(
                        command=command.cfg,
                        arg_var=param.arg
                    )
                    assert arg is not None
                    wait_cmd_rids[rid]['args'][arg_idx] = arg.__class__(arg.to_primitive())

        for rid, value in [*wait_cmd_rids.items()]:
            if "get_op" not in value:
                logger.error(f'Failed to support wait command for resource: '
                             f'Get operation with provisioning state property does not exist: {rid}')
                del wait_cmd_rids[rid]

        if not wait_cmd_rids:
            return

        if len(wait_cmd_rids) > 1:
            # Not support to generate wait command for multiple resources
            logger.error(f'A wait command cannot apply on multiple resources')
            return

        wait_cmd_info = [*wait_cmd_rids.values()][0]

        wait_command = CLIAtomicCommand()
        wait_command.names = [*command_group.names, "wait"]
        wait_command.help = CLICommandHelp()
        wait_command.help.short = "Place the CLI in a waiting state until a condition is met."
        wait_command.register_info = CLIAtomicCommandRegisterInfo()
        wait_command.resources = [wait_cmd_info['resource']]
        wait_command.cfg = cfg = CMDCommand()
        cfg.name = "wait"
        cfg.version = "undefined"

        arg_group = CMDArgGroup()
        cfg.arg_groups = [arg_group]
        arg_group.name = ""
        arg_group.args = [
            *wait_cmd_info['args'].values()
        ]
        get_op = wait_cmd_info['get_op']
        cfg.operations = [get_op]

        output = CMDObjectOutput()
        for response in get_op.http.responses:
            if response.is_error:
                continue
            if not isinstance(response.body, CMDHttpResponseJsonBody):
                continue
            if response.body.json.var:
                output.ref = response.body.json.var
                break
        if not output.ref:
            raise ValueError("Output ref is empty")
        output.client_flatten = False
        cfg.outputs = [output]
        return wait_command