powerstore.getIoLimitRule

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

//Copyright (c) 2025 Dell Inc., or its subsidiaries. All Rights Reserved.
//
//Licensed under the Mozilla Public License Version 2.0 (the "License");
//you may not use this file except in compliance with the License.
//You may obtain a copy of the License at
//
//    http://mozilla.org/MPL/2.0/
//
//
//Unless required by applicable law or agreed to in writing, software
//distributed under the License is distributed on an "AS IS" BASIS,
//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//See the License for the specific language governing permissions and
//limitations under the License.
// commands to run this tf file : terraform init && pulumi up --auto-approve
// This datasource reads I/O limit rules either by id or name where user can provide a value to any one of them
// If it is a empty datasource block , then it will read all the I/O limit rules
// If id or name is provided then it reads a particular I/O limit rule with that id or name
// Only one of the attribute can be provided among id and name
const test1 = powerstore.getIoLimitRule({
    name: "tf_acc_io_limit_rule",
});
export const ioLimitRuleAllDetails = test1.then(test1 => test1.ioLimitRules);
export const ioLimitRuleIDsOnly = test1.then(test1 => test1.ioLimitRules.map(__item => __item.id));
export const ioLimitRuleIdAndMaxIops = test1.then(test1 => .reduce((__obj, rule) => ({ ...__obj, [rule.name]: {
    id: rule.id,
    maxIops: rule.maxIops,
} })));

import pulumi
import pulumi_powerstore as powerstore

#Copyright (c) 2025 Dell Inc., or its subsidiaries. All Rights Reserved.
#
#Licensed under the Mozilla Public License Version 2.0 (the "License");
#you may not use this file except in compliance with the License.
#You may obtain a copy of the License at
#
#    http://mozilla.org/MPL/2.0/
#
#
#Unless required by applicable law or agreed to in writing, software
#distributed under the License is distributed on an "AS IS" BASIS,
#WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#See the License for the specific language governing permissions and
#limitations under the License.
# commands to run this tf file : terraform init && pulumi up --auto-approve
# This datasource reads I/O limit rules either by id or name where user can provide a value to any one of them
# If it is a empty datasource block , then it will read all the I/O limit rules
# If id or name is provided then it reads a particular I/O limit rule with that id or name
# Only one of the attribute can be provided among id and name
test1 = powerstore.get_io_limit_rule(name="tf_acc_io_limit_rule")
pulumi.export("ioLimitRuleAllDetails", test1.io_limit_rules)
pulumi.export("ioLimitRuleIDsOnly", [__item.id for __item in test1.io_limit_rules])
pulumi.export("ioLimitRuleIdAndMaxIops", {rule.name: {
    "id": rule.id,
    "maxIops": rule.max_iops,
} for rule in test1.io_limit_rules})

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

return await Deployment.RunAsync(() => 
{
    //Copyright (c) 2025 Dell Inc., or its subsidiaries. All Rights Reserved.
    //
    //Licensed under the Mozilla Public License Version 2.0 (the "License");
    //you may not use this file except in compliance with the License.
    //You may obtain a copy of the License at
    //
    //    http://mozilla.org/MPL/2.0/
    //
    //
    //Unless required by applicable law or agreed to in writing, software
    //distributed under the License is distributed on an "AS IS" BASIS,
    //WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    //See the License for the specific language governing permissions and
    //limitations under the License.
    // commands to run this tf file : terraform init && pulumi up --auto-approve
    // This datasource reads I/O limit rules either by id or name where user can provide a value to any one of them
    // If it is a empty datasource block , then it will read all the I/O limit rules
    // If id or name is provided then it reads a particular I/O limit rule with that id or name
    // Only one of the attribute can be provided among id and name
    var test1 = Powerstore.GetIoLimitRule.Invoke(new()
    {
        Name = "tf_acc_io_limit_rule",
    });

    return new Dictionary<string, object?>
    {
        ["ioLimitRuleAllDetails"] = test1.Apply(getIoLimitRuleResult => getIoLimitRuleResult.IoLimitRules),
        ["ioLimitRuleIDsOnly"] = test1.Apply(getIoLimitRuleResult => getIoLimitRuleResult.IoLimitRules).Select(__item => __item.Id).ToList(),
        ["ioLimitRuleIdAndMaxIops"] = .ToDictionary(item => {
            var rule = item.Value;
            return rule.Name;
        }, item => {
            var rule = item.Value;
            return 
            {
                { "id", rule.Id },
                { "maxIops", rule.MaxIops },
            };
        }),
    };
});

function getIoLimitRule(args: GetIoLimitRuleArgs, opts?: InvokeOptions): Promise<GetIoLimitRuleResult>
function getIoLimitRuleOutput(args: GetIoLimitRuleOutputArgs, opts?: InvokeOptions): Output<GetIoLimitRuleResult>

def get_io_limit_rule(filter_expression: Optional[str] = None,
                      id: Optional[str] = None,
                      name: Optional[str] = None,
                      type: Optional[str] = None,
                      opts: Optional[InvokeOptions] = None) -> GetIoLimitRuleResult
def get_io_limit_rule_output(filter_expression: pulumi.Input[Optional[str]] = None,
                      id: pulumi.Input[Optional[str]] = None,
                      name: pulumi.Input[Optional[str]] = None,
                      type: pulumi.Input[Optional[str]] = None,
                      opts: Optional[InvokeOptions] = None) -> Output[GetIoLimitRuleResult]

func LookupIoLimitRule(ctx *Context, args *LookupIoLimitRuleArgs, opts ...InvokeOption) (*LookupIoLimitRuleResult, error)
func LookupIoLimitRuleOutput(ctx *Context, args *LookupIoLimitRuleOutputArgs, opts ...InvokeOption) LookupIoLimitRuleResultOutput

public static class GetIoLimitRule 
{
    public static Task<GetIoLimitRuleResult> InvokeAsync(GetIoLimitRuleArgs args, InvokeOptions? opts = null)
    public static Output<GetIoLimitRuleResult> Invoke(GetIoLimitRuleInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetIoLimitRuleResult> getIoLimitRule(GetIoLimitRuleArgs args, InvokeOptions options)
public static Output<GetIoLimitRuleResult> getIoLimitRule(GetIoLimitRuleArgs args, InvokeOptions options)

fn::invoke:
  function: powerstore:index/getIoLimitRule:getIoLimitRule
  arguments:
    # arguments dictionary

data "powerstore_getiolimitrule" "name" {
    # arguments
}