alicloud.cen.getTransitRouterRouteTablePropagations

import * as pulumi from "@pulumi/pulumi";
import * as alicloud from "@pulumi/alicloud";
import * as random from "@pulumi/random";

const config = new pulumi.Config();
const name = config.get("name") || "terraform-example";
const _default = alicloud.expressconnect.getPhysicalConnections({
    nameRegex: "^preserved-NODELETING",
});
const defaultInteger = new random.index.Integer("default", {
    min: 1,
    max: 2999,
});
const defaultInstance = new alicloud.cen.Instance("default", {
    cenInstanceName: name,
    protectionLevel: "REDUCED",
});
const defaultTransitRouter = new alicloud.cen.TransitRouter("default", {cenId: defaultInstance.id});
const defaultVirtualBorderRouter = new alicloud.expressconnect.VirtualBorderRouter("default", {
    localGatewayIp: "10.0.0.1",
    peerGatewayIp: "10.0.0.2",
    peeringSubnetMask: "255.255.255.252",
    physicalConnectionId: _default.then(_default => _default.connections?.[0]?.id),
    virtualBorderRouterName: name,
    vlanId: defaultInteger.id,
    minRxInterval: 1000,
    minTxInterval: 1000,
    detectMultiplier: 10,
});
const defaultTransitRouterVbrAttachment = new alicloud.cen.TransitRouterVbrAttachment("default", {
    cenId: defaultInstance.id,
    transitRouterId: defaultTransitRouter.transitRouterId,
    vbrId: defaultVirtualBorderRouter.id,
    autoPublishRouteEnabled: true,
    transitRouterAttachmentName: name,
    transitRouterAttachmentDescription: name,
});
const defaultTransitRouterRouteTable = new alicloud.cen.TransitRouterRouteTable("default", {
    transitRouterId: defaultTransitRouter.transitRouterId,
    transitRouterRouteTableName: name,
});
const defaultTransitRouterRouteTablePropagation = new alicloud.cen.TransitRouterRouteTablePropagation("default", {
    transitRouterAttachmentId: defaultTransitRouterVbrAttachment.transitRouterAttachmentId,
    transitRouterRouteTableId: defaultTransitRouterRouteTable.transitRouterRouteTableId,
});
const ids = alicloud.cen.getTransitRouterRouteTablePropagationsOutput({
    transitRouterRouteTableId: defaultTransitRouterRouteTablePropagation.transitRouterRouteTableId,
    ids: [defaultTransitRouterRouteTablePropagation.transitRouterAttachmentId],
});
export const cenTransitRouterRouteTablePropagationId0 = ids.apply(ids => ids.propagations?.[0]?.id);

import pulumi
import pulumi_alicloud as alicloud
import pulumi_random as random

config = pulumi.Config()
name = config.get("name")
if name is None:
    name = "terraform-example"
default = alicloud.expressconnect.get_physical_connections(name_regex="^preserved-NODELETING")
default_integer = random.index.Integer("default",
    min=1,
    max=2999)
default_instance = alicloud.cen.Instance("default",
    cen_instance_name=name,
    protection_level="REDUCED")
default_transit_router = alicloud.cen.TransitRouter("default", cen_id=default_instance.id)
default_virtual_border_router = alicloud.expressconnect.VirtualBorderRouter("default",
    local_gateway_ip="10.0.0.1",
    peer_gateway_ip="10.0.0.2",
    peering_subnet_mask="255.255.255.252",
    physical_connection_id=default.connections[0].id,
    virtual_border_router_name=name,
    vlan_id=default_integer["id"],
    min_rx_interval=1000,
    min_tx_interval=1000,
    detect_multiplier=10)
default_transit_router_vbr_attachment = alicloud.cen.TransitRouterVbrAttachment("default",
    cen_id=default_instance.id,
    transit_router_id=default_transit_router.transit_router_id,
    vbr_id=default_virtual_border_router.id,
    auto_publish_route_enabled=True,
    transit_router_attachment_name=name,
    transit_router_attachment_description=name)
default_transit_router_route_table = alicloud.cen.TransitRouterRouteTable("default",
    transit_router_id=default_transit_router.transit_router_id,
    transit_router_route_table_name=name)
default_transit_router_route_table_propagation = alicloud.cen.TransitRouterRouteTablePropagation("default",
    transit_router_attachment_id=default_transit_router_vbr_attachment.transit_router_attachment_id,
    transit_router_route_table_id=default_transit_router_route_table.transit_router_route_table_id)
ids = alicloud.cen.get_transit_router_route_table_propagations_output(transit_router_route_table_id=default_transit_router_route_table_propagation.transit_router_route_table_id,
    ids=[default_transit_router_route_table_propagation.transit_router_attachment_id])
pulumi.export("cenTransitRouterRouteTablePropagationId0", ids.propagations[0].id)

package main

import (
	"github.com/pulumi/pulumi-alicloud/sdk/v3/go/alicloud/cen"
	"github.com/pulumi/pulumi-alicloud/sdk/v3/go/alicloud/expressconnect"
	"github.com/pulumi/pulumi-random/sdk/v4/go/random"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi/config"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		cfg := config.New(ctx, "")
		name := "terraform-example"
		if param := cfg.Get("name"); param != "" {
			name = param
		}
		_default, err := expressconnect.GetPhysicalConnections(ctx, &expressconnect.GetPhysicalConnectionsArgs{
			NameRegex: pulumi.StringRef("^preserved-NODELETING"),
		}, nil)
		if err != nil {
			return err
		}
		defaultInteger, err := random.NewInteger(ctx, "default", &random.IntegerArgs{
			Min: 1,
			Max: 2999,
		})
		if err != nil {
			return err
		}
		defaultInstance, err := cen.NewInstance(ctx, "default", &cen.InstanceArgs{
			CenInstanceName: pulumi.String(name),
			ProtectionLevel: pulumi.String("REDUCED"),
		})
		if err != nil {
			return err
		}
		defaultTransitRouter, err := cen.NewTransitRouter(ctx, "default", &cen.TransitRouterArgs{
			CenId: defaultInstance.ID(),
		})
		if err != nil {
			return err
		}
		defaultVirtualBorderRouter, err := expressconnect.NewVirtualBorderRouter(ctx, "default", &expressconnect.VirtualBorderRouterArgs{
			LocalGatewayIp:          pulumi.String("10.0.0.1"),
			PeerGatewayIp:           pulumi.String("10.0.0.2"),
			PeeringSubnetMask:       pulumi.String("255.255.255.252"),
			PhysicalConnectionId:    pulumi.String(_default.Connections[0].Id),
			VirtualBorderRouterName: pulumi.String(name),
			VlanId:                  defaultInteger.Id,
			MinRxInterval:           pulumi.Int(1000),
			MinTxInterval:           pulumi.Int(1000),
			DetectMultiplier:        pulumi.Int(10),
		})
		if err != nil {
			return err
		}
		defaultTransitRouterVbrAttachment, err := cen.NewTransitRouterVbrAttachment(ctx, "default", &cen.TransitRouterVbrAttachmentArgs{
			CenId:                              defaultInstance.ID(),
			TransitRouterId:                    defaultTransitRouter.TransitRouterId,
			VbrId:                              defaultVirtualBorderRouter.ID(),
			AutoPublishRouteEnabled:            pulumi.Bool(true),
			TransitRouterAttachmentName:        pulumi.String(name),
			TransitRouterAttachmentDescription: pulumi.String(name),
		})
		if err != nil {
			return err
		}
		defaultTransitRouterRouteTable, err := cen.NewTransitRouterRouteTable(ctx, "default", &cen.TransitRouterRouteTableArgs{
			TransitRouterId:             defaultTransitRouter.TransitRouterId,
			TransitRouterRouteTableName: pulumi.String(name),
		})
		if err != nil {
			return err
		}
		defaultTransitRouterRouteTablePropagation, err := cen.NewTransitRouterRouteTablePropagation(ctx, "default", &cen.TransitRouterRouteTablePropagationArgs{
			TransitRouterAttachmentId: defaultTransitRouterVbrAttachment.TransitRouterAttachmentId,
			TransitRouterRouteTableId: defaultTransitRouterRouteTable.TransitRouterRouteTableId,
		})
		if err != nil {
			return err
		}
		ids := cen.GetTransitRouterRouteTablePropagationsOutput(ctx, cen.GetTransitRouterRouteTablePropagationsOutputArgs{
			TransitRouterRouteTableId: defaultTransitRouterRouteTablePropagation.TransitRouterRouteTableId,
			Ids: pulumi.StringArray{
				defaultTransitRouterRouteTablePropagation.TransitRouterAttachmentId,
			},
		}, nil)
		ctx.Export("cenTransitRouterRouteTablePropagationId0", ids.ApplyT(func(ids cen.GetTransitRouterRouteTablePropagationsResult) (*string, error) {
			return &ids.Propagations[0].Id, nil
		}).(pulumi.StringPtrOutput))
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AliCloud = Pulumi.AliCloud;
using Random = Pulumi.Random;

return await Deployment.RunAsync(() => 
{
    var config = new Config();
    var name = config.Get("name") ?? "terraform-example";
    var @default = AliCloud.ExpressConnect.GetPhysicalConnections.Invoke(new()
    {
        NameRegex = "^preserved-NODELETING",
    });

    var defaultInteger = new Random.Index.Integer("default", new()
    {
        Min = 1,
        Max = 2999,
    });

    var defaultInstance = new AliCloud.Cen.Instance("default", new()
    {
        CenInstanceName = name,
        ProtectionLevel = "REDUCED",
    });

    var defaultTransitRouter = new AliCloud.Cen.TransitRouter("default", new()
    {
        CenId = defaultInstance.Id,
    });

    var defaultVirtualBorderRouter = new AliCloud.ExpressConnect.VirtualBorderRouter("default", new()
    {
        LocalGatewayIp = "10.0.0.1",
        PeerGatewayIp = "10.0.0.2",
        PeeringSubnetMask = "255.255.255.252",
        PhysicalConnectionId = @default.Apply(@default => @default.Apply(getPhysicalConnectionsResult => getPhysicalConnectionsResult.Connections[0]?.Id)),
        VirtualBorderRouterName = name,
        VlanId = defaultInteger.Id,
        MinRxInterval = 1000,
        MinTxInterval = 1000,
        DetectMultiplier = 10,
    });

    var defaultTransitRouterVbrAttachment = new AliCloud.Cen.TransitRouterVbrAttachment("default", new()
    {
        CenId = defaultInstance.Id,
        TransitRouterId = defaultTransitRouter.TransitRouterId,
        VbrId = defaultVirtualBorderRouter.Id,
        AutoPublishRouteEnabled = true,
        TransitRouterAttachmentName = name,
        TransitRouterAttachmentDescription = name,
    });

    var defaultTransitRouterRouteTable = new AliCloud.Cen.TransitRouterRouteTable("default", new()
    {
        TransitRouterId = defaultTransitRouter.TransitRouterId,
        TransitRouterRouteTableName = name,
    });

    var defaultTransitRouterRouteTablePropagation = new AliCloud.Cen.TransitRouterRouteTablePropagation("default", new()
    {
        TransitRouterAttachmentId = defaultTransitRouterVbrAttachment.TransitRouterAttachmentId,
        TransitRouterRouteTableId = defaultTransitRouterRouteTable.TransitRouterRouteTableId,
    });

    var ids = AliCloud.Cen.GetTransitRouterRouteTablePropagations.Invoke(new()
    {
        TransitRouterRouteTableId = defaultTransitRouterRouteTablePropagation.TransitRouterRouteTableId,
        Ids = new[]
        {
            defaultTransitRouterRouteTablePropagation.TransitRouterAttachmentId,
        },
    });

    return new Dictionary<string, object?>
    {
        ["cenTransitRouterRouteTablePropagationId0"] = ids.Apply(getTransitRouterRouteTablePropagationsResult => getTransitRouterRouteTablePropagationsResult.Propagations[0]?.Id),
    };
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.alicloud.expressconnect.ExpressconnectFunctions;
import com.pulumi.alicloud.expressconnect.inputs.GetPhysicalConnectionsArgs;
import com.pulumi.random.integer;
import com.pulumi.random.integerArgs;
import com.pulumi.alicloud.cen.Instance;
import com.pulumi.alicloud.cen.InstanceArgs;
import com.pulumi.alicloud.cen.TransitRouter;
import com.pulumi.alicloud.cen.TransitRouterArgs;
import com.pulumi.alicloud.expressconnect.VirtualBorderRouter;
import com.pulumi.alicloud.expressconnect.VirtualBorderRouterArgs;
import com.pulumi.alicloud.cen.TransitRouterVbrAttachment;
import com.pulumi.alicloud.cen.TransitRouterVbrAttachmentArgs;
import com.pulumi.alicloud.cen.TransitRouterRouteTable;
import com.pulumi.alicloud.cen.TransitRouterRouteTableArgs;
import com.pulumi.alicloud.cen.TransitRouterRouteTablePropagation;
import com.pulumi.alicloud.cen.TransitRouterRouteTablePropagationArgs;
import com.pulumi.alicloud.cen.CenFunctions;
import com.pulumi.alicloud.cen.inputs.GetTransitRouterRouteTablePropagationsArgs;
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) {
        final var config = ctx.config();
        final var name = config.get("name").orElse("terraform-example");
        final var default = ExpressconnectFunctions.getPhysicalConnections(GetPhysicalConnectionsArgs.builder()
            .nameRegex("^preserved-NODELETING")
            .build());

        var defaultInteger = new Integer("defaultInteger", IntegerArgs.builder()
            .min(1)
            .max(2999)
            .build());

        var defaultInstance = new Instance("defaultInstance", InstanceArgs.builder()
            .cenInstanceName(name)
            .protectionLevel("REDUCED")
            .build());

        var defaultTransitRouter = new TransitRouter("defaultTransitRouter", TransitRouterArgs.builder()
            .cenId(defaultInstance.id())
            .build());

        var defaultVirtualBorderRouter = new VirtualBorderRouter("defaultVirtualBorderRouter", VirtualBorderRouterArgs.builder()
            .localGatewayIp("10.0.0.1")
            .peerGatewayIp("10.0.0.2")
            .peeringSubnetMask("255.255.255.252")
            .physicalConnectionId(default_.connections()[0].id())
            .virtualBorderRouterName(name)
            .vlanId(defaultInteger.id())
            .minRxInterval(1000)
            .minTxInterval(1000)
            .detectMultiplier(10)
            .build());

        var defaultTransitRouterVbrAttachment = new TransitRouterVbrAttachment("defaultTransitRouterVbrAttachment", TransitRouterVbrAttachmentArgs.builder()
            .cenId(defaultInstance.id())
            .transitRouterId(defaultTransitRouter.transitRouterId())
            .vbrId(defaultVirtualBorderRouter.id())
            .autoPublishRouteEnabled(true)
            .transitRouterAttachmentName(name)
            .transitRouterAttachmentDescription(name)
            .build());

        var defaultTransitRouterRouteTable = new TransitRouterRouteTable("defaultTransitRouterRouteTable", TransitRouterRouteTableArgs.builder()
            .transitRouterId(defaultTransitRouter.transitRouterId())
            .transitRouterRouteTableName(name)
            .build());

        var defaultTransitRouterRouteTablePropagation = new TransitRouterRouteTablePropagation("defaultTransitRouterRouteTablePropagation", TransitRouterRouteTablePropagationArgs.builder()
            .transitRouterAttachmentId(defaultTransitRouterVbrAttachment.transitRouterAttachmentId())
            .transitRouterRouteTableId(defaultTransitRouterRouteTable.transitRouterRouteTableId())
            .build());

        final var ids = CenFunctions.getTransitRouterRouteTablePropagations(GetTransitRouterRouteTablePropagationsArgs.builder()
            .transitRouterRouteTableId(defaultTransitRouterRouteTablePropagation.transitRouterRouteTableId())
            .ids(defaultTransitRouterRouteTablePropagation.transitRouterAttachmentId())
            .build());

        ctx.export("cenTransitRouterRouteTablePropagationId0", ids.applyValue(_ids -> _ids.propagations()[0].id()));
    }
}

configuration:
  name:
    type: string
    default: terraform-example
resources:
  defaultInteger:
    type: random:integer
    name: default
    properties:
      min: 1
      max: 2999
  defaultInstance:
    type: alicloud:cen:Instance
    name: default
    properties:
      cenInstanceName: ${name}
      protectionLevel: REDUCED
  defaultTransitRouter:
    type: alicloud:cen:TransitRouter
    name: default
    properties:
      cenId: ${defaultInstance.id}
  defaultVirtualBorderRouter:
    type: alicloud:expressconnect:VirtualBorderRouter
    name: default
    properties:
      localGatewayIp: 10.0.0.1
      peerGatewayIp: 10.0.0.2
      peeringSubnetMask: 255.255.255.252
      physicalConnectionId: ${default.connections[0].id}
      virtualBorderRouterName: ${name}
      vlanId: ${defaultInteger.id}
      minRxInterval: 1000
      minTxInterval: 1000
      detectMultiplier: 10
  defaultTransitRouterVbrAttachment:
    type: alicloud:cen:TransitRouterVbrAttachment
    name: default
    properties:
      cenId: ${defaultInstance.id}
      transitRouterId: ${defaultTransitRouter.transitRouterId}
      vbrId: ${defaultVirtualBorderRouter.id}
      autoPublishRouteEnabled: true
      transitRouterAttachmentName: ${name}
      transitRouterAttachmentDescription: ${name}
  defaultTransitRouterRouteTable:
    type: alicloud:cen:TransitRouterRouteTable
    name: default
    properties:
      transitRouterId: ${defaultTransitRouter.transitRouterId}
      transitRouterRouteTableName: ${name}
  defaultTransitRouterRouteTablePropagation:
    type: alicloud:cen:TransitRouterRouteTablePropagation
    name: default
    properties:
      transitRouterAttachmentId: ${defaultTransitRouterVbrAttachment.transitRouterAttachmentId}
      transitRouterRouteTableId: ${defaultTransitRouterRouteTable.transitRouterRouteTableId}
variables:
  default:
    fn::invoke:
      function: alicloud:expressconnect:getPhysicalConnections
      arguments:
        nameRegex: ^preserved-NODELETING
  ids:
    fn::invoke:
      function: alicloud:cen:getTransitRouterRouteTablePropagations
      arguments:
        transitRouterRouteTableId: ${defaultTransitRouterRouteTablePropagation.transitRouterRouteTableId}
        ids:
          - ${defaultTransitRouterRouteTablePropagation.transitRouterAttachmentId}
outputs:
  cenTransitRouterRouteTablePropagationId0: ${ids.propagations[0].id}

function getTransitRouterRouteTablePropagations(args: GetTransitRouterRouteTablePropagationsArgs, opts?: InvokeOptions): Promise<GetTransitRouterRouteTablePropagationsResult>
function getTransitRouterRouteTablePropagationsOutput(args: GetTransitRouterRouteTablePropagationsOutputArgs, opts?: InvokeOptions): Output<GetTransitRouterRouteTablePropagationsResult>

def get_transit_router_route_table_propagations(ids: Optional[Sequence[str]] = None,
                                                output_file: Optional[str] = None,
                                                status: Optional[str] = None,
                                                transit_router_attachment_id: Optional[str] = None,
                                                transit_router_route_table_id: Optional[str] = None,
                                                opts: Optional[InvokeOptions] = None) -> GetTransitRouterRouteTablePropagationsResult
def get_transit_router_route_table_propagations_output(ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                                                output_file: Optional[pulumi.Input[str]] = None,
                                                status: Optional[pulumi.Input[str]] = None,
                                                transit_router_attachment_id: Optional[pulumi.Input[str]] = None,
                                                transit_router_route_table_id: Optional[pulumi.Input[str]] = None,
                                                opts: Optional[InvokeOptions] = None) -> Output[GetTransitRouterRouteTablePropagationsResult]

func GetTransitRouterRouteTablePropagations(ctx *Context, args *GetTransitRouterRouteTablePropagationsArgs, opts ...InvokeOption) (*GetTransitRouterRouteTablePropagationsResult, error)
func GetTransitRouterRouteTablePropagationsOutput(ctx *Context, args *GetTransitRouterRouteTablePropagationsOutputArgs, opts ...InvokeOption) GetTransitRouterRouteTablePropagationsResultOutput

public static class GetTransitRouterRouteTablePropagations 
{
    public static Task<GetTransitRouterRouteTablePropagationsResult> InvokeAsync(GetTransitRouterRouteTablePropagationsArgs args, InvokeOptions? opts = null)
    public static Output<GetTransitRouterRouteTablePropagationsResult> Invoke(GetTransitRouterRouteTablePropagationsInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetTransitRouterRouteTablePropagationsResult> getTransitRouterRouteTablePropagations(GetTransitRouterRouteTablePropagationsArgs args, InvokeOptions options)
public static Output<GetTransitRouterRouteTablePropagationsResult> getTransitRouterRouteTablePropagations(GetTransitRouterRouteTablePropagationsArgs args, InvokeOptions options)

fn::invoke:
  function: alicloud:cen/getTransitRouterRouteTablePropagations:getTransitRouterRouteTablePropagations
  arguments:
    # arguments dictionary