routeros.getIpServices

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

export = async () => {
    const router = await routeros.getIpServices({});
    const router_disabled: routeros.IpService[] = [];
    for (const range of Object.entries(.filter(s => s.name != "www-ssl").reduce((__obj, s) => ({ ...__obj, [s.name]: s }))).map(([k, v]) => ({key: k, value: v}))) {
        router_disabled.push(new routeros.IpService(`router-disabled-${range.key}`, {
            disabled: true,
            numbers: range.value.name,
            port: range.value.port,
        }));
    }
}

import pulumi
import pulumi_routeros as routeros

router = routeros.get_ip_services()
router_disabled = []
for range in [{"key": k, "value": v} for [k, v] in enumerate({s.name: s for s in router.services if s.name != www-ssl})]:
    router_disabled.append(routeros.IpService(f"router-disabled-{range['key']}",
        disabled=True,
        numbers=%!v(PANIC=Format method: runtime error: index out of range [-1]),
        port=%!v(PANIC=Format method: runtime error: index out of range [-1])))

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

return await Deployment.RunAsync(async() => 
{
    var router = await Routeros.GetIpServices.InvokeAsync();

    var router_disabled = new List<Routeros.IpService>();
    foreach (var range in .Select(pair => new { pair.Key, pair.Value }))
    {
        router_disabled.Add(new Routeros.IpService($"router-disabled-{range.Key}", new()
        {
            Disabled = true,
            Numbers = range.Value.Name,
            Port = range.Value.Port,
        }));
    }
});

resources:
  router-disabled:
    type: routeros:IpService
    properties:
      disabled: true
      numbers: ${range.value.name}
      port: ${range.value.port}
    options: {}
variables:
  router:
    fn::invoke:
      function: routeros:getIpServices
      arguments: {}

function getIpServices(args: GetIpServicesArgs, opts?: InvokeOptions): Promise<GetIpServicesResult>
function getIpServicesOutput(args: GetIpServicesOutputArgs, opts?: InvokeOptions): Output<GetIpServicesResult>

def get_ip_services(___id_: Optional[float] = None,
                    ___path_: Optional[str] = None,
                    filter: Optional[Mapping[str, str]] = None,
                    id: Optional[str] = None,
                    opts: Optional[InvokeOptions] = None) -> GetIpServicesResult
def get_ip_services_output(___id_: Optional[pulumi.Input[float]] = None,
                    ___path_: Optional[pulumi.Input[str]] = None,
                    filter: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
                    id: Optional[pulumi.Input[str]] = None,
                    opts: Optional[InvokeOptions] = None) -> Output[GetIpServicesResult]

func GetIpServices(ctx *Context, args *GetIpServicesArgs, opts ...InvokeOption) (*GetIpServicesResult, error)
func GetIpServicesOutput(ctx *Context, args *GetIpServicesOutputArgs, opts ...InvokeOption) GetIpServicesResultOutput

public static class GetIpServices 
{
    public static Task<GetIpServicesResult> InvokeAsync(GetIpServicesArgs args, InvokeOptions? opts = null)
    public static Output<GetIpServicesResult> Invoke(GetIpServicesInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetIpServicesResult> getIpServices(GetIpServicesArgs args, InvokeOptions options)
public static Output<GetIpServicesResult> getIpServices(GetIpServicesArgs args, InvokeOptions options)

fn::invoke:
  function: routeros:index/getIpServices:getIpServices
  arguments:
    # arguments dictionary