start_failback_launch ¶

def start_failback_launch(
    self,
    recovery_instance_i_ds: "capo_drs.types.start_failback_request_recovery_instance_i_ds.StartFailbackRequestRecoveryInstanceIDs",
    *,
    config_overrides: Optional[drsClientConfig] = None,
    tags: Optional["capo_drs.types.tags_map.TagsMap"] = None,
) -> "capo_drs.types.start_failback_launch_response.StartFailbackLaunchResponse":
    """<p>Initiates a Job for launching the machine that is being failed back to from the specified Recovery Instance. This will run conversion on the failback client and will reboot your machine, thus completing the failback process.</p>

    Args:
        recovery_instance_i_ds: <p>The IDs of the Recovery Instance whose failback launch we want to request.</p>
        tags: <p>The tags to be associated with the failback launch Job.</p>

    Raises:
        capo_drs.errors.conflict_exception.ConflictException: <p>The request could not be completed due to a conflict with the current state of the target resource.</p>
        capo_drs.errors.internal_server_exception.InternalServerException: <p>The request processing has failed because of an unknown error, exception or failure.</p>
        capo_drs.errors.service_quota_exceeded_exception.ServiceQuotaExceededException: <p>The request could not be completed because its exceeded the service quota.</p>
        capo_drs.errors.throttling_exception.ThrottlingException: <p>The request was denied due to request throttling.</p>
        capo_drs.errors.uninitialized_account_exception.UninitializedAccountException: <p>The account performing the request has not been initialized.</p>
        capo_drs.errors.validation_exception.ValidationException: <p>The input fails to satisfy the constraints specified by the AWS service.</p>
        capo_drs.errors.UnknownServiceError: The service returned an error code this client does not model.
    """

    def _handler(
        req: "OperationRequest[capo_drs.types.start_failback_launch_request.StartFailbackLaunchRequest]",
    ) -> OperationResponse[
        "capo_drs.types.start_failback_launch_response.StartFailbackLaunchResponse"
    ]:
        import capo_drs._operations.elastic_disaster_recovery_service.start_failback_launch

        output, http_response = (
            capo_drs._operations.elastic_disaster_recovery_service.start_failback_launch.start_failback_launch(
                req.options, req.input
            )
        )
        return OperationResponse(output=output, response=http_response)

    def _redact_input(
        input_: "capo_drs.types.start_failback_launch_request.StartFailbackLaunchRequest",
    ) -> dict[str, Any]:
        import capo_drs.types.start_failback_launch_request

        return capo_drs.types.start_failback_launch_request.redact_sensitive(input_)

    def _redact_output(
        output: "capo_drs.types.start_failback_launch_response.StartFailbackLaunchResponse",
    ) -> dict[str, Any]:
        import capo_drs.types.start_failback_launch_response

        return capo_drs.types.start_failback_launch_response.redact_sensitive(
            output
        )

    interceptors_, options_ = self.operation_options(
        config_overrides,
        OperationLogging(
            "StartFailbackLaunch",
            redact_input=_redact_input,
            redact_output=_redact_output,
        ),
    )
    input_: capo_drs.types.start_failback_launch_request.StartFailbackLaunchRequest = {
        "recovery_instance_i_ds": recovery_instance_i_ds
    }
    if tags is not None:
        input_["tags"] = tags

    response = execute_pipeline(
        OperationRequest(input=input_, options=options_),
        handler=_handler,
        interceptors=list(interceptors_),
    )
    response.response.close()
    return response.output