com.pulumi.gcp.compute.kotlin.inputs.URLMapPathMatcherArgs.kt Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of pulumi-gcp-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: 8.10.0.0
Show newest version
@file:Suppress("NAME_SHADOWING", "DEPRECATION")

package com.pulumi.gcp.compute.kotlin.inputs

import com.pulumi.core.Output
import com.pulumi.core.Output.of
import com.pulumi.gcp.compute.inputs.URLMapPathMatcherArgs.builder
import com.pulumi.kotlin.ConvertibleToJava
import com.pulumi.kotlin.PulumiNullFieldException
import com.pulumi.kotlin.PulumiTagMarker
import com.pulumi.kotlin.applySuspend
import kotlin.String
import kotlin.Suppress
import kotlin.Unit
import kotlin.collections.List
import kotlin.jvm.JvmName

/**
 *
 * @property defaultRouteAction defaultRouteAction takes effect when none of the pathRules or routeRules match. The load balancer performs
 * advanced routing actions like URL rewrites, header transformations, etc. prior to forwarding the request
 * to the selected backend. If defaultRouteAction specifies any weightedBackendServices, defaultService must not be set.
 * Conversely if defaultService is set, defaultRouteAction cannot contain any weightedBackendServices.
 * Only one of defaultRouteAction or defaultUrlRedirect must be set.
 * Structure is documented below.
 * @property defaultService The backend service or backend bucket to use when none of the given paths match.
 * @property defaultUrlRedirect When none of the specified hostRules match, the request is redirected to a URL specified
 * by defaultUrlRedirect. If defaultUrlRedirect is specified, defaultService or
 * defaultRouteAction must not be set.
 * Structure is documented below.
 * @property description An optional description of this resource. Provide this property when you create
 * the resource.
 * @property headerAction Specifies changes to request and response headers that need to take effect for
 * the selected backendService. HeaderAction specified here are applied after the
 * matching HttpRouteRule HeaderAction and before the HeaderAction in the UrlMap
 * Structure is documented below.
 * @property name The name to which this PathMatcher is referred by the HostRule.
 * @property pathRules The list of path rules. Use this list instead of routeRules when routing based
 * on simple path matching is all that's required. The order by which path rules
 * are specified does not matter. Matches are always done on the longest-path-first
 * basis. For example: a pathRule with a path /a/b/c/* will match before /a/b/*
 * irrespective of the order in which those paths appear in this list. Within a
 * given pathMatcher, only one of pathRules or routeRules must be set.
 * Structure is documented below.
 * @property routeRules The list of ordered HTTP route rules. Use this list instead of pathRules when
 * advanced route matching and routing actions are desired. The order of specifying
 * routeRules matters: the first rule that matches will cause its specified routing
 * action to take effect. Within a given pathMatcher, only one of pathRules or
 * routeRules must be set. routeRules are not supported in UrlMaps intended for
 * External load balancers.
 * Structure is documented below.
 * */*/
 */
public data class URLMapPathMatcherArgs(
    public val defaultRouteAction: Output? = null,
    public val defaultService: Output? = null,
    public val defaultUrlRedirect: Output? = null,
    public val description: Output? = null,
    public val headerAction: Output? = null,
    public val name: Output,
    public val pathRules: Output>? = null,
    public val routeRules: Output>? = null,
) : ConvertibleToJava {
    override fun toJava(): com.pulumi.gcp.compute.inputs.URLMapPathMatcherArgs =
        com.pulumi.gcp.compute.inputs.URLMapPathMatcherArgs.builder()
            .defaultRouteAction(
                defaultRouteAction?.applyValue({ args0 ->
                    args0.let({ args0 ->
                        args0.toJava()
                    })
                }),
            )
            .defaultService(defaultService?.applyValue({ args0 -> args0 }))
            .defaultUrlRedirect(
                defaultUrlRedirect?.applyValue({ args0 ->
                    args0.let({ args0 ->
                        args0.toJava()
                    })
                }),
            )
            .description(description?.applyValue({ args0 -> args0 }))
            .headerAction(headerAction?.applyValue({ args0 -> args0.let({ args0 -> args0.toJava() }) }))
            .name(name.applyValue({ args0 -> args0 }))
            .pathRules(
                pathRules?.applyValue({ args0 ->
                    args0.map({ args0 ->
                        args0.let({ args0 ->
                            args0.toJava()
                        })
                    })
                }),
            )
            .routeRules(
                routeRules?.applyValue({ args0 ->
                    args0.map({ args0 ->
                        args0.let({ args0 ->
                            args0.toJava()
                        })
                    })
                }),
            ).build()
}

/**
 * Builder for [URLMapPathMatcherArgs].
 */
@PulumiTagMarker
public class URLMapPathMatcherArgsBuilder internal constructor() {
    private var defaultRouteAction: Output? = null

    private var defaultService: Output? = null

    private var defaultUrlRedirect: Output? = null

    private var description: Output? = null

    private var headerAction: Output? = null

    private var name: Output? = null

    private var pathRules: Output>? = null

    private var routeRules: Output>? = null

    /**
     * @param value defaultRouteAction takes effect when none of the pathRules or routeRules match. The load balancer performs
     * advanced routing actions like URL rewrites, header transformations, etc. prior to forwarding the request
     * to the selected backend. If defaultRouteAction specifies any weightedBackendServices, defaultService must not be set.
     * Conversely if defaultService is set, defaultRouteAction cannot contain any weightedBackendServices.
     * Only one of defaultRouteAction or defaultUrlRedirect must be set.
     * Structure is documented below.
     */
    @JvmName("powdbiitidnxvekk")
    public suspend fun defaultRouteAction(`value`: Output) {
        this.defaultRouteAction = value
    }

    /**
     * @param value The backend service or backend bucket to use when none of the given paths match.
     */
    @JvmName("jogrwnayqorqtqyh")
    public suspend fun defaultService(`value`: Output) {
        this.defaultService = value
    }

    /**
     * @param value When none of the specified hostRules match, the request is redirected to a URL specified
     * by defaultUrlRedirect. If defaultUrlRedirect is specified, defaultService or
     * defaultRouteAction must not be set.
     * Structure is documented below.
     */
    @JvmName("nhmpcvbadtqhuiyp")
    public suspend fun defaultUrlRedirect(`value`: Output) {
        this.defaultUrlRedirect = value
    }

    /**
     * @param value An optional description of this resource. Provide this property when you create
     * the resource.
     */
    @JvmName("aglsrgjyqwkxaqkf")
    public suspend fun description(`value`: Output) {
        this.description = value
    }

    /**
     * @param value Specifies changes to request and response headers that need to take effect for
     * the selected backendService. HeaderAction specified here are applied after the
     * matching HttpRouteRule HeaderAction and before the HeaderAction in the UrlMap
     * Structure is documented below.
     */
    @JvmName("oldelpacdlkcsxrn")
    public suspend fun headerAction(`value`: Output) {
        this.headerAction = value
    }

    /**
     * @param value The name to which this PathMatcher is referred by the HostRule.
     */
    @JvmName("rmwthaiejmuotujj")
    public suspend fun name(`value`: Output) {
        this.name = value
    }

    /**
     * @param value The list of path rules. Use this list instead of routeRules when routing based
     * on simple path matching is all that's required. The order by which path rules
     * are specified does not matter. Matches are always done on the longest-path-first
     * basis. For example: a pathRule with a path /a/b/c/* will match before /a/b/*
     * irrespective of the order in which those paths appear in this list. Within a
     * given pathMatcher, only one of pathRules or routeRules must be set.
     * Structure is documented below.
     * */*/
     */
    @JvmName("ibinlbgyfvfkyhtu")
    public suspend fun pathRules(`value`: Output>) {
        this.pathRules = value
    }

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

    /**
     * @param values The list of path rules. Use this list instead of routeRules when routing based
     * on simple path matching is all that's required. The order by which path rules
     * are specified does not matter. Matches are always done on the longest-path-first
     * basis. For example: a pathRule with a path /a/b/c/* will match before /a/b/*
     * irrespective of the order in which those paths appear in this list. Within a
     * given pathMatcher, only one of pathRules or routeRules must be set.
     * Structure is documented below.
     * */*/
     */
    @JvmName("xhbbxbibgoiedctq")
    public suspend fun pathRules(values: List>) {
        this.pathRules = Output.all(values)
    }

    /**
     * @param value The list of ordered HTTP route rules. Use this list instead of pathRules when
     * advanced route matching and routing actions are desired. The order of specifying
     * routeRules matters: the first rule that matches will cause its specified routing
     * action to take effect. Within a given pathMatcher, only one of pathRules or
     * routeRules must be set. routeRules are not supported in UrlMaps intended for
     * External load balancers.
     * Structure is documented below.
     */
    @JvmName("pqnwkwotelvxjkij")
    public suspend fun routeRules(`value`: Output>) {
        this.routeRules = value
    }

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

    /**
     * @param values The list of ordered HTTP route rules. Use this list instead of pathRules when
     * advanced route matching and routing actions are desired. The order of specifying
     * routeRules matters: the first rule that matches will cause its specified routing
     * action to take effect. Within a given pathMatcher, only one of pathRules or
     * routeRules must be set. routeRules are not supported in UrlMaps intended for
     * External load balancers.
     * Structure is documented below.
     */
    @JvmName("tyrhdgswmafhryxx")
    public suspend fun routeRules(values: List>) {
        this.routeRules = Output.all(values)
    }

    /**
     * @param value defaultRouteAction takes effect when none of the pathRules or routeRules match. The load balancer performs
     * advanced routing actions like URL rewrites, header transformations, etc. prior to forwarding the request
     * to the selected backend. If defaultRouteAction specifies any weightedBackendServices, defaultService must not be set.
     * Conversely if defaultService is set, defaultRouteAction cannot contain any weightedBackendServices.
     * Only one of defaultRouteAction or defaultUrlRedirect must be set.
     * Structure is documented below.
     */
    @JvmName("nxwqyinaforsuwbg")
    public suspend fun defaultRouteAction(`value`: URLMapPathMatcherDefaultRouteActionArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.defaultRouteAction = mapped
    }

    /**
     * @param argument defaultRouteAction takes effect when none of the pathRules or routeRules match. The load balancer performs
     * advanced routing actions like URL rewrites, header transformations, etc. prior to forwarding the request
     * to the selected backend. If defaultRouteAction specifies any weightedBackendServices, defaultService must not be set.
     * Conversely if defaultService is set, defaultRouteAction cannot contain any weightedBackendServices.
     * Only one of defaultRouteAction or defaultUrlRedirect must be set.
     * Structure is documented below.
     */
    @JvmName("jaqirnmmftkvaglj")
    public suspend fun defaultRouteAction(argument: suspend URLMapPathMatcherDefaultRouteActionArgsBuilder.() -> Unit) {
        val toBeMapped = URLMapPathMatcherDefaultRouteActionArgsBuilder().applySuspend {
            argument()
        }.build()
        val mapped = of(toBeMapped)
        this.defaultRouteAction = mapped
    }

    /**
     * @param value The backend service or backend bucket to use when none of the given paths match.
     */
    @JvmName("bbxdyirvwjdjvpil")
    public suspend fun defaultService(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.defaultService = mapped
    }

    /**
     * @param value When none of the specified hostRules match, the request is redirected to a URL specified
     * by defaultUrlRedirect. If defaultUrlRedirect is specified, defaultService or
     * defaultRouteAction must not be set.
     * Structure is documented below.
     */
    @JvmName("fcauuyltkgkjijww")
    public suspend fun defaultUrlRedirect(`value`: URLMapPathMatcherDefaultUrlRedirectArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.defaultUrlRedirect = mapped
    }

    /**
     * @param argument When none of the specified hostRules match, the request is redirected to a URL specified
     * by defaultUrlRedirect. If defaultUrlRedirect is specified, defaultService or
     * defaultRouteAction must not be set.
     * Structure is documented below.
     */
    @JvmName("eaocvfxdytxjnctl")
    public suspend fun defaultUrlRedirect(argument: suspend URLMapPathMatcherDefaultUrlRedirectArgsBuilder.() -> Unit) {
        val toBeMapped = URLMapPathMatcherDefaultUrlRedirectArgsBuilder().applySuspend {
            argument()
        }.build()
        val mapped = of(toBeMapped)
        this.defaultUrlRedirect = mapped
    }

    /**
     * @param value An optional description of this resource. Provide this property when you create
     * the resource.
     */
    @JvmName("ykfoixtlkseiiwbw")
    public suspend fun description(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.description = mapped
    }

    /**
     * @param value Specifies changes to request and response headers that need to take effect for
     * the selected backendService. HeaderAction specified here are applied after the
     * matching HttpRouteRule HeaderAction and before the HeaderAction in the UrlMap
     * Structure is documented below.
     */
    @JvmName("ncwhmjcfxstregeh")
    public suspend fun headerAction(`value`: URLMapPathMatcherHeaderActionArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.headerAction = mapped
    }

    /**
     * @param argument Specifies changes to request and response headers that need to take effect for
     * the selected backendService. HeaderAction specified here are applied after the
     * matching HttpRouteRule HeaderAction and before the HeaderAction in the UrlMap
     * Structure is documented below.
     */
    @JvmName("djxkiwkqvpqpdqub")
    public suspend fun headerAction(argument: suspend URLMapPathMatcherHeaderActionArgsBuilder.() -> Unit) {
        val toBeMapped = URLMapPathMatcherHeaderActionArgsBuilder().applySuspend { argument() }.build()
        val mapped = of(toBeMapped)
        this.headerAction = mapped
    }

    /**
     * @param value The name to which this PathMatcher is referred by the HostRule.
     */
    @JvmName("dfvawbdbdeamlhnr")
    public suspend fun name(`value`: String) {
        val toBeMapped = value
        val mapped = toBeMapped.let({ args0 -> of(args0) })
        this.name = mapped
    }

    /**
     * @param value The list of path rules. Use this list instead of routeRules when routing based
     * on simple path matching is all that's required. The order by which path rules
     * are specified does not matter. Matches are always done on the longest-path-first
     * basis. For example: a pathRule with a path /a/b/c/* will match before /a/b/*
     * irrespective of the order in which those paths appear in this list. Within a
     * given pathMatcher, only one of pathRules or routeRules must be set.
     * Structure is documented below.
     * */*/
     */
    @JvmName("jjpkcesitrqdrkhw")
    public suspend fun pathRules(`value`: List?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.pathRules = mapped
    }

    /**
     * @param argument The list of path rules. Use this list instead of routeRules when routing based
     * on simple path matching is all that's required. The order by which path rules
     * are specified does not matter. Matches are always done on the longest-path-first
     * basis. For example: a pathRule with a path /a/b/c/* will match before /a/b/*
     * irrespective of the order in which those paths appear in this list. Within a
     * given pathMatcher, only one of pathRules or routeRules must be set.
     * Structure is documented below.
     * */*/
     */
    @JvmName("dearvfjwpltuginu")
    public suspend fun pathRules(argument: List Unit>) {
        val toBeMapped = argument.toList().map {
            URLMapPathMatcherPathRuleArgsBuilder().applySuspend {
                it()
            }.build()
        }
        val mapped = of(toBeMapped)
        this.pathRules = mapped
    }

    /**
     * @param argument The list of path rules. Use this list instead of routeRules when routing based
     * on simple path matching is all that's required. The order by which path rules
     * are specified does not matter. Matches are always done on the longest-path-first
     * basis. For example: a pathRule with a path /a/b/c/* will match before /a/b/*
     * irrespective of the order in which those paths appear in this list. Within a
     * given pathMatcher, only one of pathRules or routeRules must be set.
     * Structure is documented below.
     * */*/
     */
    @JvmName("jbqbvxtknowdwbid")
    public suspend fun pathRules(vararg argument: suspend URLMapPathMatcherPathRuleArgsBuilder.() -> Unit) {
        val toBeMapped = argument.toList().map {
            URLMapPathMatcherPathRuleArgsBuilder().applySuspend {
                it()
            }.build()
        }
        val mapped = of(toBeMapped)
        this.pathRules = mapped
    }

    /**
     * @param argument The list of path rules. Use this list instead of routeRules when routing based
     * on simple path matching is all that's required. The order by which path rules
     * are specified does not matter. Matches are always done on the longest-path-first
     * basis. For example: a pathRule with a path /a/b/c/* will match before /a/b/*
     * irrespective of the order in which those paths appear in this list. Within a
     * given pathMatcher, only one of pathRules or routeRules must be set.
     * Structure is documented below.
     * */*/
     */
    @JvmName("itncovlnvomocebs")
    public suspend fun pathRules(argument: suspend URLMapPathMatcherPathRuleArgsBuilder.() -> Unit) {
        val toBeMapped = listOf(
            URLMapPathMatcherPathRuleArgsBuilder().applySuspend {
                argument()
            }.build(),
        )
        val mapped = of(toBeMapped)
        this.pathRules = mapped
    }

    /**
     * @param values The list of path rules. Use this list instead of routeRules when routing based
     * on simple path matching is all that's required. The order by which path rules
     * are specified does not matter. Matches are always done on the longest-path-first
     * basis. For example: a pathRule with a path /a/b/c/* will match before /a/b/*
     * irrespective of the order in which those paths appear in this list. Within a
     * given pathMatcher, only one of pathRules or routeRules must be set.
     * Structure is documented below.
     * */*/
     */
    @JvmName("lrtihfvbmyobgaug")
    public suspend fun pathRules(vararg values: URLMapPathMatcherPathRuleArgs) {
        val toBeMapped = values.toList()
        val mapped = toBeMapped.let({ args0 -> of(args0) })
        this.pathRules = mapped
    }

    /**
     * @param value The list of ordered HTTP route rules. Use this list instead of pathRules when
     * advanced route matching and routing actions are desired. The order of specifying
     * routeRules matters: the first rule that matches will cause its specified routing
     * action to take effect. Within a given pathMatcher, only one of pathRules or
     * routeRules must be set. routeRules are not supported in UrlMaps intended for
     * External load balancers.
     * Structure is documented below.
     */
    @JvmName("hpbwqffbesflnwni")
    public suspend fun routeRules(`value`: List?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.routeRules = mapped
    }

    /**
     * @param argument The list of ordered HTTP route rules. Use this list instead of pathRules when
     * advanced route matching and routing actions are desired. The order of specifying
     * routeRules matters: the first rule that matches will cause its specified routing
     * action to take effect. Within a given pathMatcher, only one of pathRules or
     * routeRules must be set. routeRules are not supported in UrlMaps intended for
     * External load balancers.
     * Structure is documented below.
     */
    @JvmName("ppltekqcmtbblqnn")
    public suspend fun routeRules(argument: List Unit>) {
        val toBeMapped = argument.toList().map {
            URLMapPathMatcherRouteRuleArgsBuilder().applySuspend {
                it()
            }.build()
        }
        val mapped = of(toBeMapped)
        this.routeRules = mapped
    }

    /**
     * @param argument The list of ordered HTTP route rules. Use this list instead of pathRules when
     * advanced route matching and routing actions are desired. The order of specifying
     * routeRules matters: the first rule that matches will cause its specified routing
     * action to take effect. Within a given pathMatcher, only one of pathRules or
     * routeRules must be set. routeRules are not supported in UrlMaps intended for
     * External load balancers.
     * Structure is documented below.
     */
    @JvmName("uipkhrbaxppnebua")
    public suspend fun routeRules(vararg argument: suspend URLMapPathMatcherRouteRuleArgsBuilder.() -> Unit) {
        val toBeMapped = argument.toList().map {
            URLMapPathMatcherRouteRuleArgsBuilder().applySuspend {
                it()
            }.build()
        }
        val mapped = of(toBeMapped)
        this.routeRules = mapped
    }

    /**
     * @param argument The list of ordered HTTP route rules. Use this list instead of pathRules when
     * advanced route matching and routing actions are desired. The order of specifying
     * routeRules matters: the first rule that matches will cause its specified routing
     * action to take effect. Within a given pathMatcher, only one of pathRules or
     * routeRules must be set. routeRules are not supported in UrlMaps intended for
     * External load balancers.
     * Structure is documented below.
     */
    @JvmName("pivjhkadklgxgcve")
    public suspend fun routeRules(argument: suspend URLMapPathMatcherRouteRuleArgsBuilder.() -> Unit) {
        val toBeMapped = listOf(
            URLMapPathMatcherRouteRuleArgsBuilder().applySuspend {
                argument()
            }.build(),
        )
        val mapped = of(toBeMapped)
        this.routeRules = mapped
    }

    /**
     * @param values The list of ordered HTTP route rules. Use this list instead of pathRules when
     * advanced route matching and routing actions are desired. The order of specifying
     * routeRules matters: the first rule that matches will cause its specified routing
     * action to take effect. Within a given pathMatcher, only one of pathRules or
     * routeRules must be set. routeRules are not supported in UrlMaps intended for
     * External load balancers.
     * Structure is documented below.
     */
    @JvmName("uwahcjjuebtvptpj")
    public suspend fun routeRules(vararg values: URLMapPathMatcherRouteRuleArgs) {
        val toBeMapped = values.toList()
        val mapped = toBeMapped.let({ args0 -> of(args0) })
        this.routeRules = mapped
    }

    internal fun build(): URLMapPathMatcherArgs = URLMapPathMatcherArgs(
        defaultRouteAction = defaultRouteAction,
        defaultService = defaultService,
        defaultUrlRedirect = defaultUrlRedirect,
        description = description,
        headerAction = headerAction,
        name = name ?: throw PulumiNullFieldException("name"),
        pathRules = pathRules,
        routeRules = routeRules,
    )
}