com.pulumi.awsnative.vpclattice.kotlin.inputs.TargetGroupHealthCheckConfigArgs.kt Maven / Gradle / Ivy

Go to download
@file:Suppress("NAME_SHADOWING", "DEPRECATION")

package com.pulumi.awsnative.vpclattice.kotlin.inputs

import com.pulumi.awsnative.vpclattice.inputs.TargetGroupHealthCheckConfigArgs.builder
import com.pulumi.awsnative.vpclattice.kotlin.enums.TargetGroupHealthCheckConfigProtocol
import com.pulumi.awsnative.vpclattice.kotlin.enums.TargetGroupHealthCheckConfigProtocolVersion
import com.pulumi.core.Output
import com.pulumi.core.Output.of
import com.pulumi.kotlin.ConvertibleToJava
import com.pulumi.kotlin.PulumiTagMarker
import com.pulumi.kotlin.applySuspend
import kotlin.Boolean
import kotlin.Int
import kotlin.String
import kotlin.Suppress
import kotlin.Unit
import kotlin.jvm.JvmName

/**
 *
 * @property enabled Indicates whether health checking is enabled.
 * @property healthCheckIntervalSeconds The approximate amount of time, in seconds, between health checks of an individual target. The range is 5–300 seconds. The default is 30 seconds.
 * @property healthCheckTimeoutSeconds The amount of time, in seconds, to wait before reporting a target as unhealthy. The range is 1–120 seconds. The default is 5 seconds.
 * @property healthyThresholdCount The number of consecutive successful health checks required before considering an unhealthy target healthy. The range is 2–10. The default is 5.
 * @property matcher The codes to use when checking for a successful response from a target.
 * @property path The destination for health checks on the targets. If the protocol version is `HTTP/1.1` or `HTTP/2` , specify a valid URI (for example, `/path?query` ). The default path is `/` . Health checks are not supported if the protocol version is `gRPC` , however, you can choose `HTTP/1.1` or `HTTP/2` and specify a valid URI.
 * @property port The port used when performing health checks on targets. The default setting is the port that a target receives traffic on.
 * @property protocol The protocol used when performing health checks on targets. The possible protocols are `HTTP` and `HTTPS` . The default is `HTTP` .
 * @property protocolVersion The protocol version used when performing health checks on targets. The possible protocol versions are `HTTP1` and `HTTP2` .
 * @property unhealthyThresholdCount The number of consecutive failed health checks required before considering a target unhealthy. The range is 2–10. The default is 2.
 */
public data class TargetGroupHealthCheckConfigArgs(
    public val enabled: Output? = null,
    public val healthCheckIntervalSeconds: Output? = null,
    public val healthCheckTimeoutSeconds: Output? = null,
    public val healthyThresholdCount: Output? = null,
    public val matcher: Output? = null,
    public val path: Output? = null,
    public val port: Output? = null,
    public val protocol: Output? = null,
    public val protocolVersion: Output? = null,
    public val unhealthyThresholdCount: Output? = null,
) : ConvertibleToJava {
    override fun toJava(): com.pulumi.awsnative.vpclattice.inputs.TargetGroupHealthCheckConfigArgs =
        com.pulumi.awsnative.vpclattice.inputs.TargetGroupHealthCheckConfigArgs.builder()
            .enabled(enabled?.applyValue({ args0 -> args0 }))
            .healthCheckIntervalSeconds(healthCheckIntervalSeconds?.applyValue({ args0 -> args0 }))
            .healthCheckTimeoutSeconds(healthCheckTimeoutSeconds?.applyValue({ args0 -> args0 }))
            .healthyThresholdCount(healthyThresholdCount?.applyValue({ args0 -> args0 }))
            .matcher(matcher?.applyValue({ args0 -> args0.let({ args0 -> args0.toJava() }) }))
            .path(path?.applyValue({ args0 -> args0 }))
            .port(port?.applyValue({ args0 -> args0 }))
            .protocol(protocol?.applyValue({ args0 -> args0.let({ args0 -> args0.toJava() }) }))
            .protocolVersion(protocolVersion?.applyValue({ args0 -> args0.let({ args0 -> args0.toJava() }) }))
            .unhealthyThresholdCount(unhealthyThresholdCount?.applyValue({ args0 -> args0 })).build()
}

/**
 * Builder for [TargetGroupHealthCheckConfigArgs].
 */
@PulumiTagMarker
public class TargetGroupHealthCheckConfigArgsBuilder internal constructor() {
    private var enabled: Output? = null

    private var healthCheckIntervalSeconds: Output? = null

    private var healthCheckTimeoutSeconds: Output? = null

    private var healthyThresholdCount: Output? = null

    private var matcher: Output? = null

    private var path: Output? = null

    private var port: Output? = null

    private var protocol: Output? = null

    private var protocolVersion: Output? = null

    private var unhealthyThresholdCount: Output? = null

    /**
     * @param value Indicates whether health checking is enabled.
     */
    @JvmName("xhfhhwgcslkpdheh")
    public suspend fun enabled(`value`: Output) {
        this.enabled = value
    }

    /**
     * @param value The approximate amount of time, in seconds, between health checks of an individual target. The range is 5–300 seconds. The default is 30 seconds.
     */
    @JvmName("usohfccpqsqodtia")
    public suspend fun healthCheckIntervalSeconds(`value`: Output) {
        this.healthCheckIntervalSeconds = value
    }

    /**
     * @param value The amount of time, in seconds, to wait before reporting a target as unhealthy. The range is 1–120 seconds. The default is 5 seconds.
     */
    @JvmName("kfiufklcvjpfohil")
    public suspend fun healthCheckTimeoutSeconds(`value`: Output) {
        this.healthCheckTimeoutSeconds = value
    }

    /**
     * @param value The number of consecutive successful health checks required before considering an unhealthy target healthy. The range is 2–10. The default is 5.
     */
    @JvmName("howunkfmrspoicge")
    public suspend fun healthyThresholdCount(`value`: Output) {
        this.healthyThresholdCount = value
    }

    /**
     * @param value The codes to use when checking for a successful response from a target.
     */
    @JvmName("abscsxlbddgtmyoy")
    public suspend fun matcher(`value`: Output) {
        this.matcher = value
    }

    /**
     * @param value The destination for health checks on the targets. If the protocol version is `HTTP/1.1` or `HTTP/2` , specify a valid URI (for example, `/path?query` ). The default path is `/` . Health checks are not supported if the protocol version is `gRPC` , however, you can choose `HTTP/1.1` or `HTTP/2` and specify a valid URI.
     */
    @JvmName("ohqbkvpugrsunrkb")
    public suspend fun path(`value`: Output) {
        this.path = value
    }

    /**
     * @param value The port used when performing health checks on targets. The default setting is the port that a target receives traffic on.
     */
    @JvmName("qghwfmwbqpyxiicm")
    public suspend fun port(`value`: Output) {
        this.port = value
    }

    /**
     * @param value The protocol used when performing health checks on targets. The possible protocols are `HTTP` and `HTTPS` . The default is `HTTP` .
     */
    @JvmName("ygfkihkbybvrinpi")
    public suspend fun protocol(`value`: Output) {
        this.protocol = value
    }

    /**
     * @param value The protocol version used when performing health checks on targets. The possible protocol versions are `HTTP1` and `HTTP2` .
     */
    @JvmName("tdxcpwkovafxdwyb")
    public suspend fun protocolVersion(`value`: Output) {
        this.protocolVersion = value
    }

    /**
     * @param value The number of consecutive failed health checks required before considering a target unhealthy. The range is 2–10. The default is 2.
     */
    @JvmName("mudwvgmrmdonpffe")
    public suspend fun unhealthyThresholdCount(`value`: Output) {
        this.unhealthyThresholdCount = value
    }

    /**
     * @param value Indicates whether health checking is enabled.
     */
    @JvmName("lrqtkpnbwmerwsdi")
    public suspend fun enabled(`value`: Boolean?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.enabled = mapped
    }

    /**
     * @param value The approximate amount of time, in seconds, between health checks of an individual target. The range is 5–300 seconds. The default is 30 seconds.
     */
    @JvmName("olrpfsbitlggfgnx")
    public suspend fun healthCheckIntervalSeconds(`value`: Int?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.healthCheckIntervalSeconds = mapped
    }

    /**
     * @param value The amount of time, in seconds, to wait before reporting a target as unhealthy. The range is 1–120 seconds. The default is 5 seconds.
     */
    @JvmName("gpfpcwkxettfydyl")
    public suspend fun healthCheckTimeoutSeconds(`value`: Int?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.healthCheckTimeoutSeconds = mapped
    }

    /**
     * @param value The number of consecutive successful health checks required before considering an unhealthy target healthy. The range is 2–10. The default is 5.
     */
    @JvmName("haibspgovhtpftxe")
    public suspend fun healthyThresholdCount(`value`: Int?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.healthyThresholdCount = mapped
    }

    /**
     * @param value The codes to use when checking for a successful response from a target.
     */
    @JvmName("knyolbfmvesgwocx")
    public suspend fun matcher(`value`: TargetGroupMatcherArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.matcher = mapped
    }

    /**
     * @param argument The codes to use when checking for a successful response from a target.
     */
    @JvmName("sbodlrsjlibsxcpf")
    public suspend fun matcher(argument: suspend TargetGroupMatcherArgsBuilder.() -> Unit) {
        val toBeMapped = TargetGroupMatcherArgsBuilder().applySuspend { argument() }.build()
        val mapped = of(toBeMapped)
        this.matcher = mapped
    }

    /**
     * @param value The destination for health checks on the targets. If the protocol version is `HTTP/1.1` or `HTTP/2` , specify a valid URI (for example, `/path?query` ). The default path is `/` . Health checks are not supported if the protocol version is `gRPC` , however, you can choose `HTTP/1.1` or `HTTP/2` and specify a valid URI.
     */
    @JvmName("clkwybvtfixhdcda")
    public suspend fun path(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.path = mapped
    }

    /**
     * @param value The port used when performing health checks on targets. The default setting is the port that a target receives traffic on.
     */
    @JvmName("xmkjdkodhfijfgnr")
    public suspend fun port(`value`: Int?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.port = mapped
    }

    /**
     * @param value The protocol used when performing health checks on targets. The possible protocols are `HTTP` and `HTTPS` . The default is `HTTP` .
     */
    @JvmName("obdthrgfoiyyjxtm")
    public suspend fun protocol(`value`: TargetGroupHealthCheckConfigProtocol?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.protocol = mapped
    }

    /**
     * @param value The protocol version used when performing health checks on targets. The possible protocol versions are `HTTP1` and `HTTP2` .
     */
    @JvmName("poqpopmnfhiobuqu")
    public suspend fun protocolVersion(`value`: TargetGroupHealthCheckConfigProtocolVersion?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.protocolVersion = mapped
    }

    /**
     * @param value The number of consecutive failed health checks required before considering a target unhealthy. The range is 2–10. The default is 2.
     */
    @JvmName("fjorlwxxdaijyvyf")
    public suspend fun unhealthyThresholdCount(`value`: Int?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.unhealthyThresholdCount = mapped
    }

    internal fun build(): TargetGroupHealthCheckConfigArgs = TargetGroupHealthCheckConfigArgs(
        enabled = enabled,
        healthCheckIntervalSeconds = healthCheckIntervalSeconds,
        healthCheckTimeoutSeconds = healthCheckTimeoutSeconds,
        healthyThresholdCount = healthyThresholdCount,
        matcher = matcher,
        path = path,
        port = port,
        protocol = protocol,
        protocolVersion = protocolVersion,
        unhealthyThresholdCount = unhealthyThresholdCount,
    )
}