com.pulumi.azurenative.app.kotlin.inputs.HttpRetryPolicyArgs.kt Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of pulumi-azure-native-kotlin Show documentation
Build cloud applications and infrastructure by combining the safety and reliability of infrastructure as code with the power of the Kotlin programming language.
There is a newer version: 2.82.0.0
Show newest version
@file:Suppress("NAME_SHADOWING", "DEPRECATION")

package com.pulumi.azurenative.app.kotlin.inputs

import com.pulumi.azurenative.app.inputs.HttpRetryPolicyArgs.builder
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.Double
import kotlin.Int
import kotlin.String
import kotlin.Suppress
import kotlin.Unit
import kotlin.collections.List
import kotlin.jvm.JvmName

/**
 * Policy that defines http request retry conditions
 * @property errors Errors that can trigger a retry
 * @property headers Headers that must be present for a request to be retried
 * @property httpStatusCodes Additional http status codes that can trigger a retry
 * @property initialDelayInMilliseconds Initial delay, in milliseconds, before retrying a request
 * @property maxIntervalInMilliseconds Maximum interval, in milliseconds, between retries
 * @property maxRetries Maximum number of times a request will retry
 */
public data class HttpRetryPolicyArgs(
    public val errors: Output>? = null,
    public val headers: Output>? = null,
    public val httpStatusCodes: Output>? = null,
    public val initialDelayInMilliseconds: Output? = null,
    public val maxIntervalInMilliseconds: Output? = null,
    public val maxRetries: Output? = null,
) : ConvertibleToJava {
    override fun toJava(): com.pulumi.azurenative.app.inputs.HttpRetryPolicyArgs =
        com.pulumi.azurenative.app.inputs.HttpRetryPolicyArgs.builder()
            .errors(errors?.applyValue({ args0 -> args0.map({ args0 -> args0 }) }))
            .headers(
                headers?.applyValue({ args0 ->
                    args0.map({ args0 ->
                        args0.let({ args0 ->
                            args0.toJava()
                        })
                    })
                }),
            )
            .httpStatusCodes(httpStatusCodes?.applyValue({ args0 -> args0.map({ args0 -> args0 }) }))
            .initialDelayInMilliseconds(initialDelayInMilliseconds?.applyValue({ args0 -> args0 }))
            .maxIntervalInMilliseconds(maxIntervalInMilliseconds?.applyValue({ args0 -> args0 }))
            .maxRetries(maxRetries?.applyValue({ args0 -> args0 })).build()
}

/**
 * Builder for [HttpRetryPolicyArgs].
 */
@PulumiTagMarker
public class HttpRetryPolicyArgsBuilder internal constructor() {
    private var errors: Output>? = null

    private var headers: Output>? = null

    private var httpStatusCodes: Output>? = null

    private var initialDelayInMilliseconds: Output? = null

    private var maxIntervalInMilliseconds: Output? = null

    private var maxRetries: Output? = null

    /**
     * @param value Errors that can trigger a retry
     */
    @JvmName("iedfophrkqjaiybj")
    public suspend fun errors(`value`: Output>) {
        this.errors = value
    }

    @JvmName("cbhckndowqvpield")
    public suspend fun errors(vararg values: Output) {
        this.errors = Output.all(values.asList())
    }

    /**
     * @param values Errors that can trigger a retry
     */
    @JvmName("heagxikqgfgbofxq")
    public suspend fun errors(values: List>) {
        this.errors = Output.all(values)
    }

    /**
     * @param value Headers that must be present for a request to be retried
     */
    @JvmName("hgpkviifcfmubioh")
    public suspend fun headers(`value`: Output>) {
        this.headers = value
    }

    @JvmName("iscyfbrityijrhst")
    public suspend fun headers(vararg values: Output) {
        this.headers = Output.all(values.asList())
    }

    /**
     * @param values Headers that must be present for a request to be retried
     */
    @JvmName("kfqiqmfrnaxxeajq")
    public suspend fun headers(values: List>) {
        this.headers = Output.all(values)
    }

    /**
     * @param value Additional http status codes that can trigger a retry
     */
    @JvmName("dtebtdpkbqosbufj")
    public suspend fun httpStatusCodes(`value`: Output>) {
        this.httpStatusCodes = value
    }

    @JvmName("wfpafhqumaigftbg")
    public suspend fun httpStatusCodes(vararg values: Output) {
        this.httpStatusCodes = Output.all(values.asList())
    }

    /**
     * @param values Additional http status codes that can trigger a retry
     */
    @JvmName("kkhtcxwudwmvwdch")
    public suspend fun httpStatusCodes(values: List>) {
        this.httpStatusCodes = Output.all(values)
    }

    /**
     * @param value Initial delay, in milliseconds, before retrying a request
     */
    @JvmName("onpthjwoiodikdnc")
    public suspend fun initialDelayInMilliseconds(`value`: Output) {
        this.initialDelayInMilliseconds = value
    }

    /**
     * @param value Maximum interval, in milliseconds, between retries
     */
    @JvmName("tvpswqkubtmaaxsr")
    public suspend fun maxIntervalInMilliseconds(`value`: Output) {
        this.maxIntervalInMilliseconds = value
    }

    /**
     * @param value Maximum number of times a request will retry
     */
    @JvmName("tcoiymrkhtggbcad")
    public suspend fun maxRetries(`value`: Output) {
        this.maxRetries = value
    }

    /**
     * @param value Errors that can trigger a retry
     */
    @JvmName("wukyynwuipcenwlg")
    public suspend fun errors(`value`: List?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.errors = mapped
    }

    /**
     * @param values Errors that can trigger a retry
     */
    @JvmName("pisafqdpmhdjcfve")
    public suspend fun errors(vararg values: String) {
        val toBeMapped = values.toList()
        val mapped = toBeMapped.let({ args0 -> of(args0) })
        this.errors = mapped
    }

    /**
     * @param value Headers that must be present for a request to be retried
     */
    @JvmName("qgfnptrbymxmxcnf")
    public suspend fun headers(`value`: List?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.headers = mapped
    }

    /**
     * @param argument Headers that must be present for a request to be retried
     */
    @JvmName("yaybooarpstbheme")
    public suspend fun headers(argument: List Unit>) {
        val toBeMapped = argument.toList().map { HeaderMatchArgsBuilder().applySuspend { it() }.build() }
        val mapped = of(toBeMapped)
        this.headers = mapped
    }

    /**
     * @param argument Headers that must be present for a request to be retried
     */
    @JvmName("ufsofwuhydbtvgbs")
    public suspend fun headers(vararg argument: suspend HeaderMatchArgsBuilder.() -> Unit) {
        val toBeMapped = argument.toList().map { HeaderMatchArgsBuilder().applySuspend { it() }.build() }
        val mapped = of(toBeMapped)
        this.headers = mapped
    }

    /**
     * @param argument Headers that must be present for a request to be retried
     */
    @JvmName("mknhweqmufexxqns")
    public suspend fun headers(argument: suspend HeaderMatchArgsBuilder.() -> Unit) {
        val toBeMapped = listOf(HeaderMatchArgsBuilder().applySuspend { argument() }.build())
        val mapped = of(toBeMapped)
        this.headers = mapped
    }

    /**
     * @param values Headers that must be present for a request to be retried
     */
    @JvmName("aobqtyrosiorvfsw")
    public suspend fun headers(vararg values: HeaderMatchArgs) {
        val toBeMapped = values.toList()
        val mapped = toBeMapped.let({ args0 -> of(args0) })
        this.headers = mapped
    }

    /**
     * @param value Additional http status codes that can trigger a retry
     */
    @JvmName("xyqvqaorkkkiysex")
    public suspend fun httpStatusCodes(`value`: List?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.httpStatusCodes = mapped
    }

    /**
     * @param values Additional http status codes that can trigger a retry
     */
    @JvmName("ohrhkkuhljekmbkq")
    public suspend fun httpStatusCodes(vararg values: Int) {
        val toBeMapped = values.toList()
        val mapped = toBeMapped.let({ args0 -> of(args0) })
        this.httpStatusCodes = mapped
    }

    /**
     * @param value Initial delay, in milliseconds, before retrying a request
     */
    @JvmName("onessgtgjtxbfqbe")
    public suspend fun initialDelayInMilliseconds(`value`: Double?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.initialDelayInMilliseconds = mapped
    }

    /**
     * @param value Maximum interval, in milliseconds, between retries
     */
    @JvmName("ganniasnuaaadyny")
    public suspend fun maxIntervalInMilliseconds(`value`: Double?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.maxIntervalInMilliseconds = mapped
    }

    /**
     * @param value Maximum number of times a request will retry
     */
    @JvmName("eutfhsqdnsmusyho")
    public suspend fun maxRetries(`value`: Int?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.maxRetries = mapped
    }

    internal fun build(): HttpRetryPolicyArgs = HttpRetryPolicyArgs(
        errors = errors,
        headers = headers,
        httpStatusCodes = httpStatusCodes,
        initialDelayInMilliseconds = initialDelayInMilliseconds,
        maxIntervalInMilliseconds = maxIntervalInMilliseconds,
        maxRetries = maxRetries,
    )
}