powerscale.getSynciqPeerCertificate

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

//Copyright (c) 2024 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.
// PowerScale SyncIQ Certificate allows you to get a list of SyncIQ Peer Certificates or a peer certificate by its ID.
// Returns a list of PowerScale SyncIQ Certificates
const allCertificates = powerscale.getSynciqPeerCertificate({});
// Returns a the PowerScale SyncIQ Certificate with given ID
const oneCertificate = powerscale.getSynciqPeerCertificate({
    id: "g23j9a1f83h12n5j4",
});
// Returns the PowerScale SyncIQ Certificate with given name
const oneCertificateByName = powerscale.getSynciqPeerCertificate({
    filter: {
        name: "tfaccTest",
    },
});
export const powerscaleSynciqAllCertificates = allCertificates.then(allCertificates => allCertificates.certificates);
export const certificateByID = oneCertificate.then(oneCertificate => oneCertificate.certificates?.[0]);
export const certificateByName = oneCertificateByName.then(oneCertificateByName => oneCertificateByName.certificates?.[0]);
export const certificatesByStatus = {
    valid: allCertificates.then(allCertificates => .filter(certificate => certificate.status == "valid").map(certificate => (certificate))),
    invalid: allCertificates.then(allCertificates => .filter(certificate => certificate.status == "invalid").map(certificate => (certificate))),
    expired: allCertificates.then(allCertificates => .filter(certificate => certificate.status == "expired").map(certificate => (certificate))),
    expiring: allCertificates.then(allCertificates => .filter(certificate => certificate.status == "expiring").map(certificate => (certificate))),
};

import pulumi
import pulumi_powerscale as powerscale

#Copyright (c) 2024 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.
# PowerScale SyncIQ Certificate allows you to get a list of SyncIQ Peer Certificates or a peer certificate by its ID.
# Returns a list of PowerScale SyncIQ Certificates
all_certificates = powerscale.get_synciq_peer_certificate()
# Returns a the PowerScale SyncIQ Certificate with given ID
one_certificate = powerscale.get_synciq_peer_certificate(id="g23j9a1f83h12n5j4")
# Returns the PowerScale SyncIQ Certificate with given name
one_certificate_by_name = powerscale.get_synciq_peer_certificate(filter={
    "name": "tfaccTest",
})
pulumi.export("powerscaleSynciqAllCertificates", all_certificates.certificates)
pulumi.export("certificateByID", one_certificate.certificates[0])
pulumi.export("certificateByName", one_certificate_by_name.certificates[0])
pulumi.export("certificatesByStatus", {
    "valid": [certificate for certificate in all_certificates.certificates if certificate.status == "valid"],
    "invalid": [certificate for certificate in all_certificates.certificates if certificate.status == "invalid"],
    "expired": [certificate for certificate in all_certificates.certificates if certificate.status == "expired"],
    "expiring": [certificate for certificate in all_certificates.certificates if certificate.status == "expiring"],
})

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

return await Deployment.RunAsync(() => 
{
    //Copyright (c) 2024 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.
    // PowerScale SyncIQ Certificate allows you to get a list of SyncIQ Peer Certificates or a peer certificate by its ID.
    // Returns a list of PowerScale SyncIQ Certificates
    var allCertificates = Powerscale.GetSynciqPeerCertificate.Invoke();

    // Returns a the PowerScale SyncIQ Certificate with given ID
    var oneCertificate = Powerscale.GetSynciqPeerCertificate.Invoke(new()
    {
        Id = "g23j9a1f83h12n5j4",
    });

    // Returns the PowerScale SyncIQ Certificate with given name
    var oneCertificateByName = Powerscale.GetSynciqPeerCertificate.Invoke(new()
    {
        Filter = new Powerscale.Inputs.GetSynciqPeerCertificateFilterInputArgs
        {
            Name = "tfaccTest",
        },
    });

    return new Dictionary<string, object?>
    {
        ["powerscaleSynciqAllCertificates"] = allCertificates.Apply(getSynciqPeerCertificateResult => getSynciqPeerCertificateResult.Certificates),
        ["certificateByID"] = oneCertificate.Apply(getSynciqPeerCertificateResult => getSynciqPeerCertificateResult.Certificates[0]),
        ["certificateByName"] = oneCertificateByName.Apply(getSynciqPeerCertificateResult => getSynciqPeerCertificateResult.Certificates[0]),
        ["certificatesByStatus"] = 
        {
            { "valid", .Where(certificate => certificate.Status == "valid").Select(certificate => 
            {
                return certificate;
            }).ToList() },
            { "invalid", .Where(certificate => certificate.Status == "invalid").Select(certificate => 
            {
                return certificate;
            }).ToList() },
            { "expired", .Where(certificate => certificate.Status == "expired").Select(certificate => 
            {
                return certificate;
            }).ToList() },
            { "expiring", .Where(certificate => certificate.Status == "expiring").Select(certificate => 
            {
                return certificate;
            }).ToList() },
        },
    };
});

function getSynciqPeerCertificate(args: GetSynciqPeerCertificateArgs, opts?: InvokeOptions): Promise<GetSynciqPeerCertificateResult>
function getSynciqPeerCertificateOutput(args: GetSynciqPeerCertificateOutputArgs, opts?: InvokeOptions): Output<GetSynciqPeerCertificateResult>

def get_synciq_peer_certificate(filter: Optional[GetSynciqPeerCertificateFilter] = None,
                                id: Optional[str] = None,
                                opts: Optional[InvokeOptions] = None) -> GetSynciqPeerCertificateResult
def get_synciq_peer_certificate_output(filter: pulumi.Input[Optional[GetSynciqPeerCertificateFilterArgs]] = None,
                                id: pulumi.Input[Optional[str]] = None,
                                opts: Optional[InvokeOptions] = None) -> Output[GetSynciqPeerCertificateResult]

func LookupSynciqPeerCertificate(ctx *Context, args *LookupSynciqPeerCertificateArgs, opts ...InvokeOption) (*LookupSynciqPeerCertificateResult, error)
func LookupSynciqPeerCertificateOutput(ctx *Context, args *LookupSynciqPeerCertificateOutputArgs, opts ...InvokeOption) LookupSynciqPeerCertificateResultOutput

public static class GetSynciqPeerCertificate 
{
    public static Task<GetSynciqPeerCertificateResult> InvokeAsync(GetSynciqPeerCertificateArgs args, InvokeOptions? opts = null)
    public static Output<GetSynciqPeerCertificateResult> Invoke(GetSynciqPeerCertificateInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetSynciqPeerCertificateResult> getSynciqPeerCertificate(GetSynciqPeerCertificateArgs args, InvokeOptions options)
public static Output<GetSynciqPeerCertificateResult> getSynciqPeerCertificate(GetSynciqPeerCertificateArgs args, InvokeOptions options)

fn::invoke:
  function: powerscale:index/getSynciqPeerCertificate:getSynciqPeerCertificate
  arguments:
    # arguments dictionary