routeros.IpService

import * as pulumi from "@pulumi/pulumi";
import * as routeros from "@pulumi/routeros";

const tlsService = {
    "api-ssl": 8729,
    "www-ssl": 443,
};
const disableService = {
    api: 8728,
    ftp: 21,
    telnet: 23,
    www: 80,
};
const enableService = {
    ssh: 22,
    winbox: 8291,
};
const tlsCert = new routeros.SystemCertificate("tlsCert", {
    commonName: "Mikrotik Router",
    daysValid: 3650,
    keyUsages: [
        "key-cert-sign",
        "crl-sign",
        "digital-signature",
        "key-agreement",
        "tls-server",
    ],
    keySize: "prime256v1",
    signs: [{}],
});
// terraform state rm 'routeros_ip_service.tls["www-ssl"]'
// terraform import 'routeros_ip_service.tls["www-ssl"]' www-ssl
const tls: routeros.IpService[] = [];
for (const range of Object.entries(tlsService).map(([k, v]) => ({key: k, value: v}))) {
    tls.push(new routeros.IpService(`tls-${range.key}`, {
        numbers: range.key,
        port: range.value,
        certificate: tlsCert.name,
        tlsVersion: "only-1.2",
        disabled: false,
    }));
}
const disabled: routeros.IpService[] = [];
for (const range of Object.entries(disableService).map(([k, v]) => ({key: k, value: v}))) {
    disabled.push(new routeros.IpService(`disabled-${range.key}`, {
        numbers: range.key,
        port: range.value,
        disabled: true,
    }));
}
const enabled: routeros.IpService[] = [];
for (const range of Object.entries(enableService).map(([k, v]) => ({key: k, value: v}))) {
    enabled.push(new routeros.IpService(`enabled-${range.key}`, {
        numbers: range.key,
        port: range.value,
        disabled: false,
    }));
}

import pulumi
import pulumi_routeros as routeros

tls_service = {
    "api-ssl": 8729,
    "www-ssl": 443,
}
disable_service = {
    "api": 8728,
    "ftp": 21,
    "telnet": 23,
    "www": 80,
}
enable_service = {
    "ssh": 22,
    "winbox": 8291,
}
tls_cert = routeros.SystemCertificate("tlsCert",
    common_name="Mikrotik Router",
    days_valid=3650,
    key_usages=[
        "key-cert-sign",
        "crl-sign",
        "digital-signature",
        "key-agreement",
        "tls-server",
    ],
    key_size="prime256v1",
    signs=[{}])
# terraform state rm 'routeros_ip_service.tls["www-ssl"]'
# terraform import 'routeros_ip_service.tls["www-ssl"]' www-ssl
tls = []
for range in [{"key": k, "value": v} for [k, v] in enumerate(tls_service)]:
    tls.append(routeros.IpService(f"tls-{range['key']}",
        numbers=range["key"],
        port=range["value"],
        certificate=tls_cert.name,
        tls_version="only-1.2",
        disabled=False))
disabled = []
for range in [{"key": k, "value": v} for [k, v] in enumerate(disable_service)]:
    disabled.append(routeros.IpService(f"disabled-{range['key']}",
        numbers=range["key"],
        port=range["value"],
        disabled=True))
enabled = []
for range in [{"key": k, "value": v} for [k, v] in enumerate(enable_service)]:
    enabled.append(routeros.IpService(f"enabled-{range['key']}",
        numbers=range["key"],
        port=range["value"],
        disabled=False))

package main

import (
	"github.com/pulumi/pulumi-terraform-provider/sdks/go/routeros/routeros"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		tlsService := map[string]interface{}{
			"api-ssl": 8729,
			"www-ssl": 443,
		}
		disableService := map[string]interface{}{
			"api":    8728,
			"ftp":    21,
			"telnet": 23,
			"www":    80,
		}
		enableService := map[string]interface{}{
			"ssh":    22,
			"winbox": 8291,
		}
		tlsCert, err := routeros.NewSystemCertificate(ctx, "tlsCert", &routeros.SystemCertificateArgs{
			CommonName: pulumi.String("Mikrotik Router"),
			DaysValid:  pulumi.Float64(3650),
			KeyUsages: pulumi.StringArray{
				pulumi.String("key-cert-sign"),
				pulumi.String("crl-sign"),
				pulumi.String("digital-signature"),
				pulumi.String("key-agreement"),
				pulumi.String("tls-server"),
			},
			KeySize: pulumi.String("prime256v1"),
			Signs: routeros.SystemCertificateSignArray{
				&routeros.SystemCertificateSignArgs{},
			},
		})
		if err != nil {
			return err
		}
		// terraform state rm 'routeros_ip_service.tls["www-ssl"]'
		// terraform import 'routeros_ip_service.tls["www-ssl"]' www-ssl
		var tls []*routeros.IpService
		for key0, val0 := range tlsService {
			__res, err := routeros.NewIpService(ctx, fmt.Sprintf("tls-%v", key0), &routeros.IpServiceArgs{
				Numbers:     pulumi.String(key0),
				Port:        pulumi.Float64(val0),
				Certificate: tlsCert.Name,
				TlsVersion:  pulumi.String("only-1.2"),
				Disabled:    pulumi.Bool(false),
			})
			if err != nil {
				return err
			}
			tls = append(tls, __res)
		}
		var disabled []*routeros.IpService
		for key0, val0 := range disableService {
			__res, err := routeros.NewIpService(ctx, fmt.Sprintf("disabled-%v", key0), &routeros.IpServiceArgs{
				Numbers:  pulumi.String(key0),
				Port:     pulumi.Float64(val0),
				Disabled: pulumi.Bool(true),
			})
			if err != nil {
				return err
			}
			disabled = append(disabled, __res)
		}
		var enabled []*routeros.IpService
		for key0, val0 := range enableService {
			__res, err := routeros.NewIpService(ctx, fmt.Sprintf("enabled-%v", key0), &routeros.IpServiceArgs{
				Numbers:  pulumi.String(key0),
				Port:     pulumi.Float64(val0),
				Disabled: pulumi.Bool(false),
			})
			if err != nil {
				return err
			}
			enabled = append(enabled, __res)
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Routeros = Pulumi.Routeros;

return await Deployment.RunAsync(() => 
{
    var tlsService = 
    {
        { "api-ssl", 8729 },
        { "www-ssl", 443 },
    };

    var disableService = 
    {
        { "api", 8728 },
        { "ftp", 21 },
        { "telnet", 23 },
        { "www", 80 },
    };

    var enableService = 
    {
        { "ssh", 22 },
        { "winbox", 8291 },
    };

    var tlsCert = new Routeros.SystemCertificate("tlsCert", new()
    {
        CommonName = "Mikrotik Router",
        DaysValid = 3650,
        KeyUsages = new[]
        {
            "key-cert-sign",
            "crl-sign",
            "digital-signature",
            "key-agreement",
            "tls-server",
        },
        KeySize = "prime256v1",
        Signs = new[]
        {
            null,
        },
    });

    // terraform state rm 'routeros_ip_service.tls["www-ssl"]'
    // terraform import 'routeros_ip_service.tls["www-ssl"]' www-ssl
    var tls = new List<Routeros.IpService>();
    foreach (var range in tlsService.Select(pair => new { pair.Key, pair.Value }))
    {
        tls.Add(new Routeros.IpService($"tls-{range.Key}", new()
        {
            Numbers = range.Key,
            Port = range.Value,
            Certificate = tlsCert.Name,
            TlsVersion = "only-1.2",
            Disabled = false,
        }));
    }
    var disabled = new List<Routeros.IpService>();
    foreach (var range in disableService.Select(pair => new { pair.Key, pair.Value }))
    {
        disabled.Add(new Routeros.IpService($"disabled-{range.Key}", new()
        {
            Numbers = range.Key,
            Port = range.Value,
            Disabled = true,
        }));
    }
    var enabled = new List<Routeros.IpService>();
    foreach (var range in enableService.Select(pair => new { pair.Key, pair.Value }))
    {
        enabled.Add(new Routeros.IpService($"enabled-{range.Key}", new()
        {
            Numbers = range.Key,
            Port = range.Value,
            Disabled = false,
        }));
    }
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.routeros.SystemCertificate;
import com.pulumi.routeros.SystemCertificateArgs;
import com.pulumi.routeros.inputs.SystemCertificateSignArgs;
import com.pulumi.routeros.IpService;
import com.pulumi.routeros.IpServiceArgs;
import com.pulumi.codegen.internal.KeyedValue;
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 tlsService = %!v(PANIC=Format method: runtime error: invalid memory address or nil pointer dereference);

        final var disableService = %!v(PANIC=Format method: runtime error: invalid memory address or nil pointer dereference);

        final var enableService = %!v(PANIC=Format method: runtime error: invalid memory address or nil pointer dereference);

        var tlsCert = new SystemCertificate("tlsCert", SystemCertificateArgs.builder()
            .commonName("Mikrotik Router")
            .daysValid(3650)
            .keyUsages(            
                "key-cert-sign",
                "crl-sign",
                "digital-signature",
                "key-agreement",
                "tls-server")
            .keySize("prime256v1")
            .signs()
            .build());

        // terraform state rm 'routeros_ip_service.tls["www-ssl"]'
        // terraform import 'routeros_ip_service.tls["www-ssl"]' www-ssl
        for (var range : KeyedValue.of(tlsService)) {
            new IpService("tls-" + range.key(), IpServiceArgs.builder()
                .numbers(range.key())
                .port(range.value())
                .certificate(tlsCert.name())
                .tlsVersion("only-1.2")
                .disabled(false)
                .build());
        }

        for (var range : KeyedValue.of(disableService)) {
            new IpService("disabled-" + range.key(), IpServiceArgs.builder()
                .numbers(range.key())
                .port(range.value())
                .disabled(true)
                .build());
        }

        for (var range : KeyedValue.of(enableService)) {
            new IpService("enabled-" + range.key(), IpServiceArgs.builder()
                .numbers(range.key())
                .port(range.value())
                .disabled(false)
                .build());
        }

    }
}

resources:
  tlsCert:
    type: routeros:SystemCertificate
    properties:
      commonName: Mikrotik Router
      daysValid: 3650
      keyUsages:
        - key-cert-sign
        - crl-sign
        - digital-signature
        - key-agreement
        - tls-server
      keySize: prime256v1
      signs:
        - {}
  # terraform state rm 'routeros_ip_service.tls["www-ssl"]'
  # terraform import 'routeros_ip_service.tls["www-ssl"]' www-ssl
  tls:
    type: routeros:IpService
    properties:
      numbers: ${range.key}
      port: ${range.value}
      certificate: ${tlsCert.name}
      tlsVersion: only-1.2
      disabled: false
    options: {}
  disabled:
    type: routeros:IpService
    properties:
      numbers: ${range.key}
      port: ${range.value}
      disabled: true
    options: {}
  enabled:
    type: routeros:IpService
    properties:
      numbers: ${range.key}
      port: ${range.value}
      disabled: false
    options: {}
variables:
  tlsService:
    api-ssl: 8729
    www-ssl: 443
  disableService:
    api: 8728
    ftp: 21
    telnet: 23
    www: 80
  enableService:
    ssh: 22
    winbox: 8291