enable_application_status_check_suppression async ¶

async def enable_application_status_check_suppression(
    self,
    *,
    config_overrides: Optional[AsyncEC2ClientConfig] = None,
    instance_ids: Optional["capo_ec2.types.instance_id_list.InstanceIdList"] = None,
    duration_seconds: Optional["capo_ec2.types.boxed_integer.BoxedInteger"] = None,
    client_token: Optional["capo_ec2.types.string.String"] = None,
    dry_run: Optional["capo_ec2.types.boolean.Boolean"] = None,
) -> "capo_ec2.types.enable_application_status_check_suppression_result.EnableApplicationStatusCheckSuppressionResult":
    """<p>Suppresses application status checks for the specified instances. While suppressed, health checks continue to run but do not affect the instance-level application status. The following rules apply:</p> <ul> <li> <p>You can specify a maximum of 100 instance IDs for each request.</p> </li> <li> <p>Use <code>DisableApplicationStatusCheckSuppression</code> to resume normal health check reporting.</p> </li> <li> <p>If you do not specify <code>DurationSeconds</code>, suppression continues indefinitely until you call <code>DisableApplicationStatusCheckSuppression</code>.</p> </li> </ul>

    Args:
        instance_ids: <p>The IDs of the instances for which to suppress application status checks.</p>
        duration_seconds: <p>The duration, in seconds, for which to suppress application status checks. If omitted, the application status check is suppressed indefinitely until you call <code>DisableApplicationStatusCheckSuppression</code>.</p>
        client_token: <p>A unique, case-sensitive identifier that you provide to ensure that the operation completes no more than one time. If you retry a request with the same token, the service ignores the request but does not return an error. For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/Run_Instance_Idempotency.html">Ensuring idempotency</a>.</p>
        dry_run: <p>Checks whether you have the required permissions for the operation, without actually making the request, and provides an error response. If you have the required permissions, the error response is <code>DryRunOperation</code>. Otherwise, it is <code>UnauthorizedOperation</code>.</p>

    Raises:
        capo_ec2.errors.UnknownServiceError: The service returned an error code this client does not model.

    Examples:
        To enable application status check suppression
        This example suppresses application status check reporting for the specified instance for one hour.

        >>> await client.enable_application_status_check_suppression(instance_ids=['i-0123456789abcdef0'], duration_seconds=3600)
    """

    async def _handler(
        req: "AsyncOperationRequest[capo_ec2.types.enable_application_status_check_suppression_request.EnableApplicationStatusCheckSuppressionRequest]",
    ) -> AsyncOperationResponse[
        "capo_ec2.types.enable_application_status_check_suppression_result.EnableApplicationStatusCheckSuppressionResult"
    ]:
        import capo_ec2._operations.amazon_ec2.enable_application_status_check_suppression

        (
            output,
            http_response,
        ) = await capo_ec2._operations.amazon_ec2.enable_application_status_check_suppression.async_enable_application_status_check_suppression(
            req.options, req.input
        )
        return AsyncOperationResponse(output=output, response=http_response)

    interceptors_, options_ = self.operation_options(
        config_overrides,
        OperationLogging("EnableApplicationStatusCheckSuppression"),
    )
    input_: capo_ec2.types.enable_application_status_check_suppression_request.EnableApplicationStatusCheckSuppressionRequest = {}
    if instance_ids is not None:
        input_["instance_ids"] = instance_ids
    if duration_seconds is not None:
        input_["duration_seconds"] = duration_seconds
    if client_token is None:
        client_token = str(uuid.uuid4())
    input_["client_token"] = client_token
    if dry_run is not None:
        input_["dry_run"] = dry_run

    response = await aexecute_pipeline(
        AsyncOperationRequest(input=input_, options=options_),
        handler=_handler,
        interceptors=list(interceptors_),
    )
    await response.response.aclose()
    return response.output