com.pulumi.gcp.appengine.kotlin.inputs.FlexibleAppVersionAutomaticScalingArgs.kt Maven / Gradle / Ivy

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

package com.pulumi.gcp.appengine.kotlin.inputs

import com.pulumi.core.Output
import com.pulumi.core.Output.of
import com.pulumi.gcp.appengine.inputs.FlexibleAppVersionAutomaticScalingArgs.builder
import com.pulumi.kotlin.ConvertibleToJava
import com.pulumi.kotlin.PulumiNullFieldException
import com.pulumi.kotlin.PulumiTagMarker
import com.pulumi.kotlin.applySuspend
import kotlin.Int
import kotlin.String
import kotlin.Suppress
import kotlin.Unit
import kotlin.jvm.JvmName

/**
 *
 * @property coolDownPeriod The time period that the Autoscaler should wait before it starts collecting information from a new instance.
 * This prevents the autoscaler from collecting information when the instance is initializing,
 * during which the collected usage would not be reliable. Default: 120s
 * @property cpuUtilization Target scaling by CPU usage.
 * Structure is documented below.
 * @property diskUtilization Target scaling by disk usage.
 * Structure is documented below.
 * @property maxConcurrentRequests Number of concurrent requests an automatic scaling instance can accept before the scheduler spawns a new instance.
 * Defaults to a runtime-specific value.
 * @property maxIdleInstances Maximum number of idle instances that should be maintained for this version.
 * @property maxPendingLatency Maximum amount of time that a request should wait in the pending queue before starting a new instance to handle it.
 * @property maxTotalInstances Maximum number of instances that should be started to handle requests for this version. Default: 20
 * @property minIdleInstances Minimum number of idle instances that should be maintained for this version. Only applicable for the default version of a service.
 * @property minPendingLatency Minimum amount of time a request should wait in the pending queue before starting a new instance to handle it.
 * @property minTotalInstances Minimum number of running instances that should be maintained for this version. Default: 2
 * @property networkUtilization Target scaling by network usage.
 * Structure is documented below.
 * @property requestUtilization Target scaling by request utilization.
 * Structure is documented below.
 */
public data class FlexibleAppVersionAutomaticScalingArgs(
    public val coolDownPeriod: Output? = null,
    public val cpuUtilization: Output,
    public val diskUtilization: Output? = null,
    public val maxConcurrentRequests: Output? = null,
    public val maxIdleInstances: Output? = null,
    public val maxPendingLatency: Output? = null,
    public val maxTotalInstances: Output? = null,
    public val minIdleInstances: Output? = null,
    public val minPendingLatency: Output? = null,
    public val minTotalInstances: Output? = null,
    public val networkUtilization: Output? =
        null,
    public val requestUtilization: Output? =
        null,
) : ConvertibleToJava {
    override fun toJava(): com.pulumi.gcp.appengine.inputs.FlexibleAppVersionAutomaticScalingArgs =
        com.pulumi.gcp.appengine.inputs.FlexibleAppVersionAutomaticScalingArgs.builder()
            .coolDownPeriod(coolDownPeriod?.applyValue({ args0 -> args0 }))
            .cpuUtilization(cpuUtilization.applyValue({ args0 -> args0.let({ args0 -> args0.toJava() }) }))
            .diskUtilization(diskUtilization?.applyValue({ args0 -> args0.let({ args0 -> args0.toJava() }) }))
            .maxConcurrentRequests(maxConcurrentRequests?.applyValue({ args0 -> args0 }))
            .maxIdleInstances(maxIdleInstances?.applyValue({ args0 -> args0 }))
            .maxPendingLatency(maxPendingLatency?.applyValue({ args0 -> args0 }))
            .maxTotalInstances(maxTotalInstances?.applyValue({ args0 -> args0 }))
            .minIdleInstances(minIdleInstances?.applyValue({ args0 -> args0 }))
            .minPendingLatency(minPendingLatency?.applyValue({ args0 -> args0 }))
            .minTotalInstances(minTotalInstances?.applyValue({ args0 -> args0 }))
            .networkUtilization(
                networkUtilization?.applyValue({ args0 ->
                    args0.let({ args0 ->
                        args0.toJava()
                    })
                }),
            )
            .requestUtilization(
                requestUtilization?.applyValue({ args0 ->
                    args0.let({ args0 ->
                        args0.toJava()
                    })
                }),
            ).build()
}

/**
 * Builder for [FlexibleAppVersionAutomaticScalingArgs].
 */
@PulumiTagMarker
public class FlexibleAppVersionAutomaticScalingArgsBuilder internal constructor() {
    private var coolDownPeriod: Output? = null

    private var cpuUtilization: Output? = null

    private var diskUtilization: Output? = null

    private var maxConcurrentRequests: Output? = null

    private var maxIdleInstances: Output? = null

    private var maxPendingLatency: Output? = null

    private var maxTotalInstances: Output? = null

    private var minIdleInstances: Output? = null

    private var minPendingLatency: Output? = null

    private var minTotalInstances: Output? = null

    private var networkUtilization: Output? =
        null

    private var requestUtilization: Output? =
        null

    /**
     * @param value The time period that the Autoscaler should wait before it starts collecting information from a new instance.
     * This prevents the autoscaler from collecting information when the instance is initializing,
     * during which the collected usage would not be reliable. Default: 120s
     */
    @JvmName("ndquoutfkdhpmyxu")
    public suspend fun coolDownPeriod(`value`: Output) {
        this.coolDownPeriod = value
    }

    /**
     * @param value Target scaling by CPU usage.
     * Structure is documented below.
     */
    @JvmName("crspmrdchfuywcow")
    public suspend fun cpuUtilization(`value`: Output) {
        this.cpuUtilization = value
    }

    /**
     * @param value Target scaling by disk usage.
     * Structure is documented below.
     */
    @JvmName("wfydxeaigdjdgcoc")
    public suspend fun diskUtilization(`value`: Output) {
        this.diskUtilization = value
    }

    /**
     * @param value Number of concurrent requests an automatic scaling instance can accept before the scheduler spawns a new instance.
     * Defaults to a runtime-specific value.
     */
    @JvmName("bfpwlcubvqkexcph")
    public suspend fun maxConcurrentRequests(`value`: Output) {
        this.maxConcurrentRequests = value
    }

    /**
     * @param value Maximum number of idle instances that should be maintained for this version.
     */
    @JvmName("ghjmkxxnyhcmktan")
    public suspend fun maxIdleInstances(`value`: Output) {
        this.maxIdleInstances = value
    }

    /**
     * @param value Maximum amount of time that a request should wait in the pending queue before starting a new instance to handle it.
     */
    @JvmName("yimdoqgxhcmuirpp")
    public suspend fun maxPendingLatency(`value`: Output) {
        this.maxPendingLatency = value
    }

    /**
     * @param value Maximum number of instances that should be started to handle requests for this version. Default: 20
     */
    @JvmName("cubjbwknauifrnjs")
    public suspend fun maxTotalInstances(`value`: Output) {
        this.maxTotalInstances = value
    }

    /**
     * @param value Minimum number of idle instances that should be maintained for this version. Only applicable for the default version of a service.
     */
    @JvmName("phiiolgtdldhmkma")
    public suspend fun minIdleInstances(`value`: Output) {
        this.minIdleInstances = value
    }

    /**
     * @param value Minimum amount of time a request should wait in the pending queue before starting a new instance to handle it.
     */
    @JvmName("fgqvnibiymrjccmc")
    public suspend fun minPendingLatency(`value`: Output) {
        this.minPendingLatency = value
    }

    /**
     * @param value Minimum number of running instances that should be maintained for this version. Default: 2
     */
    @JvmName("mxwbntfdutchokaa")
    public suspend fun minTotalInstances(`value`: Output) {
        this.minTotalInstances = value
    }

    /**
     * @param value Target scaling by network usage.
     * Structure is documented below.
     */
    @JvmName("bivaypguvlcpbbgj")
    public suspend fun networkUtilization(`value`: Output) {
        this.networkUtilization = value
    }

    /**
     * @param value Target scaling by request utilization.
     * Structure is documented below.
     */
    @JvmName("xwuoqlbwlwhubull")
    public suspend fun requestUtilization(`value`: Output) {
        this.requestUtilization = value
    }

    /**
     * @param value The time period that the Autoscaler should wait before it starts collecting information from a new instance.
     * This prevents the autoscaler from collecting information when the instance is initializing,
     * during which the collected usage would not be reliable. Default: 120s
     */
    @JvmName("mxvqmmmhurgyhmqc")
    public suspend fun coolDownPeriod(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.coolDownPeriod = mapped
    }

    /**
     * @param value Target scaling by CPU usage.
     * Structure is documented below.
     */
    @JvmName("ogwbamemmkkpxuxr")
    public suspend fun cpuUtilization(`value`: FlexibleAppVersionAutomaticScalingCpuUtilizationArgs) {
        val toBeMapped = value
        val mapped = toBeMapped.let({ args0 -> of(args0) })
        this.cpuUtilization = mapped
    }

    /**
     * @param argument Target scaling by CPU usage.
     * Structure is documented below.
     */
    @JvmName("egfkqycyrnrwxjlp")
    public suspend fun cpuUtilization(argument: suspend FlexibleAppVersionAutomaticScalingCpuUtilizationArgsBuilder.() -> Unit) {
        val toBeMapped = FlexibleAppVersionAutomaticScalingCpuUtilizationArgsBuilder().applySuspend {
            argument()
        }.build()
        val mapped = of(toBeMapped)
        this.cpuUtilization = mapped
    }

    /**
     * @param value Target scaling by disk usage.
     * Structure is documented below.
     */
    @JvmName("criiqsifnjilqqrk")
    public suspend fun diskUtilization(`value`: FlexibleAppVersionAutomaticScalingDiskUtilizationArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.diskUtilization = mapped
    }

    /**
     * @param argument Target scaling by disk usage.
     * Structure is documented below.
     */
    @JvmName("oykhtbpalrrvaajq")
    public suspend fun diskUtilization(argument: suspend FlexibleAppVersionAutomaticScalingDiskUtilizationArgsBuilder.() -> Unit) {
        val toBeMapped = FlexibleAppVersionAutomaticScalingDiskUtilizationArgsBuilder().applySuspend {
            argument()
        }.build()
        val mapped = of(toBeMapped)
        this.diskUtilization = mapped
    }

    /**
     * @param value Number of concurrent requests an automatic scaling instance can accept before the scheduler spawns a new instance.
     * Defaults to a runtime-specific value.
     */
    @JvmName("cssurbgfsknlbwck")
    public suspend fun maxConcurrentRequests(`value`: Int?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.maxConcurrentRequests = mapped
    }

    /**
     * @param value Maximum number of idle instances that should be maintained for this version.
     */
    @JvmName("egoedtpsincwmwdg")
    public suspend fun maxIdleInstances(`value`: Int?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.maxIdleInstances = mapped
    }

    /**
     * @param value Maximum amount of time that a request should wait in the pending queue before starting a new instance to handle it.
     */
    @JvmName("bvthmicndjlsnnhx")
    public suspend fun maxPendingLatency(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.maxPendingLatency = mapped
    }

    /**
     * @param value Maximum number of instances that should be started to handle requests for this version. Default: 20
     */
    @JvmName("dcayowbavmnotadp")
    public suspend fun maxTotalInstances(`value`: Int?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.maxTotalInstances = mapped
    }

    /**
     * @param value Minimum number of idle instances that should be maintained for this version. Only applicable for the default version of a service.
     */
    @JvmName("deanvnhlxudehpkr")
    public suspend fun minIdleInstances(`value`: Int?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.minIdleInstances = mapped
    }

    /**
     * @param value Minimum amount of time a request should wait in the pending queue before starting a new instance to handle it.
     */
    @JvmName("jbnfbojlhvibsaqe")
    public suspend fun minPendingLatency(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.minPendingLatency = mapped
    }

    /**
     * @param value Minimum number of running instances that should be maintained for this version. Default: 2
     */
    @JvmName("sanxgbslamrhrsfb")
    public suspend fun minTotalInstances(`value`: Int?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.minTotalInstances = mapped
    }

    /**
     * @param value Target scaling by network usage.
     * Structure is documented below.
     */
    @JvmName("lplnahaqrnldvsmb")
    public suspend fun networkUtilization(`value`: FlexibleAppVersionAutomaticScalingNetworkUtilizationArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.networkUtilization = mapped
    }

    /**
     * @param argument Target scaling by network usage.
     * Structure is documented below.
     */
    @JvmName("krqxqqvchmeecrjd")
    public suspend fun networkUtilization(argument: suspend FlexibleAppVersionAutomaticScalingNetworkUtilizationArgsBuilder.() -> Unit) {
        val toBeMapped = FlexibleAppVersionAutomaticScalingNetworkUtilizationArgsBuilder().applySuspend {
            argument()
        }.build()
        val mapped = of(toBeMapped)
        this.networkUtilization = mapped
    }

    /**
     * @param value Target scaling by request utilization.
     * Structure is documented below.
     */
    @JvmName("uolbxibqhkvtnrbe")
    public suspend fun requestUtilization(`value`: FlexibleAppVersionAutomaticScalingRequestUtilizationArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.requestUtilization = mapped
    }

    /**
     * @param argument Target scaling by request utilization.
     * Structure is documented below.
     */
    @JvmName("bvlmgmwkhhynimsm")
    public suspend fun requestUtilization(argument: suspend FlexibleAppVersionAutomaticScalingRequestUtilizationArgsBuilder.() -> Unit) {
        val toBeMapped = FlexibleAppVersionAutomaticScalingRequestUtilizationArgsBuilder().applySuspend {
            argument()
        }.build()
        val mapped = of(toBeMapped)
        this.requestUtilization = mapped
    }

    internal fun build(): FlexibleAppVersionAutomaticScalingArgs =
        FlexibleAppVersionAutomaticScalingArgs(
            coolDownPeriod = coolDownPeriod,
            cpuUtilization = cpuUtilization ?: throw PulumiNullFieldException("cpuUtilization"),
            diskUtilization = diskUtilization,
            maxConcurrentRequests = maxConcurrentRequests,
            maxIdleInstances = maxIdleInstances,
            maxPendingLatency = maxPendingLatency,
            maxTotalInstances = maxTotalInstances,
            minIdleInstances = minIdleInstances,
            minPendingLatency = minPendingLatency,
            minTotalInstances = minTotalInstances,
            networkUtilization = networkUtilization,
            requestUtilization = requestUtilization,
        )
}