com.pulumi.gcp.networkconnectivity.kotlin.Hub.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.networkconnectivity.kotlin

import com.pulumi.core.Output
import com.pulumi.gcp.networkconnectivity.kotlin.outputs.HubRoutingVpc
import com.pulumi.gcp.networkconnectivity.kotlin.outputs.HubRoutingVpc.Companion.toKotlin
import com.pulumi.kotlin.KotlinCustomResource
import com.pulumi.kotlin.PulumiTagMarker
import com.pulumi.kotlin.ResourceMapper
import com.pulumi.kotlin.options.CustomResourceOptions
import com.pulumi.kotlin.options.CustomResourceOptionsBuilder
import com.pulumi.resources.Resource
import kotlin.Any
import kotlin.Boolean
import kotlin.String
import kotlin.Suppress
import kotlin.Unit
import kotlin.collections.List
import kotlin.collections.Map

/**
 * Builder for [Hub].
 */
@PulumiTagMarker
public class HubResourceBuilder internal constructor() {
    public var name: String? = null

    public var args: HubArgs = HubArgs()

    public var opts: CustomResourceOptions = CustomResourceOptions()

    /**
     * @param name The _unique_ name of the resulting resource.
     */
    public fun name(`value`: String) {
        this.name = value
    }

    /**
     * @param block The arguments to use to populate this resource's properties.
     */
    public suspend fun args(block: suspend HubArgsBuilder.() -> Unit) {
        val builder = HubArgsBuilder()
        block(builder)
        this.args = builder.build()
    }

    /**
     * @param block A bag of options that control this resource's behavior.
     */
    public suspend fun opts(block: suspend CustomResourceOptionsBuilder.() -> Unit) {
        this.opts = com.pulumi.kotlin.options.CustomResourceOptions.opts(block)
    }

    internal fun build(): Hub {
        val builtJavaResource = com.pulumi.gcp.networkconnectivity.Hub(
            this.name,
            this.args.toJava(),
            this.opts.toJava(),
        )
        return Hub(builtJavaResource)
    }
}

/**
 * The NetworkConnectivity Hub resource
 * ## Example Usage
 * ### Basic_hub
 * A basic test of a networkconnectivity hub
 * 
 * ```typescript
 * import * as pulumi from "@pulumi/pulumi";
 * import * as gcp from "@pulumi/gcp";
 * const primary = new gcp.networkconnectivity.Hub("primary", {
 *     name: "hub",
 *     description: "A sample hub",
 *     project: "my-project-name",
 *     labels: {
 *         "label-one": "value-one",
 *     },
 * });
 * ```
 * ```python
 * import pulumi
 * import pulumi_gcp as gcp
 * primary = gcp.networkconnectivity.Hub("primary",
 *     name="hub",
 *     description="A sample hub",
 *     project="my-project-name",
 *     labels={
 *         "label-one": "value-one",
 *     })
 * ```
 * ```csharp
 * using System.Collections.Generic;
 * using System.Linq;
 * using Pulumi;
 * using Gcp = Pulumi.Gcp;
 * return await Deployment.RunAsync(() =>
 * {
 *     var primary = new Gcp.NetworkConnectivity.Hub("primary", new()
 *     {
 *         Name = "hub",
 *         Description = "A sample hub",
 *         Project = "my-project-name",
 *         Labels =
 *         {
 *             { "label-one", "value-one" },
 *         },
 *     });
 * });
 * ```
 * ```go
 * package main
 * import (
 * 	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/networkconnectivity"
 * 	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
 * )
 * func main() {
 * 	pulumi.Run(func(ctx *pulumi.Context) error {
 * 		_, err := networkconnectivity.NewHub(ctx, "primary", &networkconnectivity.HubArgs{
 * 			Name:        pulumi.String("hub"),
 * 			Description: pulumi.String("A sample hub"),
 * 			Project:     pulumi.String("my-project-name"),
 * 			Labels: pulumi.StringMap{
 * 				"label-one": pulumi.String("value-one"),
 * 			},
 * 		})
 * 		if err != nil {
 * 			return err
 * 		}
 * 		return nil
 * 	})
 * }
 * ```
 * ```java
 * package generated_program;
 * import com.pulumi.Context;
 * import com.pulumi.Pulumi;
 * import com.pulumi.core.Output;
 * import com.pulumi.gcp.networkconnectivity.Hub;
 * import com.pulumi.gcp.networkconnectivity.HubArgs;
 * import java.util.List;
 * import java.util.ArrayList;
 * import java.util.Map;
 * import java.io.File;
 * import java.nio.file.Files;
 * import java.nio.file.Paths;
 * public class App {
 *     public static void main(String[] args) {
 *         Pulumi.run(App::stack);
 *     }
 *     public static void stack(Context ctx) {
 *         var primary = new Hub("primary", HubArgs.builder()
 *             .name("hub")
 *             .description("A sample hub")
 *             .project("my-project-name")
 *             .labels(Map.of("label-one", "value-one"))
 *             .build());
 *     }
 * }
 * ```
 * ```yaml
 * resources:
 *   primary:
 *     type: gcp:networkconnectivity:Hub
 *     properties:
 *       name: hub
 *       description: A sample hub
 *       project: my-project-name
 *       labels:
 *         label-one: value-one
 * ```
 * 
 * ## Import
 * Hub can be imported using any of these accepted formats:
 * * `projects/{{project}}/locations/global/hubs/{{name}}`
 * * `{{project}}/{{name}}`
 * * `{{name}}`
 * When using the `pulumi import` command, Hub can be imported using one of the formats above. For example:
 * ```sh
 * $ pulumi import gcp:networkconnectivity/hub:Hub default projects/{{project}}/locations/global/hubs/{{name}}
 * ```
 * ```sh
 * $ pulumi import gcp:networkconnectivity/hub:Hub default {{project}}/{{name}}
 * ```
 * ```sh
 * $ pulumi import gcp:networkconnectivity/hub:Hub default {{name}}
 * ```
 */
public class Hub internal constructor(
    override val javaResource: com.pulumi.gcp.networkconnectivity.Hub,
) : KotlinCustomResource(javaResource, HubMapper) {
    /**
     * Output only. The time the hub was created.
     */
    public val createTime: Output
        get() = javaResource.createTime().applyValue({ args0 -> args0 })

    /**
     * An optional description of the hub.
     */
    public val description: Output?
        get() = javaResource.description().applyValue({ args0 ->
            args0.map({ args0 ->
                args0
            }).orElse(null)
        })

    /**
     * All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.
     */
    public val effectiveLabels: Output>
        get() = javaResource.effectiveLabels().applyValue({ args0 ->
            args0.map({ args0 ->
                args0.key.to(args0.value)
            }).toMap()
        })

    /**
     * Optional labels in key:value format. For more information about labels, see [Requirements for labels](https://cloud.google.com/resource-manager/docs/creating-managing-labels#requirements).
     * **Note**: This field is non-authoritative, and will only manage the labels present in your configuration.
     * Please refer to the field `effective_labels` for all of the labels present on the resource.
     */
    public val labels: Output>?
        get() = javaResource.labels().applyValue({ args0 ->
            args0.map({ args0 ->
                args0.map({ args0 ->
                    args0.key.to(args0.value)
                }).toMap()
            }).orElse(null)
        })

    /**
     * Immutable. The name of the hub. Hub names must be unique. They use the following form: `projects/{project_number}/locations/global/hubs/{hub_id}`
     * - - -
     */
    public val name: Output
        get() = javaResource.name().applyValue({ args0 -> args0 })

    /**
     * The project for the resource
     */
    public val project: Output
        get() = javaResource.project().applyValue({ args0 -> args0 })

    /**
     * The combination of labels configured directly on the resource and default labels configured on the provider.
     */
    public val pulumiLabels: Output>
        get() = javaResource.pulumiLabels().applyValue({ args0 ->
            args0.map({ args0 ->
                args0.key.to(args0.value)
            }).toMap()
        })

    /**
     * The VPC network associated with this hub's spokes. All of the VPN tunnels, VLAN attachments, and router appliance instances referenced by this hub's spokes must belong to this VPC network. This field is read-only. Network Connectivity Center automatically populates it based on the set of spokes attached to the hub.
     */
    public val routingVpcs: Output>
        get() = javaResource.routingVpcs().applyValue({ args0 ->
            args0.map({ args0 ->
                args0.let({ args0 ->
                    toKotlin(args0)
                })
            })
        })

    /**
     * Output only. The current lifecycle state of this hub. Possible values: STATE_UNSPECIFIED, CREATING, ACTIVE, DELETING
     */
    public val state: Output
        get() = javaResource.state().applyValue({ args0 -> args0 })

    /**
     * Output only. The Google-generated UUID for the hub. This value is unique across all hub resources. If a hub is deleted and another with the same name is created, the new hub is assigned a different unique_id.
     */
    public val uniqueId: Output
        get() = javaResource.uniqueId().applyValue({ args0 -> args0 })

    /**
     * Output only. The time the hub was last updated.
     */
    public val updateTime: Output
        get() = javaResource.updateTime().applyValue({ args0 -> args0 })
}

public object HubMapper : ResourceMapper {
    override fun supportsMappingOfType(javaResource: Resource): Boolean =
        com.pulumi.gcp.networkconnectivity.Hub::class == javaResource::class

    override fun map(javaResource: Resource): Hub = Hub(
        javaResource as
            com.pulumi.gcp.networkconnectivity.Hub,
    )
}

/**
 * @see [Hub].
 * @param name The _unique_ name of the resulting resource.
 * @param block Builder for [Hub].
 */
public suspend fun hub(name: String, block: suspend HubResourceBuilder.() -> Unit): Hub {
    val builder = HubResourceBuilder()
    builder.name(name)
    block(builder)
    return builder.build()
}

/**
 * @see [Hub].
 * @param name The _unique_ name of the resulting resource.
 */
public fun hub(name: String): Hub {
    val builder = HubResourceBuilder()
    builder.name(name)
    return builder.build()
}