armstoragepool

package module
v1.2.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Nov 24, 2023 License: MIT Imports: 14 Imported by: 2

README

Azure Storage Pool Module for Go

PkgGoDev

The armstoragepool module provides operations for working with Azure Storage Pool.

Source code

Getting started

Prerequisites

  • an Azure subscription
  • Go 1.18 or above (You could download and install the latest version of Go from here. It will replace the existing Go on your machine. If you want to install multiple Go versions on the same machine, you could refer this doc.)

Install the package

This project uses Go modules for versioning and dependency management.

Install the Azure Storage Pool module:

go get github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storagepool/armstoragepool

Authorization

When creating a client, you will need to provide a credential for authenticating with Azure Storage Pool. The azidentity module provides facilities for various ways of authenticating with Azure including client/secret, certificate, managed identity, and more.

cred, err := azidentity.NewDefaultAzureCredential(nil)

For more information on authentication, please see the documentation for azidentity at pkg.go.dev/github.com/Azure/azure-sdk-for-go/sdk/azidentity.

Client Factory

Azure Storage Pool module consists of one or more clients. We provide a client factory which could be used to create any client in this module.

clientFactory, err := armstoragepool.NewClientFactory(<subscription ID>, cred, nil)

You can use ClientOptions in package github.com/Azure/azure-sdk-for-go/sdk/azcore/arm to set endpoint to connect with public and sovereign clouds as well as Azure Stack. For more information, please see the documentation for azcore at pkg.go.dev/github.com/Azure/azure-sdk-for-go/sdk/azcore.

options := arm.ClientOptions {
    ClientOptions: azcore.ClientOptions {
        Cloud: cloud.AzureChina,
    },
}
clientFactory, err := armstoragepool.NewClientFactory(<subscription ID>, cred, &options)

Clients

A client groups a set of related APIs, providing access to its functionality. Create one or more clients to access the APIs you require using client factory.

client := clientFactory.NewDiskPoolsClient()

Fakes

The fake package contains types used for constructing in-memory fake servers used in unit tests. This allows writing tests to cover various success/error conditions without the need for connecting to a live service.

Please see https://github.com/Azure/azure-sdk-for-go/tree/main/sdk/samples/fakes for details and examples on how to use fakes.

Provide Feedback

If you encounter bugs or have suggestions, please open an issue and assign the Storage Pool label.

Contributing

This project welcomes contributions and suggestions. Most contributions require you to agree to a Contributor License Agreement (CLA) declaring that you have the right to, and actually do, grant us the rights to use your contribution. For details, visit https://cla.microsoft.com.

When you submit a pull request, a CLA-bot will automatically determine whether you need to provide a CLA and decorate the PR appropriately (e.g., label, comment). Simply follow the instructions provided by the bot. You will only need to do this once across all repos using our CLA.

This project has adopted the Microsoft Open Source Code of Conduct. For more information, see the Code of Conduct FAQ or contact opencode@microsoft.com with any additional questions or comments.

Documentation

Index

Examples

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type ACL 

type ACL struct {
	// REQUIRED; iSCSI initiator IQN (iSCSI Qualified Name); example: "iqn.2005-03.org.iscsi:client".
	InitiatorIqn *string

	// REQUIRED; List of LUN names mapped to the ACL.
	MappedLuns []*string
}

ACL - Access Control List (ACL) for an iSCSI Target; defines LUN masking policy

func (ACL) MarshalJSON 

func (a ACL) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ACL.

func (*ACL) UnmarshalJSON added in v1.1.0 

func (a *ACL) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ACL.

type ClientFactory added in v1.1.0 

type ClientFactory struct {
	// contains filtered or unexported fields
}

ClientFactory is a client factory used to create any client in this module. Don't use this type directly, use NewClientFactory instead.

func NewClientFactory added in v1.1.0 

func NewClientFactory(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*ClientFactory, error)

NewClientFactory creates a new instance of ClientFactory with the specified values. The parameter values will be propagated to any client created from this factory.

  • subscriptionID - The ID of the target subscription.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*ClientFactory) NewDiskPoolZonesClient added in v1.1.0 

func (c *ClientFactory) NewDiskPoolZonesClient() *DiskPoolZonesClient

NewDiskPoolZonesClient creates a new instance of DiskPoolZonesClient.

func (*ClientFactory) NewDiskPoolsClient added in v1.1.0 

func (c *ClientFactory) NewDiskPoolsClient() *DiskPoolsClient

NewDiskPoolsClient creates a new instance of DiskPoolsClient.

func (*ClientFactory) NewIscsiTargetsClient added in v1.1.0 

func (c *ClientFactory) NewIscsiTargetsClient() *IscsiTargetsClient

NewIscsiTargetsClient creates a new instance of IscsiTargetsClient.

func (*ClientFactory) NewOperationsClient added in v1.1.0 

func (c *ClientFactory) NewOperationsClient() *OperationsClient

NewOperationsClient creates a new instance of OperationsClient.

func (*ClientFactory) NewResourceSKUsClient added in v1.1.0 

func (c *ClientFactory) NewResourceSKUsClient() *ResourceSKUsClient

NewResourceSKUsClient creates a new instance of ResourceSKUsClient.

type CreatedByType 

type CreatedByType string

CreatedByType - The type of identity that created the resource. 

const (
	CreatedByTypeApplication     CreatedByType = "Application"
	CreatedByTypeKey             CreatedByType = "Key"
	CreatedByTypeManagedIdentity CreatedByType = "ManagedIdentity"
	CreatedByTypeUser            CreatedByType = "User"
)

func PossibleCreatedByTypeValues 

func PossibleCreatedByTypeValues() []CreatedByType

PossibleCreatedByTypeValues returns the possible values for the CreatedByType const type.

type Disk 

type Disk struct {
	// REQUIRED; Unique Azure Resource ID of the Managed Disk.
	ID *string
}

Disk - Azure Managed Disk to attach to the Disk Pool.

func (Disk) MarshalJSON added in v1.1.0 

func (d Disk) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type Disk.

func (*Disk) UnmarshalJSON added in v1.1.0 

func (d *Disk) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type Disk.

type DiskPool 

type DiskPool struct {
	// REQUIRED; The geo-location where the resource lives.
	Location *string

	// REQUIRED; Properties of Disk Pool.
	Properties *DiskPoolProperties

	// Determines the SKU of the Disk pool
	SKU *SKU

	// Resource tags.
	Tags map[string]*string

	// READ-ONLY; Fully qualified resource Id for the resource. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}
	ID *string

	// READ-ONLY; Azure resource id. Indicates if this resource is managed by another Azure resource.
	ManagedBy *string

	// READ-ONLY; List of Azure resource ids that manage this resource.
	ManagedByExtended []*string

	// READ-ONLY; The name of the resource
	Name *string

	// READ-ONLY; Resource metadata required by ARM RPC
	SystemData *SystemMetadata

	// READ-ONLY; The type of the resource. Ex- Microsoft.Compute/virtualMachines or Microsoft.Storage/storageAccounts.
	Type *string
}

DiskPool - Response for Disk Pool request.

func (DiskPool) MarshalJSON 

func (d DiskPool) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type DiskPool.

func (*DiskPool) UnmarshalJSON added in v1.1.0 

func (d *DiskPool) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type DiskPool.

type DiskPoolCreate 

type DiskPoolCreate struct {
	// REQUIRED; The geo-location where the resource lives.
	Location *string

	// REQUIRED; Properties for Disk Pool create request.
	Properties *DiskPoolCreateProperties

	// REQUIRED; Determines the SKU of the Disk Pool
	SKU *SKU

	// Azure resource id. Indicates if this resource is managed by another Azure resource.
	ManagedBy *string

	// List of Azure resource ids that manage this resource.
	ManagedByExtended []*string

	// Resource tags.
	Tags map[string]*string

	// READ-ONLY; Fully qualified resource Id for the resource. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}
	ID *string

	// READ-ONLY; The name of the resource
	Name *string

	// READ-ONLY; The type of the resource. Ex- Microsoft.Compute/virtualMachines or Microsoft.Storage/storageAccounts.
	Type *string
}

DiskPoolCreate - Request payload for create or update Disk Pool request.

func (DiskPoolCreate) MarshalJSON 

func (d DiskPoolCreate) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type DiskPoolCreate.

func (*DiskPoolCreate) UnmarshalJSON added in v1.1.0 

func (d *DiskPoolCreate) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type DiskPoolCreate.

type DiskPoolCreateProperties 

type DiskPoolCreateProperties struct {
	// REQUIRED; Azure Resource ID of a Subnet for the Disk Pool.
	SubnetID *string

	// List of additional capabilities for a Disk Pool.
	AdditionalCapabilities []*string

	// Logical zone for Disk Pool resource; example: ["1"].
	AvailabilityZones []*string

	// List of Azure Managed Disks to attach to a Disk Pool.
	Disks []*Disk
}

DiskPoolCreateProperties - Properties for Disk Pool create or update request.

func (DiskPoolCreateProperties) MarshalJSON 

func (d DiskPoolCreateProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type DiskPoolCreateProperties.

func (*DiskPoolCreateProperties) UnmarshalJSON added in v1.1.0 

func (d *DiskPoolCreateProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type DiskPoolCreateProperties.

type DiskPoolListResult 

type DiskPoolListResult struct {
	// REQUIRED; An array of Disk pool objects.
	Value []*DiskPool

	// READ-ONLY; URI to fetch the next section of the paginated response.
	NextLink *string
}

DiskPoolListResult - List of Disk Pools

func (DiskPoolListResult) MarshalJSON 

func (d DiskPoolListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type DiskPoolListResult.

func (*DiskPoolListResult) UnmarshalJSON added in v1.1.0 

func (d *DiskPoolListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type DiskPoolListResult.

type DiskPoolProperties 

type DiskPoolProperties struct {
	// REQUIRED; Logical zone for Disk Pool resource; example: ["1"].
	AvailabilityZones []*string

	// REQUIRED; Operational status of the Disk Pool.
	Status *OperationalStatus

	// REQUIRED; Azure Resource ID of a Subnet for the Disk Pool.
	SubnetID *string

	// READ-ONLY; State of the operation on the resource.
	ProvisioningState *ProvisioningStates

	// List of additional capabilities for Disk Pool.
	AdditionalCapabilities []*string

	// List of Azure Managed Disks to attach to a Disk Pool.
	Disks []*Disk
}

DiskPoolProperties - Disk Pool response properties.

func (DiskPoolProperties) MarshalJSON 

func (d DiskPoolProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type DiskPoolProperties.

func (*DiskPoolProperties) UnmarshalJSON added in v1.1.0 

func (d *DiskPoolProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type DiskPoolProperties.

type DiskPoolTier 

type DiskPoolTier string

DiskPoolTier - SKU of the VM host part of the Disk Pool deployment 

const (
	DiskPoolTierBasic    DiskPoolTier = "Basic"
	DiskPoolTierPremium  DiskPoolTier = "Premium"
	DiskPoolTierStandard DiskPoolTier = "Standard"
)

func PossibleDiskPoolTierValues 

func PossibleDiskPoolTierValues() []DiskPoolTier

PossibleDiskPoolTierValues returns the possible values for the DiskPoolTier const type.

type DiskPoolUpdate 

type DiskPoolUpdate struct {
	// REQUIRED; Properties for Disk Pool update request.
	Properties *DiskPoolUpdateProperties

	// Azure resource id. Indicates if this resource is managed by another Azure resource.
	ManagedBy *string

	// List of Azure resource ids that manage this resource.
	ManagedByExtended []*string

	// Determines the SKU of the Disk Pool
	SKU *SKU

	// Resource tags.
	Tags map[string]*string
}

DiskPoolUpdate - Request payload for Update Disk Pool request.

func (DiskPoolUpdate) MarshalJSON 

func (d DiskPoolUpdate) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type DiskPoolUpdate.

func (*DiskPoolUpdate) UnmarshalJSON added in v1.1.0 

func (d *DiskPoolUpdate) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type DiskPoolUpdate.

type DiskPoolUpdateProperties 

type DiskPoolUpdateProperties struct {
	// List of Azure Managed Disks to attach to a Disk Pool.
	Disks []*Disk
}

DiskPoolUpdateProperties - Properties for Disk Pool update request.

func (DiskPoolUpdateProperties) MarshalJSON 

func (d DiskPoolUpdateProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type DiskPoolUpdateProperties.

func (*DiskPoolUpdateProperties) UnmarshalJSON added in v1.1.0 

func (d *DiskPoolUpdateProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type DiskPoolUpdateProperties.

type DiskPoolZoneInfo 

type DiskPoolZoneInfo struct {
	// READ-ONLY; List of additional capabilities for Disk Pool.
	AdditionalCapabilities []*string

	// READ-ONLY; Logical zone for Disk Pool resource; example: ["1"].
	AvailabilityZones []*string

	// READ-ONLY; Determines the SKU of VM deployed for Disk Pool
	SKU *SKU
}

DiskPoolZoneInfo - Disk Pool SKU Details

func (DiskPoolZoneInfo) MarshalJSON 

func (d DiskPoolZoneInfo) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type DiskPoolZoneInfo.

func (*DiskPoolZoneInfo) UnmarshalJSON added in v1.1.0 

func (d *DiskPoolZoneInfo) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type DiskPoolZoneInfo.

type DiskPoolZoneListResult 

type DiskPoolZoneListResult struct {
	// READ-ONLY; URI to fetch the next section of the paginated response.
	NextLink *string

	// READ-ONLY; The list of Disk Pool Skus.
	Value []*DiskPoolZoneInfo
}

DiskPoolZoneListResult - List Disk Pool skus operation response.

func (DiskPoolZoneListResult) MarshalJSON 

func (d DiskPoolZoneListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type DiskPoolZoneListResult.

func (*DiskPoolZoneListResult) UnmarshalJSON added in v1.1.0 

func (d *DiskPoolZoneListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type DiskPoolZoneListResult.

type DiskPoolZonesClient 

type DiskPoolZonesClient struct {
	// contains filtered or unexported fields
}

DiskPoolZonesClient contains the methods for the DiskPoolZones group. Don't use this type directly, use NewDiskPoolZonesClient() instead.

func NewDiskPoolZonesClient 

func NewDiskPoolZonesClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*DiskPoolZonesClient, error)

NewDiskPoolZonesClient creates a new instance of DiskPoolZonesClient with the specified values.

  • subscriptionID - The ID of the target subscription.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*DiskPoolZonesClient) NewListPager added in v0.4.0 

func (client *DiskPoolZonesClient) NewListPager(location string, options *DiskPoolZonesClientListOptions) *runtime.Pager[DiskPoolZonesClientListResponse]

NewListPager - Lists available Disk Pool Skus in an Azure location.

Generated from API version 2021-08-01

  • location - The location of the resource.
  • options - DiskPoolZonesClientListOptions contains the optional parameters for the DiskPoolZonesClient.NewListPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/storagepool/resource-manager/Microsoft.StoragePool/stable/2021-08-01/examples/DiskPoolZones_List.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storagepool/armstoragepool"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstoragepool.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewDiskPoolZonesClient().NewListPager("eastus", nil)
	for pager.More() {
		page, err := pager.NextPage(ctx)
		if err != nil {
			log.Fatalf("failed to advance page: %v", err)
		}
		for _, v := range page.Value {
			// You could use page here. We use blank identifier for just demo purposes.
			_ = v
		}
		// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
		// page.DiskPoolZoneListResult = armstoragepool.DiskPoolZoneListResult{
		// 	Value: []*armstoragepool.DiskPoolZoneInfo{
		// 		{
		// 			AdditionalCapabilities: []*string{
		// 			},
		// 			AvailabilityZones: []*string{
		// 				to.Ptr("1"),
		// 				to.Ptr("2"),
		// 				to.Ptr("3")},
		// 				SKU: &armstoragepool.SKU{
		// 					Name: to.Ptr("Basic"),
		// 					Tier: to.Ptr("Basic_V1"),
		// 				},
		// 			},
		// 			{
		// 				AdditionalCapabilities: []*string{
		// 				},
		// 				AvailabilityZones: []*string{
		// 					to.Ptr("1"),
		// 					to.Ptr("2")},
		// 					SKU: &armstoragepool.SKU{
		// 						Name: to.Ptr("Standard"),
		// 						Tier: to.Ptr("Standard_V1"),
		// 					},
		// 			}},
		// 		}
	}
}

Output:

type DiskPoolZonesClientListOptions added in v0.2.0 

type DiskPoolZonesClientListOptions struct {
}

DiskPoolZonesClientListOptions contains the optional parameters for the DiskPoolZonesClient.NewListPager method.

type DiskPoolZonesClientListResponse added in v0.2.0 

type DiskPoolZonesClientListResponse struct {
	// List Disk Pool skus operation response.
	DiskPoolZoneListResult
}

DiskPoolZonesClientListResponse contains the response from method DiskPoolZonesClient.NewListPager.

type DiskPoolsClient 

type DiskPoolsClient struct {
	// contains filtered or unexported fields
}

DiskPoolsClient contains the methods for the DiskPools group. Don't use this type directly, use NewDiskPoolsClient() instead.

func NewDiskPoolsClient 

func NewDiskPoolsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*DiskPoolsClient, error)

NewDiskPoolsClient creates a new instance of DiskPoolsClient with the specified values.

  • subscriptionID - The ID of the target subscription.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*DiskPoolsClient) BeginCreateOrUpdate 

func (client *DiskPoolsClient) BeginCreateOrUpdate(ctx context.Context, resourceGroupName string, diskPoolName string, diskPoolCreatePayload DiskPoolCreate, options *DiskPoolsClientBeginCreateOrUpdateOptions) (*runtime.Poller[DiskPoolsClientCreateOrUpdateResponse], error)

BeginCreateOrUpdate - Create or Update Disk pool. This create or update operation can take 15 minutes to complete. This is expected service behavior. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2021-08-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • diskPoolName - The name of the Disk Pool.
  • diskPoolCreatePayload - Request payload for Disk Pool create operation
  • options - DiskPoolsClientBeginCreateOrUpdateOptions contains the optional parameters for the DiskPoolsClient.BeginCreateOrUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/storagepool/resource-manager/Microsoft.StoragePool/stable/2021-08-01/examples/DiskPools_Put.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storagepool/armstoragepool"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstoragepool.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewDiskPoolsClient().BeginCreateOrUpdate(ctx, "myResourceGroup", "myDiskPool", armstoragepool.DiskPoolCreate{
		Location: to.Ptr("westus"),
		Properties: &armstoragepool.DiskPoolCreateProperties{
			AvailabilityZones: []*string{
				to.Ptr("1")},
			Disks: []*armstoragepool.Disk{
				{
					ID: to.Ptr("/subscriptions/11111111-1111-1111-1111-111111111111/resourceGroups/myResourceGroup/providers/Microsoft.Compute/disks/vm-name_DataDisk_0"),
				},
				{
					ID: to.Ptr("/subscriptions/11111111-1111-1111-1111-111111111111/resourceGroups/myResourceGroup/providers/Microsoft.Compute/disks/vm-name_DataDisk_1"),
				}},
			SubnetID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/myvnet/subnets/mysubnet"),
		},
		SKU: &armstoragepool.SKU{
			Name: to.Ptr("Basic_V1"),
			Tier: to.Ptr("Basic"),
		},
		Tags: map[string]*string{
			"key": to.Ptr("value"),
		},
	}, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	res, err := poller.PollUntilDone(ctx, nil)
	if err != nil {
		log.Fatalf("failed to pull the result: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res.DiskPool = armstoragepool.DiskPool{
	// 	Name: to.Ptr("myDiskPool"),
	// 	Type: to.Ptr("Microsoft.StoragePool/diskPools"),
	// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/myResourceGroup/providers/Microsoft.StoragePool/diskPools/myDiskPool"),
	// 	Location: to.Ptr("westus2"),
	// 	Tags: map[string]*string{
	// 		"env": to.Ptr("int"),
	// 	},
	// 	ManagedBy: to.Ptr("/subscriptions/11111111-1111-1111-1111-111111111111/resourceGroups/myResourceGroup/providers/Microsoft.AVS/privateClouds/myPrivateCloud/clusters/Cluster-1/datastores/datastore1"),
	// 	ManagedByExtended: []*string{
	// 		to.Ptr("/subscriptions/11111111-1111-1111-1111-111111111111/resourceGroups/myResourceGroup/providers/Microsoft.AVS/privateClouds/myPrivateCloud/clusters/Cluster-1/datastores/datastore1"),
	// 		to.Ptr("/subscriptions/11111111-1111-1111-1111-111111111111/resourceGroups/myResourceGroup/providers/Microsoft.AVS/privateClouds/myPrivateCloud/clusters/Cluster-1/datastores/datastore2")},
	// 		Properties: &armstoragepool.DiskPoolProperties{
	// 			AvailabilityZones: []*string{
	// 				to.Ptr("1")},
	// 				Disks: []*armstoragepool.Disk{
	// 					{
	// 						ID: to.Ptr("/subscriptions/11111111-1111-1111-1111-111111111111/resourceGroups/myResourceGroup/providers/Microsoft.Compute/disks/vm-name_DataDisk_0"),
	// 					},
	// 					{
	// 						ID: to.Ptr("/subscriptions/11111111-1111-1111-1111-111111111111/resourceGroups/myResourceGroup/providers/Microsoft.Compute/disks/vm-name_DataDisk_1"),
	// 				}},
	// 				ProvisioningState: to.Ptr(armstoragepool.ProvisioningStatesSucceeded),
	// 				Status: to.Ptr(armstoragepool.OperationalStatusUnknown),
	// 				SubnetID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/myvnet/subnets/mysubnet"),
	// 			},
	// 			SKU: &armstoragepool.SKU{
	// 				Name: to.Ptr("Basic_0"),
	// 				Tier: to.Ptr("Basic"),
	// 			},
	// 			SystemData: &armstoragepool.SystemMetadata{
	// 				CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-06-24T06:53:57.000Z"); return t}()),
	// 				CreatedBy: to.Ptr("alias"),
	// 				CreatedByType: to.Ptr(armstoragepool.CreatedByTypeUser),
	// 				LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-06-24T06:53:57.000Z"); return t}()),
	// 				LastModifiedBy: to.Ptr("alias"),
	// 				LastModifiedByType: to.Ptr(armstoragepool.CreatedByTypeUser),
	// 			},
	// 		}
}

Output:

func (*DiskPoolsClient) BeginDeallocate 

func (client *DiskPoolsClient) BeginDeallocate(ctx context.Context, resourceGroupName string, diskPoolName string, options *DiskPoolsClientBeginDeallocateOptions) (*runtime.Poller[DiskPoolsClientDeallocateResponse], error)

BeginDeallocate - Shuts down the Disk Pool and releases the compute resources. You are not billed for the compute resources that this Disk Pool uses. This operation can take 10 minutes to complete. This is expected service behavior. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2021-08-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • diskPoolName - The name of the Disk Pool.
  • options - DiskPoolsClientBeginDeallocateOptions contains the optional parameters for the DiskPoolsClient.BeginDeallocate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/storagepool/resource-manager/Microsoft.StoragePool/stable/2021-08-01/examples/DiskPools_Deallocate.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storagepool/armstoragepool"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstoragepool.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewDiskPoolsClient().BeginDeallocate(ctx, "myResourceGroup", "myDiskPool", nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	_, err = poller.PollUntilDone(ctx, nil)
	if err != nil {
		log.Fatalf("failed to pull the result: %v", err)
	}
}

Output:

func (*DiskPoolsClient) BeginDelete 

func (client *DiskPoolsClient) BeginDelete(ctx context.Context, resourceGroupName string, diskPoolName string, options *DiskPoolsClientBeginDeleteOptions) (*runtime.Poller[DiskPoolsClientDeleteResponse], error)

BeginDelete - Delete a Disk pool; attached disks are not affected. This delete operation can take 10 minutes to complete. This is expected service behavior. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2021-08-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • diskPoolName - The name of the Disk Pool.
  • options - DiskPoolsClientBeginDeleteOptions contains the optional parameters for the DiskPoolsClient.BeginDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/storagepool/resource-manager/Microsoft.StoragePool/stable/2021-08-01/examples/DiskPools_Delete.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storagepool/armstoragepool"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstoragepool.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewDiskPoolsClient().BeginDelete(ctx, "myResourceGroup", "myDiskPool", nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	_, err = poller.PollUntilDone(ctx, nil)
	if err != nil {
		log.Fatalf("failed to pull the result: %v", err)
	}
}

Output:

func (*DiskPoolsClient) BeginStart 

func (client *DiskPoolsClient) BeginStart(ctx context.Context, resourceGroupName string, diskPoolName string, options *DiskPoolsClientBeginStartOptions) (*runtime.Poller[DiskPoolsClientStartResponse], error)

BeginStart - The operation to start a Disk Pool. This start operation can take 10 minutes to complete. This is expected service behavior. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2021-08-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • diskPoolName - The name of the Disk Pool.
  • options - DiskPoolsClientBeginStartOptions contains the optional parameters for the DiskPoolsClient.BeginStart method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/storagepool/resource-manager/Microsoft.StoragePool/stable/2021-08-01/examples/DiskPools_Start.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storagepool/armstoragepool"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstoragepool.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewDiskPoolsClient().BeginStart(ctx, "myResourceGroup", "myDiskPool", nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	_, err = poller.PollUntilDone(ctx, nil)
	if err != nil {
		log.Fatalf("failed to pull the result: %v", err)
	}
}

Output:

func (*DiskPoolsClient) BeginUpdate 

func (client *DiskPoolsClient) BeginUpdate(ctx context.Context, resourceGroupName string, diskPoolName string, diskPoolUpdatePayload DiskPoolUpdate, options *DiskPoolsClientBeginUpdateOptions) (*runtime.Poller[DiskPoolsClientUpdateResponse], error)

BeginUpdate - Update a Disk pool. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2021-08-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • diskPoolName - The name of the Disk Pool.
  • diskPoolUpdatePayload - Request payload for Disk Pool update operation.
  • options - DiskPoolsClientBeginUpdateOptions contains the optional parameters for the DiskPoolsClient.BeginUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/storagepool/resource-manager/Microsoft.StoragePool/stable/2021-08-01/examples/DiskPools_Patch.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storagepool/armstoragepool"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstoragepool.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewDiskPoolsClient().BeginUpdate(ctx, "myResourceGroup", "myDiskPool", armstoragepool.DiskPoolUpdate{
		Properties: &armstoragepool.DiskPoolUpdateProperties{
			Disks: []*armstoragepool.Disk{
				{
					ID: to.Ptr("/subscriptions/11111111-1111-1111-1111-111111111111/resourceGroups/myResourceGroup/providers/Microsoft.Compute/disks/vm-name_DataDisk_0"),
				},
				{
					ID: to.Ptr("/subscriptions/11111111-1111-1111-1111-111111111111/resourceGroups/myResourceGroup/providers/Microsoft.Compute/disks/vm-name_DataDisk_1"),
				}},
		},
		SKU: &armstoragepool.SKU{
			Name: to.Ptr("Basic_B1"),
			Tier: to.Ptr("Basic"),
		},
		Tags: map[string]*string{
			"key": to.Ptr("value"),
		},
	}, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	res, err := poller.PollUntilDone(ctx, nil)
	if err != nil {
		log.Fatalf("failed to pull the result: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res.DiskPool = armstoragepool.DiskPool{
	// 	Name: to.Ptr("myDiskPool"),
	// 	Type: to.Ptr("Microsoft.StoragePool/diskPools"),
	// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/myResourceGroup/providers/Microsoft.StoragePool/diskPools/myDiskPool"),
	// 	Location: to.Ptr("westus2"),
	// 	Tags: map[string]*string{
	// 		"env": to.Ptr("int"),
	// 	},
	// 	ManagedBy: to.Ptr("/subscriptions/11111111-1111-1111-1111-111111111111/resourceGroups/myResourceGroup/providers/Microsoft.AVS/privateClouds/myPrivateCloud/clusters/Cluster-1/datastores/datastore1"),
	// 	ManagedByExtended: []*string{
	// 		to.Ptr("/subscriptions/11111111-1111-1111-1111-111111111111/resourceGroups/myResourceGroup/providers/Microsoft.AVS/privateClouds/myPrivateCloud/clusters/Cluster-1/datastores/datastore1"),
	// 		to.Ptr("/subscriptions/11111111-1111-1111-1111-111111111111/resourceGroups/myResourceGroup/providers/Microsoft.AVS/privateClouds/myPrivateCloud/clusters/Cluster-1/datastores/datastore2")},
	// 		Properties: &armstoragepool.DiskPoolProperties{
	// 			AvailabilityZones: []*string{
	// 				to.Ptr("1")},
	// 				Disks: []*armstoragepool.Disk{
	// 					{
	// 						ID: to.Ptr("/subscriptions/11111111-1111-1111-1111-111111111111/resourceGroups/myResourceGroup/providers/Microsoft.Compute/disks/vm-name_DataDisk_0"),
	// 					},
	// 					{
	// 						ID: to.Ptr("/subscriptions/11111111-1111-1111-1111-111111111111/resourceGroups/myResourceGroup/providers/Microsoft.Compute/disks/vm-name_DataDisk_1"),
	// 				}},
	// 				ProvisioningState: to.Ptr(armstoragepool.ProvisioningStatesSucceeded),
	// 				Status: to.Ptr(armstoragepool.OperationalStatusUnknown),
	// 				SubnetID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/myvnet/subnets/mysubnet"),
	// 			},
	// 			SKU: &armstoragepool.SKU{
	// 				Name: to.Ptr("Basic_V1"),
	// 				Tier: to.Ptr("Basic"),
	// 			},
	// 			SystemData: &armstoragepool.SystemMetadata{
	// 				CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-06-24T06:53:57.000Z"); return t}()),
	// 				CreatedBy: to.Ptr("alias"),
	// 				CreatedByType: to.Ptr(armstoragepool.CreatedByTypeUser),
	// 				LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-06-24T06:53:57.000Z"); return t}()),
	// 				LastModifiedBy: to.Ptr("alias"),
	// 				LastModifiedByType: to.Ptr(armstoragepool.CreatedByTypeUser),
	// 			},
	// 		}
}

Output:

func (*DiskPoolsClient) BeginUpgrade 

func (client *DiskPoolsClient) BeginUpgrade(ctx context.Context, resourceGroupName string, diskPoolName string, options *DiskPoolsClientBeginUpgradeOptions) (*runtime.Poller[DiskPoolsClientUpgradeResponse], error)

BeginUpgrade - Upgrade replaces the underlying virtual machine hosts one at a time. This operation can take 10-15 minutes to complete. This is expected service behavior. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2021-08-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • diskPoolName - The name of the Disk Pool.
  • options - DiskPoolsClientBeginUpgradeOptions contains the optional parameters for the DiskPoolsClient.BeginUpgrade method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/storagepool/resource-manager/Microsoft.StoragePool/stable/2021-08-01/examples/DiskPools_Upgrade.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storagepool/armstoragepool"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstoragepool.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewDiskPoolsClient().BeginUpgrade(ctx, "myResourceGroup", "myDiskPool", nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	_, err = poller.PollUntilDone(ctx, nil)
	if err != nil {
		log.Fatalf("failed to pull the result: %v", err)
	}
}

Output:

func (*DiskPoolsClient) Get 

func (client *DiskPoolsClient) Get(ctx context.Context, resourceGroupName string, diskPoolName string, options *DiskPoolsClientGetOptions) (DiskPoolsClientGetResponse, error)

Get - Get a Disk pool. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2021-08-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • diskPoolName - The name of the Disk Pool.
  • options - DiskPoolsClientGetOptions contains the optional parameters for the DiskPoolsClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/storagepool/resource-manager/Microsoft.StoragePool/stable/2021-08-01/examples/DiskPools_Get.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storagepool/armstoragepool"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstoragepool.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewDiskPoolsClient().Get(ctx, "myResourceGroup", "myDiskPool", nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res.DiskPool = armstoragepool.DiskPool{
	// 	Name: to.Ptr("myDiskPool"),
	// 	Type: to.Ptr("Microsoft.StoragePool/diskPools"),
	// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/myResourceGroup/providers/Microsoft.StoragePool/diskPools/myDiskPool"),
	// 	Location: to.Ptr("westus2"),
	// 	Tags: map[string]*string{
	// 		"env": to.Ptr("int"),
	// 	},
	// 	ManagedBy: to.Ptr("/subscriptions/11111111-1111-1111-1111-111111111111/resourceGroups/myResourceGroup/providers/Microsoft.AVS/privateClouds/myPrivateCloud/clusters/Cluster-1/datastores/datastore1"),
	// 	ManagedByExtended: []*string{
	// 		to.Ptr("/subscriptions/11111111-1111-1111-1111-111111111111/resourceGroups/myResourceGroup/providers/Microsoft.AVS/privateClouds/myPrivateCloud/clusters/Cluster-1/datastores/datastore1"),
	// 		to.Ptr("/subscriptions/11111111-1111-1111-1111-111111111111/resourceGroups/myResourceGroup/providers/Microsoft.AVS/privateClouds/myPrivateCloud/clusters/Cluster-1/datastores/datastore2")},
	// 		Properties: &armstoragepool.DiskPoolProperties{
	// 			AvailabilityZones: []*string{
	// 				to.Ptr("1")},
	// 				Disks: []*armstoragepool.Disk{
	// 					{
	// 						ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/myResourceGroup/providers/Microsoft.Compute/disks/myDataDisk_0"),
	// 				}},
	// 				ProvisioningState: to.Ptr(armstoragepool.ProvisioningStatesSucceeded),
	// 				Status: to.Ptr(armstoragepool.OperationalStatusHealthy),
	// 				SubnetID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/myvnet/subnets/mysubnet"),
	// 			},
	// 			SKU: &armstoragepool.SKU{
	// 				Name: to.Ptr("Basic_V1"),
	// 				Tier: to.Ptr("Basic"),
	// 			},
	// 			SystemData: &armstoragepool.SystemMetadata{
	// 				CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-06-24T06:53:57.000Z"); return t}()),
	// 				CreatedBy: to.Ptr("alias"),
	// 				CreatedByType: to.Ptr(armstoragepool.CreatedByTypeUser),
	// 				LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-06-24T06:53:57.000Z"); return t}()),
	// 				LastModifiedBy: to.Ptr("alias"),
	// 				LastModifiedByType: to.Ptr(armstoragepool.CreatedByTypeUser),
	// 			},
	// 		}
}

Output:

func (*DiskPoolsClient) NewListByResourceGroupPager added in v0.4.0 

func (client *DiskPoolsClient) NewListByResourceGroupPager(resourceGroupName string, options *DiskPoolsClientListByResourceGroupOptions) *runtime.Pager[DiskPoolsClientListByResourceGroupResponse]

NewListByResourceGroupPager - Gets a list of DiskPools in a resource group.

Generated from API version 2021-08-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • options - DiskPoolsClientListByResourceGroupOptions contains the optional parameters for the DiskPoolsClient.NewListByResourceGroupPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/storagepool/resource-manager/Microsoft.StoragePool/stable/2021-08-01/examples/DiskPools_ListByResourceGroup.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storagepool/armstoragepool"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstoragepool.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewDiskPoolsClient().NewListByResourceGroupPager("myResourceGroup", nil)
	for pager.More() {
		page, err := pager.NextPage(ctx)
		if err != nil {
			log.Fatalf("failed to advance page: %v", err)
		}
		for _, v := range page.Value {
			// You could use page here. We use blank identifier for just demo purposes.
			_ = v
		}
		// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
		// page.DiskPoolListResult = armstoragepool.DiskPoolListResult{
		// 	Value: []*armstoragepool.DiskPool{
		// 		{
		// 			Name: to.Ptr("myDiskPool"),
		// 			Type: to.Ptr("Microsoft.StoragePool/diskPools"),
		// 			ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/myResourceGroup/providers/Microsoft.StoragePool/diskPools/myDiskPool"),
		// 			Location: to.Ptr("westus2"),
		// 			Tags: map[string]*string{
		// 				"env": to.Ptr("int"),
		// 			},
		// 			ManagedBy: to.Ptr("/subscriptions/11111111-1111-1111-1111-111111111111/resourceGroups/myResourceGroup/providers/Microsoft.AVS/privateClouds/myPrivateCloud/clusters/Cluster-1/datastores/datastore1"),
		// 			ManagedByExtended: []*string{
		// 				to.Ptr("/subscriptions/11111111-1111-1111-1111-111111111111/resourceGroups/myResourceGroup/providers/Microsoft.AVS/privateClouds/myPrivateCloud/clusters/Cluster-1/datastores/datastore1"),
		// 				to.Ptr("/subscriptions/11111111-1111-1111-1111-111111111111/resourceGroups/myResourceGroup/providers/Microsoft.AVS/privateClouds/myPrivateCloud/clusters/Cluster-1/datastores/datastore2")},
		// 				Properties: &armstoragepool.DiskPoolProperties{
		// 					AvailabilityZones: []*string{
		// 						to.Ptr("1")},
		// 						Disks: []*armstoragepool.Disk{
		// 							{
		// 								ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/myResourceGroup/providers/Microsoft.Compute/disks/myDataDisk_0"),
		// 						}},
		// 						ProvisioningState: to.Ptr(armstoragepool.ProvisioningStatesSucceeded),
		// 						Status: to.Ptr(armstoragepool.OperationalStatusUnknown),
		// 						SubnetID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/myvnet/subnets/mysubnet"),
		// 					},
		// 					SKU: &armstoragepool.SKU{
		// 						Name: to.Ptr("Basic_V1"),
		// 						Tier: to.Ptr("Basic"),
		// 					},
		// 					SystemData: &armstoragepool.SystemMetadata{
		// 						CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-06-24T06:53:57.000Z"); return t}()),
		// 						CreatedBy: to.Ptr("alias"),
		// 						CreatedByType: to.Ptr(armstoragepool.CreatedByTypeUser),
		// 						LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-06-24T06:53:57.000Z"); return t}()),
		// 						LastModifiedBy: to.Ptr("alias"),
		// 						LastModifiedByType: to.Ptr(armstoragepool.CreatedByTypeUser),
		// 					},
		// 				},
		// 				{
		// 					Name: to.Ptr("myDiskPool2"),
		// 					Type: to.Ptr("Microsoft.StoragePool/diskPools"),
		// 					ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/myResourceGroup/providers/Microsoft.StoragePool/diskPools/myDiskPool2"),
		// 					Location: to.Ptr("westus2"),
		// 					Tags: map[string]*string{
		// 						"env": to.Ptr("int"),
		// 					},
		// 					ManagedBy: to.Ptr("/subscriptions/11111111-1111-1111-1111-111111111111/resourceGroups/myResourceGroup/providers/Microsoft.AVS/privateClouds/myPrivateCloud/clusters/Cluster-1/datastores/datastore1"),
		// 					ManagedByExtended: []*string{
		// 						to.Ptr("/subscriptions/11111111-1111-1111-1111-111111111111/resourceGroups/myResourceGroup/providers/Microsoft.AVS/privateClouds/myPrivateCloud/clusters/Cluster-1/datastores/datastore1"),
		// 						to.Ptr("/subscriptions/11111111-1111-1111-1111-111111111111/resourceGroups/myResourceGroup/providers/Microsoft.AVS/privateClouds/myPrivateCloud/clusters/Cluster-1/datastores/datastore2")},
		// 						Properties: &armstoragepool.DiskPoolProperties{
		// 							AvailabilityZones: []*string{
		// 								to.Ptr("1")},
		// 								Disks: []*armstoragepool.Disk{
		// 									{
		// 										ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/myResourceGroup/providers/Microsoft.Compute/disks/myDataDisk_0"),
		// 								}},
		// 								ProvisioningState: to.Ptr(armstoragepool.ProvisioningStatesSucceeded),
		// 								Status: to.Ptr(armstoragepool.OperationalStatusUnknown),
		// 								SubnetID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/myvnet/subnets/mysubnet"),
		// 							},
		// 							SKU: &armstoragepool.SKU{
		// 								Name: to.Ptr("Basic_V1"),
		// 								Tier: to.Ptr("Basic"),
		// 							},
		// 							SystemData: &armstoragepool.SystemMetadata{
		// 								CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-06-24T06:53:57.000Z"); return t}()),
		// 								CreatedBy: to.Ptr("alias"),
		// 								CreatedByType: to.Ptr(armstoragepool.CreatedByTypeUser),
		// 								LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-06-24T06:53:57.000Z"); return t}()),
		// 								LastModifiedBy: to.Ptr("alias"),
		// 								LastModifiedByType: to.Ptr(armstoragepool.CreatedByTypeUser),
		// 							},
		// 					}},
		// 				}
	}
}

Output:

func (*DiskPoolsClient) NewListBySubscriptionPager added in v0.4.0 

func (client *DiskPoolsClient) NewListBySubscriptionPager(options *DiskPoolsClientListBySubscriptionOptions) *runtime.Pager[DiskPoolsClientListBySubscriptionResponse]

NewListBySubscriptionPager - Gets a list of Disk Pools in a subscription

Generated from API version 2021-08-01

  • options - DiskPoolsClientListBySubscriptionOptions contains the optional parameters for the DiskPoolsClient.NewListBySubscriptionPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/storagepool/resource-manager/Microsoft.StoragePool/stable/2021-08-01/examples/DiskPools_ListBySubscription.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storagepool/armstoragepool"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstoragepool.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewDiskPoolsClient().NewListBySubscriptionPager(nil)
	for pager.More() {
		page, err := pager.NextPage(ctx)
		if err != nil {
			log.Fatalf("failed to advance page: %v", err)
		}
		for _, v := range page.Value {
			// You could use page here. We use blank identifier for just demo purposes.
			_ = v
		}
		// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
		// page.DiskPoolListResult = armstoragepool.DiskPoolListResult{
		// 	Value: []*armstoragepool.DiskPool{
		// 		{
		// 			Name: to.Ptr("myDiskPool"),
		// 			Type: to.Ptr("Microsoft.StoragePool/diskPools"),
		// 			ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/myResourceGroup/providers/Microsoft.StoragePool/diskPools/myDiskPool"),
		// 			Location: to.Ptr("westus2"),
		// 			Tags: map[string]*string{
		// 				"env": to.Ptr("int"),
		// 			},
		// 			ManagedBy: to.Ptr("/subscriptions/11111111-1111-1111-1111-111111111111/resourceGroups/myResourceGroup/providers/Microsoft.AVS/privateClouds/myPrivateCloud/clusters/Cluster-1/datastores/datastore1"),
		// 			ManagedByExtended: []*string{
		// 				to.Ptr("/subscriptions/11111111-1111-1111-1111-111111111111/resourceGroups/myResourceGroup/providers/Microsoft.AVS/privateClouds/myPrivateCloud/clusters/Cluster-1/datastores/datastore1"),
		// 				to.Ptr("/subscriptions/11111111-1111-1111-1111-111111111111/resourceGroups/myResourceGroup/providers/Microsoft.AVS/privateClouds/myPrivateCloud/clusters/Cluster-1/datastores/datastore2")},
		// 				Properties: &armstoragepool.DiskPoolProperties{
		// 					AvailabilityZones: []*string{
		// 						to.Ptr("1")},
		// 						Disks: []*armstoragepool.Disk{
		// 							{
		// 								ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/myResourceGroup/providers/Microsoft.Compute/disks/myDataDisk_0"),
		// 						}},
		// 						ProvisioningState: to.Ptr(armstoragepool.ProvisioningStatesSucceeded),
		// 						Status: to.Ptr(armstoragepool.OperationalStatusHealthy),
		// 						SubnetID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/myvnet/subnets/mysubnet"),
		// 					},
		// 					SKU: &armstoragepool.SKU{
		// 						Name: to.Ptr("Basic_V1"),
		// 						Tier: to.Ptr("Basic"),
		// 					},
		// 					SystemData: &armstoragepool.SystemMetadata{
		// 						CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-06-24T06:53:57.000Z"); return t}()),
		// 						CreatedBy: to.Ptr("alias"),
		// 						CreatedByType: to.Ptr(armstoragepool.CreatedByTypeUser),
		// 						LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-06-24T06:53:57.000Z"); return t}()),
		// 						LastModifiedBy: to.Ptr("alias"),
		// 						LastModifiedByType: to.Ptr(armstoragepool.CreatedByTypeUser),
		// 					},
		// 				},
		// 				{
		// 					Name: to.Ptr("myDiskPool2"),
		// 					Type: to.Ptr("Microsoft.StoragePool/diskPools"),
		// 					ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/myResourceGroup/providers/Microsoft.StoragePool/diskPools/myDiskPool2"),
		// 					Location: to.Ptr("westus2"),
		// 					Tags: map[string]*string{
		// 						"env": to.Ptr("int"),
		// 					},
		// 					ManagedBy: to.Ptr("/subscriptions/11111111-1111-1111-1111-111111111111/resourceGroups/myResourceGroup/providers/Microsoft.AVS/privateClouds/myPrivateCloud/clusters/Cluster-1/datastores/datastore1"),
		// 					ManagedByExtended: []*string{
		// 						to.Ptr("/subscriptions/11111111-1111-1111-1111-111111111111/resourceGroups/myResourceGroup/providers/Microsoft.AVS/privateClouds/myPrivateCloud/clusters/Cluster-1/datastores/datastore1"),
		// 						to.Ptr("/subscriptions/11111111-1111-1111-1111-111111111111/resourceGroups/myResourceGroup/providers/Microsoft.AVS/privateClouds/myPrivateCloud/clusters/Cluster-1/datastores/datastore2")},
		// 						Properties: &armstoragepool.DiskPoolProperties{
		// 							AvailabilityZones: []*string{
		// 								to.Ptr("1")},
		// 								Disks: []*armstoragepool.Disk{
		// 									{
		// 										ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/myResourceGroup/providers/Microsoft.Compute/disks/myDataDisk_0"),
		// 								}},
		// 								ProvisioningState: to.Ptr(armstoragepool.ProvisioningStatesSucceeded),
		// 								Status: to.Ptr(armstoragepool.OperationalStatusHealthy),
		// 								SubnetID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/myvnet/subnets/mysubnet"),
		// 							},
		// 							SKU: &armstoragepool.SKU{
		// 								Name: to.Ptr("Basic_V1"),
		// 								Tier: to.Ptr("Basic"),
		// 							},
		// 							SystemData: &armstoragepool.SystemMetadata{
		// 								CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-06-24T06:53:57.000Z"); return t}()),
		// 								CreatedBy: to.Ptr("alias"),
		// 								CreatedByType: to.Ptr(armstoragepool.CreatedByTypeUser),
		// 								LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-06-24T06:53:57.000Z"); return t}()),
		// 								LastModifiedBy: to.Ptr("alias"),
		// 								LastModifiedByType: to.Ptr(armstoragepool.CreatedByTypeUser),
		// 							},
		// 					}},
		// 				}
	}
}

Output:

func (*DiskPoolsClient) NewListOutboundNetworkDependenciesEndpointsPager added in v0.4.0 

func (client *DiskPoolsClient) NewListOutboundNetworkDependenciesEndpointsPager(resourceGroupName string, diskPoolName string, options *DiskPoolsClientListOutboundNetworkDependenciesEndpointsOptions) *runtime.Pager[DiskPoolsClientListOutboundNetworkDependenciesEndpointsResponse]

NewListOutboundNetworkDependenciesEndpointsPager - Gets the network endpoints of all outbound dependencies of a Disk Pool

Generated from API version 2021-08-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • diskPoolName - The name of the Disk Pool.
  • options - DiskPoolsClientListOutboundNetworkDependenciesEndpointsOptions contains the optional parameters for the DiskPoolsClient.NewListOutboundNetworkDependenciesEndpointsPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/storagepool/resource-manager/Microsoft.StoragePool/stable/2021-08-01/examples/DiskPools_GetOutboundNetworkDependencies.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storagepool/armstoragepool"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstoragepool.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewDiskPoolsClient().NewListOutboundNetworkDependenciesEndpointsPager("Sample-WestUSResourceGroup", "SampleAse", nil)
	for pager.More() {
		page, err := pager.NextPage(ctx)
		if err != nil {
			log.Fatalf("failed to advance page: %v", err)
		}
		for _, v := range page.Value {
			// You could use page here. We use blank identifier for just demo purposes.
			_ = v
		}
		// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
		// page.OutboundEnvironmentEndpointList = armstoragepool.OutboundEnvironmentEndpointList{
		// 	Value: []*armstoragepool.OutboundEnvironmentEndpoint{
		// 		{
		// 			Category: to.Ptr("Azure Storage"),
		// 			Endpoints: []*armstoragepool.EndpointDependency{
		// 				{
		// 					DomainName: to.Ptr("blob.core.windows.net"),
		// 					EndpointDetails: []*armstoragepool.EndpointDetail{
		// 						{
		// 							IPAddress: to.Ptr("52.183.104.36"),
		// 							IsAccessible: to.Ptr(true),
		// 							Latency: to.Ptr[float64](42.0469),
		// 							Port: to.Ptr[int32](80),
		// 						},
		// 						{
		// 							IPAddress: to.Ptr("52.183.104.36"),
		// 							IsAccessible: to.Ptr(true),
		// 							Latency: to.Ptr[float64](41.7038),
		// 							Port: to.Ptr[int32](443),
		// 					}},
		// 				},
		// 				{
		// 					DomainName: to.Ptr("queue.core.windows.net"),
		// 					EndpointDetails: []*armstoragepool.EndpointDetail{
		// 						{
		// 							IPAddress: to.Ptr("52.183.104.25"),
		// 							IsAccessible: to.Ptr(true),
		// 							Latency: to.Ptr[float64](37.326),
		// 							Port: to.Ptr[int32](80),
		// 						},
		// 						{
		// 							IPAddress: to.Ptr("52.183.104.25"),
		// 							IsAccessible: to.Ptr(true),
		// 							Latency: to.Ptr[float64](37.513600000000004),
		// 							Port: to.Ptr[int32](443),
		// 					}},
		// 				},
		// 				{
		// 					DomainName: to.Ptr("table.core.windows.net"),
		// 					EndpointDetails: []*armstoragepool.EndpointDetail{
		// 						{
		// 							IPAddress: to.Ptr("52.183.104.26"),
		// 							IsAccessible: to.Ptr(true),
		// 							Latency: to.Ptr[float64](32.789),
		// 							Port: to.Ptr[int32](80),
		// 						},
		// 						{
		// 							IPAddress: to.Ptr("52.183.104.26"),
		// 							IsAccessible: to.Ptr(true),
		// 							Latency: to.Ptr[float64](1.8702),
		// 							Port: to.Ptr[int32](443),
		// 					}},
		// 				},
		// 				{
		// 					DomainName: to.Ptr("file.core.windows.net"),
		// 					EndpointDetails: []*armstoragepool.EndpointDetail{
		// 						{
		// 							IPAddress: to.Ptr("52.183.104.28"),
		// 							IsAccessible: to.Ptr(true),
		// 							Latency: to.Ptr[float64](36.7378),
		// 							Port: to.Ptr[int32](80),
		// 						},
		// 						{
		// 							IPAddress: to.Ptr("52.183.104.28"),
		// 							IsAccessible: to.Ptr(true),
		// 							Latency: to.Ptr[float64](36.7108),
		// 							Port: to.Ptr[int32](443),
		// 					}},
		// 				},
		// 				{
		// 					DomainName: to.Ptr("blob.core.windows.net"),
		// 					EndpointDetails: []*armstoragepool.EndpointDetail{
		// 						{
		// 							IPAddress: to.Ptr("13.77.184.64"),
		// 							IsAccessible: to.Ptr(true),
		// 							Latency: to.Ptr[float64](4.0261000000000005),
		// 							Port: to.Ptr[int32](80),
		// 						},
		// 						{
		// 							IPAddress: to.Ptr("13.77.184.64"),
		// 							IsAccessible: to.Ptr(true),
		// 							Latency: to.Ptr[float64](3.8264),
		// 							Port: to.Ptr[int32](443),
		// 					}},
		// 				},
		// 				{
		// 					DomainName: to.Ptr("queue.core.windows.net"),
		// 					EndpointDetails: []*armstoragepool.EndpointDetail{
		// 						{
		// 							IPAddress: to.Ptr("13.77.184.73"),
		// 							IsAccessible: to.Ptr(true),
		// 							Latency: to.Ptr[float64](40.8523),
		// 							Port: to.Ptr[int32](80),
		// 						},
		// 						{
		// 							IPAddress: to.Ptr("13.77.184.73"),
		// 							IsAccessible: to.Ptr(true),
		// 							Latency: to.Ptr[float64](40.7501),
		// 							Port: to.Ptr[int32](443),
		// 					}},
		// 				},
		// 				{
		// 					DomainName: to.Ptr("table.core.windows.net"),
		// 					EndpointDetails: []*armstoragepool.EndpointDetail{
		// 						{
		// 							IPAddress: to.Ptr("13.77.184.74"),
		// 							IsAccessible: to.Ptr(true),
		// 							Latency: to.Ptr[float64](1.2071),
		// 							Port: to.Ptr[int32](80),
		// 						},
		// 						{
		// 							IPAddress: to.Ptr("13.77.184.74"),
		// 							IsAccessible: to.Ptr(true),
		// 							Latency: to.Ptr[float64](38.2975),
		// 							Port: to.Ptr[int32](443),
		// 					}},
		// 				},
		// 				{
		// 					DomainName: to.Ptr("file.core.windows.net"),
		// 					EndpointDetails: []*armstoragepool.EndpointDetail{
		// 						{
		// 							IPAddress: to.Ptr("13.77.184.76"),
		// 							IsAccessible: to.Ptr(true),
		// 							Latency: to.Ptr[float64](59.383700000000005),
		// 							Port: to.Ptr[int32](80),
		// 						},
		// 						{
		// 							IPAddress: to.Ptr("13.77.184.76"),
		// 							IsAccessible: to.Ptr(true),
		// 							Latency: to.Ptr[float64](60.0775),
		// 							Port: to.Ptr[int32](443),
		// 					}},
		// 				},
		// 				{
		// 					DomainName: to.Ptr("blob.core.windows.net"),
		// 					EndpointDetails: []*armstoragepool.EndpointDetail{
		// 						{
		// 							IPAddress: to.Ptr("13.77.184.64"),
		// 							IsAccessible: to.Ptr(true),
		// 							Latency: to.Ptr[float64](3.5512),
		// 							Port: to.Ptr[int32](80),
		// 						},
		// 						{
		// 							IPAddress: to.Ptr("13.77.184.64"),
		// 							IsAccessible: to.Ptr(true),
		// 							Latency: to.Ptr[float64](2.6777),
		// 							Port: to.Ptr[int32](443),
		// 					}},
		// 				},
		// 				{
		// 					DomainName: to.Ptr("queue.core.windows.net"),
		// 					EndpointDetails: []*armstoragepool.EndpointDetail{
		// 						{
		// 							IPAddress: to.Ptr("13.77.184.73"),
		// 							IsAccessible: to.Ptr(true),
		// 							Latency: to.Ptr[float64](3.5204),
		// 							Port: to.Ptr[int32](80),
		// 						},
		// 						{
		// 							IPAddress: to.Ptr("13.77.184.73"),
		// 							IsAccessible: to.Ptr(true),
		// 							Latency: to.Ptr[float64](2.8193),
		// 							Port: to.Ptr[int32](443),
		// 					}},
		// 				},
		// 				{
		// 					DomainName: to.Ptr("table.core.windows.net"),
		// 					EndpointDetails: []*armstoragepool.EndpointDetail{
		// 						{
		// 							IPAddress: to.Ptr("13.77.184.74"),
		// 							IsAccessible: to.Ptr(true),
		// 							Latency: to.Ptr[float64](3.2720000000000002),
		// 							Port: to.Ptr[int32](80),
		// 						},
		// 						{
		// 							IPAddress: to.Ptr("13.77.184.74"),
		// 							IsAccessible: to.Ptr(true),
		// 							Latency: to.Ptr[float64](3.0147),
		// 							Port: to.Ptr[int32](443),
		// 					}},
		// 				},
		// 				{
		// 					DomainName: to.Ptr("file.core.windows.net"),
		// 					EndpointDetails: []*armstoragepool.EndpointDetail{
		// 						{
		// 							IPAddress: to.Ptr("13.77.184.76"),
		// 							IsAccessible: to.Ptr(true),
		// 							Latency: to.Ptr[float64](3.2387),
		// 							Port: to.Ptr[int32](80),
		// 						},
		// 						{
		// 							IPAddress: to.Ptr("13.77.184.76"),
		// 							IsAccessible: to.Ptr(true),
		// 							Latency: to.Ptr[float64](3.2804),
		// 							Port: to.Ptr[int32](443),
		// 					}},
		// 				},
		// 				{
		// 					DomainName: to.Ptr("blob.core.windows.net"),
		// 					EndpointDetails: []*armstoragepool.EndpointDetail{
		// 						{
		// 							IPAddress: to.Ptr("13.66.176.16"),
		// 							IsAccessible: to.Ptr(true),
		// 							Latency: to.Ptr[float64](43.025200000000005),
		// 							Port: to.Ptr[int32](80),
		// 						},
		// 						{
		// 							IPAddress: to.Ptr("13.66.176.16"),
		// 							IsAccessible: to.Ptr(true),
		// 							Latency: to.Ptr[float64](43.1683),
		// 							Port: to.Ptr[int32](443),
		// 					}},
		// 				},
		// 				{
		// 					DomainName: to.Ptr("queue.core.windows.net"),
		// 					EndpointDetails: []*armstoragepool.EndpointDetail{
		// 						{
		// 							IPAddress: to.Ptr("13.66.176.25"),
		// 							IsAccessible: to.Ptr(true),
		// 							Latency: to.Ptr[float64](41.8598),
		// 							Port: to.Ptr[int32](80),
		// 						},
		// 						{
		// 							IPAddress: to.Ptr("13.66.176.25"),
		// 							IsAccessible: to.Ptr(true),
		// 							Latency: to.Ptr[float64](41.9805),
		// 							Port: to.Ptr[int32](443),
		// 					}},
		// 				},
		// 				{
		// 					DomainName: to.Ptr("table.core.windows.net"),
		// 					EndpointDetails: []*armstoragepool.EndpointDetail{
		// 						{
		// 							IPAddress: to.Ptr("13.66.176.26"),
		// 							IsAccessible: to.Ptr(true),
		// 							Latency: to.Ptr[float64](30.542900000000003),
		// 							Port: to.Ptr[int32](80),
		// 						},
		// 						{
		// 							IPAddress: to.Ptr("13.66.176.26"),
		// 							IsAccessible: to.Ptr(true),
		// 							Latency: to.Ptr[float64](0.9832000000000001),
		// 							Port: to.Ptr[int32](443),
		// 					}},
		// 				},
		// 				{
		// 					DomainName: to.Ptr("file.core.windows.net"),
		// 					EndpointDetails: []*armstoragepool.EndpointDetail{
		// 						{
		// 							IPAddress: to.Ptr("13.66.176.28"),
		// 							IsAccessible: to.Ptr(true),
		// 							Latency: to.Ptr[float64](35.9562),
		// 							Port: to.Ptr[int32](80),
		// 						},
		// 						{
		// 							IPAddress: to.Ptr("13.66.176.28"),
		// 							IsAccessible: to.Ptr(true),
		// 							Latency: to.Ptr[float64](36.0643),
		// 							Port: to.Ptr[int32](443),
		// 					}},
		// 				},
		// 				{
		// 					DomainName: to.Ptr("blob.core.windows.net"),
		// 					EndpointDetails: []*armstoragepool.EndpointDetail{
		// 						{
		// 							IPAddress: to.Ptr("13.77.184.64"),
		// 							IsAccessible: to.Ptr(true),
		// 							Latency: to.Ptr[float64](3.2829),
		// 							Port: to.Ptr[int32](80),
		// 						},
		// 						{
		// 							IPAddress: to.Ptr("13.77.184.64"),
		// 							IsAccessible: to.Ptr(true),
		// 							Latency: to.Ptr[float64](2.3393),
		// 							Port: to.Ptr[int32](443),
		// 					}},
		// 				},
		// 				{
		// 					DomainName: to.Ptr("queue.core.windows.net"),
		// 					EndpointDetails: []*armstoragepool.EndpointDetail{
		// 						{
		// 							IPAddress: to.Ptr("13.77.184.73"),
		// 							IsAccessible: to.Ptr(true),
		// 							Latency: to.Ptr[float64](3.4103000000000003),
		// 							Port: to.Ptr[int32](80),
		// 						},
		// 						{
		// 							IPAddress: to.Ptr("13.77.184.73"),
		// 							IsAccessible: to.Ptr(true),
		// 							Latency: to.Ptr[float64](4.1032),
		// 							Port: to.Ptr[int32](443),
		// 					}},
		// 				},
		// 				{
		// 					DomainName: to.Ptr("table.core.windows.net"),
		// 					EndpointDetails: []*armstoragepool.EndpointDetail{
		// 						{
		// 							IPAddress: to.Ptr("13.77.184.74"),
		// 							IsAccessible: to.Ptr(true),
		// 							Latency: to.Ptr[float64](3.1141),
		// 							Port: to.Ptr[int32](80),
		// 						},
		// 						{
		// 							IPAddress: to.Ptr("13.77.184.74"),
		// 							IsAccessible: to.Ptr(true),
		// 							Latency: to.Ptr[float64](3.0247),
		// 							Port: to.Ptr[int32](443),
		// 					}},
		// 				},
		// 				{
		// 					DomainName: to.Ptr("file.core.windows.net"),
		// 					EndpointDetails: []*armstoragepool.EndpointDetail{
		// 						{
		// 							IPAddress: to.Ptr("13.77.184.76"),
		// 							IsAccessible: to.Ptr(true),
		// 							Latency: to.Ptr[float64](2.834),
		// 							Port: to.Ptr[int32](80),
		// 						},
		// 						{
		// 							IPAddress: to.Ptr("13.77.184.76"),
		// 							IsAccessible: to.Ptr(true),
		// 							Latency: to.Ptr[float64](2.8198000000000003),
		// 							Port: to.Ptr[int32](443),
		// 					}},
		// 				},
		// 				{
		// 					DomainName: to.Ptr("blob.core.windows.net"),
		// 					EndpointDetails: []*armstoragepool.EndpointDetail{
		// 						{
		// 							IPAddress: to.Ptr("13.77.184.64"),
		// 							IsAccessible: to.Ptr(true),
		// 							Latency: to.Ptr[float64](1.3855000000000002),
		// 							Port: to.Ptr[int32](80),
		// 						},
		// 						{
		// 							IPAddress: to.Ptr("13.77.184.64"),
		// 							IsAccessible: to.Ptr(true),
		// 							Latency: to.Ptr[float64](1.0594000000000001),
		// 							Port: to.Ptr[int32](443),
		// 					}},
		// 				},
		// 				{
		// 					DomainName: to.Ptr("queue.core.windows.net"),
		// 					EndpointDetails: []*armstoragepool.EndpointDetail{
		// 						{
		// 							IPAddress: to.Ptr("13.77.184.73"),
		// 							IsAccessible: to.Ptr(true),
		// 							Latency: to.Ptr[float64](2.4717000000000002),
		// 							Port: to.Ptr[int32](80),
		// 						},
		// 						{
		// 							IPAddress: to.Ptr("13.77.184.73"),
		// 							IsAccessible: to.Ptr(true),
		// 							Latency: to.Ptr[float64](2.4827),
		// 							Port: to.Ptr[int32](443),
		// 					}},
		// 				},
		// 				{
		// 					DomainName: to.Ptr("table.core.windows.net"),
		// 					EndpointDetails: []*armstoragepool.EndpointDetail{
		// 						{
		// 							IPAddress: to.Ptr("13.77.184.74"),
		// 							IsAccessible: to.Ptr(true),
		// 							Latency: to.Ptr[float64](3.395),
		// 							Port: to.Ptr[int32](80),
		// 						},
		// 						{
		// 							IPAddress: to.Ptr("13.77.184.74"),
		// 							IsAccessible: to.Ptr(true),
		// 							Latency: to.Ptr[float64](3.1701),
		// 							Port: to.Ptr[int32](443),
		// 					}},
		// 				},
		// 				{
		// 					DomainName: to.Ptr("file.core.windows.net"),
		// 					EndpointDetails: []*armstoragepool.EndpointDetail{
		// 						{
		// 							IPAddress: to.Ptr("13.77.184.76"),
		// 							IsAccessible: to.Ptr(true),
		// 							Latency: to.Ptr[float64](1.4308),
		// 							Port: to.Ptr[int32](80),
		// 						},
		// 						{
		// 							IPAddress: to.Ptr("13.77.184.76"),
		// 							IsAccessible: to.Ptr(true),
		// 							Latency: to.Ptr[float64](22.5866),
		// 							Port: to.Ptr[int32](443),
		// 					}},
		// 				},
		// 				{
		// 					DomainName: to.Ptr("blob.core.windows.net"),
		// 					EndpointDetails: []*armstoragepool.EndpointDetail{
		// 						{
		// 							IPAddress: to.Ptr("13.77.184.64"),
		// 							IsAccessible: to.Ptr(true),
		// 							Latency: to.Ptr[float64](2.5372),
		// 							Port: to.Ptr[int32](80),
		// 						},
		// 						{
		// 							IPAddress: to.Ptr("13.77.184.64"),
		// 							IsAccessible: to.Ptr(true),
		// 							Latency: to.Ptr[float64](2.4626),
		// 							Port: to.Ptr[int32](443),
		// 					}},
		// 				},
		// 				{
		// 					DomainName: to.Ptr("queue.core.windows.net"),
		// 					EndpointDetails: []*armstoragepool.EndpointDetail{
		// 						{
		// 							IPAddress: to.Ptr("13.77.184.73"),
		// 							IsAccessible: to.Ptr(true),
		// 							Latency: to.Ptr[float64](3.7873),
		// 							Port: to.Ptr[int32](80),
		// 						},
		// 						{
		// 							IPAddress: to.Ptr("13.77.184.73"),
		// 							IsAccessible: to.Ptr(true),
		// 							Latency: to.Ptr[float64](4.1911000000000005),
		// 							Port: to.Ptr[int32](443),
		// 					}},
		// 				},
		// 				{
		// 					DomainName: to.Ptr("table.core.windows.net"),
		// 					EndpointDetails: []*armstoragepool.EndpointDetail{
		// 						{
		// 							IPAddress: to.Ptr("13.77.184.74"),
		// 							IsAccessible: to.Ptr(true),
		// 							Latency: to.Ptr[float64](2.9162000000000003),
		// 							Port: to.Ptr[int32](80),
		// 						},
		// 						{
		// 							IPAddress: to.Ptr("13.77.184.74"),
		// 							IsAccessible: to.Ptr(true),
		// 							Latency: to.Ptr[float64](2.7896),
		// 							Port: to.Ptr[int32](443),
		// 					}},
		// 				},
		// 				{
		// 					DomainName: to.Ptr("file.core.windows.net"),
		// 					EndpointDetails: []*armstoragepool.EndpointDetail{
		// 						{
		// 							IPAddress: to.Ptr("13.77.184.76"),
		// 							IsAccessible: to.Ptr(true),
		// 							Latency: to.Ptr[float64](26.723100000000002),
		// 							Port: to.Ptr[int32](80),
		// 						},
		// 						{
		// 							IPAddress: to.Ptr("13.77.184.76"),
		// 							IsAccessible: to.Ptr(true),
		// 							Latency: to.Ptr[float64](26.735200000000003),
		// 							Port: to.Ptr[int32](443),
		// 					}},
		// 			}},
		// 		},
		// 		{
		// 			Category: to.Ptr("Azure SQL Database"),
		// 			Endpoints: []*armstoragepool.EndpointDependency{
		// 				{
		// 					DomainName: to.Ptr("database.windows.net"),
		// 					EndpointDetails: []*armstoragepool.EndpointDetail{
		// 						{
		// 							IPAddress: to.Ptr("13.66.226.202"),
		// 							IsAccessible: to.Ptr(true),
		// 							Latency: to.Ptr[float64](1.5964),
		// 							Port: to.Ptr[int32](1433),
		// 					}},
		// 			}},
		// 		},
		// 		{
		// 			Category: to.Ptr("Azure Management"),
		// 			Endpoints: []*armstoragepool.EndpointDependency{
		// 				{
		// 					DomainName: to.Ptr("management.core.windows.net"),
		// 					EndpointDetails: []*armstoragepool.EndpointDetail{
		// 						{
		// 							IPAddress: to.Ptr("23.102.135.246"),
		// 							IsAccessible: to.Ptr(true),
		// 							Latency: to.Ptr[float64](46.5764),
		// 							Port: to.Ptr[int32](443),
		// 					}},
		// 				},
		// 				{
		// 					DomainName: to.Ptr("admin.core.windows.net"),
		// 					EndpointDetails: []*armstoragepool.EndpointDetail{
		// 						{
		// 							IPAddress: to.Ptr("23.102.135.247"),
		// 							IsAccessible: to.Ptr(true),
		// 							Latency: to.Ptr[float64](47.408),
		// 							Port: to.Ptr[int32](443),
		// 					}},
		// 				},
		// 				{
		// 					DomainName: to.Ptr("management.azure.com"),
		// 					EndpointDetails: []*armstoragepool.EndpointDetail{
		// 						{
		// 							IPAddress: to.Ptr("52.151.25.45"),
		// 							IsAccessible: to.Ptr(true),
		// 							Latency: to.Ptr[float64](3.9529),
		// 							Port: to.Ptr[int32](443),
		// 					}},
		// 			}},
		// 		},
		// 		{
		// 			Category: to.Ptr("Azure Active Directory"),
		// 			Endpoints: []*armstoragepool.EndpointDependency{
		// 				{
		// 					DomainName: to.Ptr("graph.windows.net"),
		// 					EndpointDetails: []*armstoragepool.EndpointDetail{
		// 						{
		// 							IPAddress: to.Ptr("20.190.133.83"),
		// 							IsAccessible: to.Ptr(true),
		// 							Latency: to.Ptr[float64](3.2264),
		// 							Port: to.Ptr[int32](443),
		// 						},
		// 						{
		// 							IPAddress: to.Ptr("20.190.133.81"),
		// 							IsAccessible: to.Ptr(true),
		// 							Latency: to.Ptr[float64](3.2264),
		// 							Port: to.Ptr[int32](443),
		// 						},
		// 						{
		// 							IPAddress: to.Ptr("20.190.133.67"),
		// 							IsAccessible: to.Ptr(true),
		// 							Latency: to.Ptr[float64](3.2264),
		// 							Port: to.Ptr[int32](443),
		// 						},
		// 						{
		// 							IPAddress: to.Ptr("40.126.5.34"),
		// 							IsAccessible: to.Ptr(true),
		// 							Latency: to.Ptr[float64](3.2264),
		// 							Port: to.Ptr[int32](443),
		// 					}},
		// 			}},
		// 		},
		// 		{
		// 			Category: to.Ptr("Regional Service"),
		// 			Endpoints: []*armstoragepool.EndpointDependency{
		// 				{
		// 					DomainName: to.Ptr("gr-prod-mwh.cloudapp.net"),
		// 					EndpointDetails: []*armstoragepool.EndpointDetail{
		// 						{
		// 							IPAddress: to.Ptr("13.66.225.188"),
		// 							IsAccessible: to.Ptr(true),
		// 							Latency: to.Ptr[float64](3.3826),
		// 							Port: to.Ptr[int32](443),
		// 					}},
		// 				},
		// 				{
		// 					DomainName: to.Ptr("az-prod.metrics.nsatc.net"),
		// 					EndpointDetails: []*armstoragepool.EndpointDetail{
		// 						{
		// 							IPAddress: to.Ptr("40.77.24.27"),
		// 							IsAccessible: to.Ptr(true),
		// 							Latency: to.Ptr[float64](38.5647),
		// 							Port: to.Ptr[int32](443),
		// 					}},
		// 			}},
		// 		},
		// 		{
		// 			Category: to.Ptr("SSL Certificate Verification"),
		// 			Endpoints: []*armstoragepool.EndpointDependency{
		// 				{
		// 					DomainName: to.Ptr("ocsp.msocsp.com"),
		// 					EndpointDetails: []*armstoragepool.EndpointDetail{
		// 						{
		// 							IPAddress: to.Ptr("104.18.25.243"),
		// 							IsAccessible: to.Ptr(true),
		// 							Latency: to.Ptr[float64](6.0651),
		// 							Port: to.Ptr[int32](80),
		// 						},
		// 						{
		// 							IPAddress: to.Ptr("104.18.25.243"),
		// 							IsAccessible: to.Ptr(true),
		// 							Latency: to.Ptr[float64](12.888),
		// 							Port: to.Ptr[int32](443),
		// 						},
		// 						{
		// 							IPAddress: to.Ptr("104.18.24.243"),
		// 							IsAccessible: to.Ptr(true),
		// 							Latency: to.Ptr[float64](6.0651),
		// 							Port: to.Ptr[int32](80),
		// 						},
		// 						{
		// 							IPAddress: to.Ptr("104.18.24.243"),
		// 							IsAccessible: to.Ptr(true),
		// 							Latency: to.Ptr[float64](12.888),
		// 							Port: to.Ptr[int32](443),
		// 					}},
		// 				},
		// 				{
		// 					DomainName: to.Ptr("mscrl.microsoft.com"),
		// 					EndpointDetails: []*armstoragepool.EndpointDetail{
		// 						{
		// 							IPAddress: to.Ptr("152.199.4.33"),
		// 							IsAccessible: to.Ptr(true),
		// 							Latency: to.Ptr[float64](6.742900000000001),
		// 							Port: to.Ptr[int32](80),
		// 						},
		// 						{
		// 							IPAddress: to.Ptr("152.199.4.33"),
		// 							IsAccessible: to.Ptr(true),
		// 							Latency: to.Ptr[float64](7.436100000000001),
		// 							Port: to.Ptr[int32](443),
		// 					}},
		// 				},
		// 				{
		// 					DomainName: to.Ptr("crl.microsoft.com"),
		// 					EndpointDetails: []*armstoragepool.EndpointDetail{
		// 						{
		// 							IPAddress: to.Ptr("23.215.102.10"),
		// 							IsAccessible: to.Ptr(true),
		// 							Latency: to.Ptr[float64](25.136200000000002),
		// 							Port: to.Ptr[int32](80),
		// 						},
		// 						{
		// 							IPAddress: to.Ptr("23.215.102.10"),
		// 							IsAccessible: to.Ptr(true),
		// 							Latency: to.Ptr[float64](25.0085),
		// 							Port: to.Ptr[int32](443),
		// 						},
		// 						{
		// 							IPAddress: to.Ptr("23.215.102.42"),
		// 							IsAccessible: to.Ptr(true),
		// 							Latency: to.Ptr[float64](25.136200000000002),
		// 							Port: to.Ptr[int32](80),
		// 						},
		// 						{
		// 							IPAddress: to.Ptr("23.215.102.42"),
		// 							IsAccessible: to.Ptr(true),
		// 							Latency: to.Ptr[float64](25.0085),
		// 							Port: to.Ptr[int32](443),
		// 					}},
		// 				},
		// 				{
		// 					DomainName: to.Ptr("www.microsoft.com"),
		// 					EndpointDetails: []*armstoragepool.EndpointDetail{
		// 						{
		// 							IPAddress: to.Ptr("23.49.13.56"),
		// 							IsAccessible: to.Ptr(true),
		// 							Latency: to.Ptr[float64](7.9229),
		// 							Port: to.Ptr[int32](80),
		// 						},
		// 						{
		// 							IPAddress: to.Ptr("23.49.13.56"),
		// 							IsAccessible: to.Ptr(true),
		// 							Latency: to.Ptr[float64](8.4871),
		// 							Port: to.Ptr[int32](443),
		// 					}},
		// 				},
		// 				{
		// 					DomainName: to.Ptr("crl3.digicert.com"),
		// 					EndpointDetails: []*armstoragepool.EndpointDetail{
		// 						{
		// 							IPAddress: to.Ptr("72.21.91.29"),
		// 							IsAccessible: to.Ptr(true),
		// 							Latency: to.Ptr[float64](5.4074),
		// 							Port: to.Ptr[int32](80),
		// 						},
		// 						{
		// 							IPAddress: to.Ptr("72.21.91.29"),
		// 							IsAccessible: to.Ptr(true),
		// 							Latency: to.Ptr[float64](5.577),
		// 							Port: to.Ptr[int32](443),
		// 					}},
		// 				},
		// 				{
		// 					DomainName: to.Ptr("ocsp.digicert.com"),
		// 					EndpointDetails: []*armstoragepool.EndpointDetail{
		// 						{
		// 							IPAddress: to.Ptr("72.21.91.29"),
		// 							IsAccessible: to.Ptr(true),
		// 							Latency: to.Ptr[float64](6.8989),
		// 							Port: to.Ptr[int32](80),
		// 						},
		// 						{
		// 							IPAddress: to.Ptr("72.21.91.29"),
		// 							IsAccessible: to.Ptr(true),
		// 							Latency: to.Ptr[float64](5.667400000000001),
		// 							Port: to.Ptr[int32](443),
		// 					}},
		// 				},
		// 				{
		// 					DomainName: to.Ptr("cacerts.digicert.com"),
		// 					EndpointDetails: []*armstoragepool.EndpointDetail{
		// 						{
		// 							IPAddress: to.Ptr("104.18.11.39"),
		// 							IsAccessible: to.Ptr(true),
		// 							Latency: to.Ptr[float64](10.772400000000001),
		// 							Port: to.Ptr[int32](80),
		// 						},
		// 						{
		// 							IPAddress: to.Ptr("104.18.11.39"),
		// 							IsAccessible: to.Ptr(true),
		// 							Latency: to.Ptr[float64](10.7705),
		// 							Port: to.Ptr[int32](443),
		// 						},
		// 						{
		// 							IPAddress: to.Ptr("104.18.10.39"),
		// 							IsAccessible: to.Ptr(true),
		// 							Latency: to.Ptr[float64](10.772400000000001),
		// 							Port: to.Ptr[int32](80),
		// 						},
		// 						{
		// 							IPAddress: to.Ptr("104.18.10.39"),
		// 							IsAccessible: to.Ptr(true),
		// 							Latency: to.Ptr[float64](10.7705),
		// 							Port: to.Ptr[int32](443),
		// 					}},
		// 				},
		// 				{
		// 					DomainName: to.Ptr("www.thawte.com"),
		// 					EndpointDetails: []*armstoragepool.EndpointDetail{
		// 						{
		// 							IPAddress: to.Ptr("54.69.98.161"),
		// 							IsAccessible: to.Ptr(true),
		// 							Latency: to.Ptr[float64](47.532900000000005),
		// 							Port: to.Ptr[int32](80),
		// 						},
		// 						{
		// 							IPAddress: to.Ptr("54.69.98.161"),
		// 							IsAccessible: to.Ptr(true),
		// 							Latency: to.Ptr[float64](48.5362),
		// 							Port: to.Ptr[int32](443),
		// 						},
		// 						{
		// 							IPAddress: to.Ptr("35.167.62.148"),
		// 							IsAccessible: to.Ptr(true),
		// 							Latency: to.Ptr[float64](47.532900000000005),
		// 							Port: to.Ptr[int32](80),
		// 						},
		// 						{
		// 							IPAddress: to.Ptr("35.167.62.148"),
		// 							IsAccessible: to.Ptr(true),
		// 							Latency: to.Ptr[float64](48.5362),
		// 							Port: to.Ptr[int32](443),
		// 					}},
		// 			}},
		// 	}},
		// }
	}
}

Output:

type DiskPoolsClientBeginCreateOrUpdateOptions added in v0.2.0 

type DiskPoolsClientBeginCreateOrUpdateOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

DiskPoolsClientBeginCreateOrUpdateOptions contains the optional parameters for the DiskPoolsClient.BeginCreateOrUpdate method.

type DiskPoolsClientBeginDeallocateOptions added in v0.2.0 

type DiskPoolsClientBeginDeallocateOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

DiskPoolsClientBeginDeallocateOptions contains the optional parameters for the DiskPoolsClient.BeginDeallocate method.

type DiskPoolsClientBeginDeleteOptions added in v0.2.0 

type DiskPoolsClientBeginDeleteOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

DiskPoolsClientBeginDeleteOptions contains the optional parameters for the DiskPoolsClient.BeginDelete method.

type DiskPoolsClientBeginStartOptions added in v0.2.0 

type DiskPoolsClientBeginStartOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

DiskPoolsClientBeginStartOptions contains the optional parameters for the DiskPoolsClient.BeginStart method.

type DiskPoolsClientBeginUpdateOptions added in v0.2.0 

type DiskPoolsClientBeginUpdateOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

DiskPoolsClientBeginUpdateOptions contains the optional parameters for the DiskPoolsClient.BeginUpdate method.

type DiskPoolsClientBeginUpgradeOptions added in v0.2.0 

type DiskPoolsClientBeginUpgradeOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

DiskPoolsClientBeginUpgradeOptions contains the optional parameters for the DiskPoolsClient.BeginUpgrade method.

type DiskPoolsClientCreateOrUpdateResponse added in v0.2.0 

type DiskPoolsClientCreateOrUpdateResponse struct {
	// Response for Disk Pool request.
	DiskPool
}

DiskPoolsClientCreateOrUpdateResponse contains the response from method DiskPoolsClient.BeginCreateOrUpdate.

type DiskPoolsClientDeallocateResponse added in v0.2.0 

type DiskPoolsClientDeallocateResponse struct {
}

DiskPoolsClientDeallocateResponse contains the response from method DiskPoolsClient.BeginDeallocate.

type DiskPoolsClientDeleteResponse added in v0.2.0 

type DiskPoolsClientDeleteResponse struct {
}

DiskPoolsClientDeleteResponse contains the response from method DiskPoolsClient.BeginDelete.

type DiskPoolsClientGetOptions added in v0.2.0 

type DiskPoolsClientGetOptions struct {
}

DiskPoolsClientGetOptions contains the optional parameters for the DiskPoolsClient.Get method.

type DiskPoolsClientGetResponse added in v0.2.0 

type DiskPoolsClientGetResponse struct {
	// Response for Disk Pool request.
	DiskPool
}

DiskPoolsClientGetResponse contains the response from method DiskPoolsClient.Get.

type DiskPoolsClientListByResourceGroupOptions added in v0.2.0 

type DiskPoolsClientListByResourceGroupOptions struct {
}

DiskPoolsClientListByResourceGroupOptions contains the optional parameters for the DiskPoolsClient.NewListByResourceGroupPager method.

type DiskPoolsClientListByResourceGroupResponse added in v0.2.0 

type DiskPoolsClientListByResourceGroupResponse struct {
	// List of Disk Pools
	DiskPoolListResult
}

DiskPoolsClientListByResourceGroupResponse contains the response from method DiskPoolsClient.NewListByResourceGroupPager.

type DiskPoolsClientListBySubscriptionOptions added in v0.2.0 

type DiskPoolsClientListBySubscriptionOptions struct {
}

DiskPoolsClientListBySubscriptionOptions contains the optional parameters for the DiskPoolsClient.NewListBySubscriptionPager method.

type DiskPoolsClientListBySubscriptionResponse added in v0.2.0 

type DiskPoolsClientListBySubscriptionResponse struct {
	// List of Disk Pools
	DiskPoolListResult
}

DiskPoolsClientListBySubscriptionResponse contains the response from method DiskPoolsClient.NewListBySubscriptionPager.

type DiskPoolsClientListOutboundNetworkDependenciesEndpointsOptions added in v0.2.0 

type DiskPoolsClientListOutboundNetworkDependenciesEndpointsOptions struct {
}

DiskPoolsClientListOutboundNetworkDependenciesEndpointsOptions contains the optional parameters for the DiskPoolsClient.NewListOutboundNetworkDependenciesEndpointsPager method.

type DiskPoolsClientListOutboundNetworkDependenciesEndpointsResponse added in v0.2.0 

type DiskPoolsClientListOutboundNetworkDependenciesEndpointsResponse struct {
	// Collection of Outbound Environment Endpoints
	OutboundEnvironmentEndpointList
}

DiskPoolsClientListOutboundNetworkDependenciesEndpointsResponse contains the response from method DiskPoolsClient.NewListOutboundNetworkDependenciesEndpointsPager.

type DiskPoolsClientStartResponse added in v0.2.0 

type DiskPoolsClientStartResponse struct {
}

DiskPoolsClientStartResponse contains the response from method DiskPoolsClient.BeginStart.

type DiskPoolsClientUpdateResponse added in v0.2.0 

type DiskPoolsClientUpdateResponse struct {
	// Response for Disk Pool request.
	DiskPool
}

DiskPoolsClientUpdateResponse contains the response from method DiskPoolsClient.BeginUpdate.

type DiskPoolsClientUpgradeResponse added in v0.2.0 

type DiskPoolsClientUpgradeResponse struct {
}

DiskPoolsClientUpgradeResponse contains the response from method DiskPoolsClient.BeginUpgrade.

type EndpointDependency 

type EndpointDependency struct {
	// The domain name of the dependency.
	DomainName *string

	// The IP Addresses and Ports used when connecting to DomainName.
	EndpointDetails []*EndpointDetail
}

EndpointDependency - A domain name that a service is reached at, including details of the current connection status.

func (EndpointDependency) MarshalJSON 

func (e EndpointDependency) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type EndpointDependency.

func (*EndpointDependency) UnmarshalJSON added in v1.1.0 

func (e *EndpointDependency) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type EndpointDependency.

type EndpointDetail 

type EndpointDetail struct {
	// An IP Address that Domain Name currently resolves to.
	IPAddress *string

	// Whether it is possible to create a TCP connection from the App Service Environment to this IpAddress at this Port.
	IsAccessible *bool

	// The time in milliseconds it takes for a TCP connection to be created from the App Service Environment to this IpAddress
	// at this Port.
	Latency *float64

	// The port an endpoint is connected to.
	Port *int32
}

EndpointDetail - Current TCP connectivity information from the App Service Environment to a single endpoint.

func (EndpointDetail) MarshalJSON added in v1.1.0 

func (e EndpointDetail) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type EndpointDetail.

func (*EndpointDetail) UnmarshalJSON added in v1.1.0 

func (e *EndpointDetail) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type EndpointDetail.

type Error 

type Error struct {
	// RP error response.
	Error *ErrorResponse
}

Error - The resource management error response.

func (Error) MarshalJSON added in v1.1.0 

func (e Error) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type Error.

func (*Error) UnmarshalJSON added in v1.1.0 

func (e *Error) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type Error.

type ErrorAdditionalInfo 

type ErrorAdditionalInfo struct {
	// READ-ONLY; The additional info.
	Info any

	// READ-ONLY; The additional info type.
	Type *string
}

ErrorAdditionalInfo - The resource management error additional info.

func (ErrorAdditionalInfo) MarshalJSON added in v1.1.0 

func (e ErrorAdditionalInfo) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ErrorAdditionalInfo.

func (*ErrorAdditionalInfo) UnmarshalJSON added in v1.1.0 

func (e *ErrorAdditionalInfo) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ErrorAdditionalInfo.

type ErrorResponse 

type ErrorResponse struct {
	// READ-ONLY; The error additional info.
	AdditionalInfo []*ErrorAdditionalInfo

	// READ-ONLY; The error code.
	Code *string

	// READ-ONLY; The error details.
	Details []*ErrorResponse

	// READ-ONLY; The error message.
	Message *string

	// READ-ONLY; The error target.
	Target *string
}

ErrorResponse - The resource management error response.

func (ErrorResponse) MarshalJSON 

func (e ErrorResponse) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ErrorResponse.

func (*ErrorResponse) UnmarshalJSON added in v1.1.0 

func (e *ErrorResponse) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ErrorResponse.

type IscsiLun 

type IscsiLun struct {
	// REQUIRED; Azure Resource ID of the Managed Disk.
	ManagedDiskAzureResourceID *string

	// REQUIRED; User defined name for iSCSI LUN; example: "lun0"
	Name *string

	// READ-ONLY; Specifies the Logical Unit Number of the iSCSI LUN.
	Lun *int32
}

IscsiLun - LUN to expose the Azure Managed Disk.

func (IscsiLun) MarshalJSON added in v1.1.0 

func (i IscsiLun) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type IscsiLun.

func (*IscsiLun) UnmarshalJSON added in v1.1.0 

func (i *IscsiLun) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type IscsiLun.

type IscsiTarget 

type IscsiTarget struct {
	// REQUIRED; Properties for iSCSI Target operations.
	Properties *IscsiTargetProperties

	// READ-ONLY; Fully qualified resource Id for the resource. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}
	ID *string

	// READ-ONLY; Azure resource id. Indicates if this resource is managed by another Azure resource.
	ManagedBy *string

	// READ-ONLY; List of Azure resource ids that manage this resource.
	ManagedByExtended []*string

	// READ-ONLY; The name of the resource
	Name *string

	// READ-ONLY; Resource metadata required by ARM RPC
	SystemData *SystemMetadata

	// READ-ONLY; The type of the resource. Ex- Microsoft.Compute/virtualMachines or Microsoft.Storage/storageAccounts.
	Type *string
}

IscsiTarget - Response for iSCSI Target requests.

func (IscsiTarget) MarshalJSON 

func (i IscsiTarget) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type IscsiTarget.

func (*IscsiTarget) UnmarshalJSON added in v1.1.0 

func (i *IscsiTarget) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type IscsiTarget.

type IscsiTargetACLMode 

type IscsiTargetACLMode string

IscsiTargetACLMode - ACL mode for iSCSI Target. 

const (
	IscsiTargetACLModeDynamic IscsiTargetACLMode = "Dynamic"
	IscsiTargetACLModeStatic  IscsiTargetACLMode = "Static"
)

func PossibleIscsiTargetACLModeValues 

func PossibleIscsiTargetACLModeValues() []IscsiTargetACLMode

PossibleIscsiTargetACLModeValues returns the possible values for the IscsiTargetACLMode const type.

type IscsiTargetCreate 

type IscsiTargetCreate struct {
	// REQUIRED; Properties for iSCSI Target create request.
	Properties *IscsiTargetCreateProperties

	// Azure resource id. Indicates if this resource is managed by another Azure resource.
	ManagedBy *string

	// List of Azure resource ids that manage this resource.
	ManagedByExtended []*string

	// READ-ONLY; Fully qualified resource Id for the resource. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}
	ID *string

	// READ-ONLY; The name of the resource
	Name *string

	// READ-ONLY; The type of the resource. Ex- Microsoft.Compute/virtualMachines or Microsoft.Storage/storageAccounts.
	Type *string
}

IscsiTargetCreate - Payload for iSCSI Target create or update requests.

func (IscsiTargetCreate) MarshalJSON 

func (i IscsiTargetCreate) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type IscsiTargetCreate.

func (*IscsiTargetCreate) UnmarshalJSON added in v1.1.0 

func (i *IscsiTargetCreate) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type IscsiTargetCreate.

type IscsiTargetCreateProperties 

type IscsiTargetCreateProperties struct {
	// REQUIRED; Mode for Target connectivity.
	ACLMode *IscsiTargetACLMode

	// List of LUNs to be exposed through iSCSI Target.
	Luns []*IscsiLun

	// Access Control List (ACL) for an iSCSI Target; defines LUN masking policy
	StaticACLs []*ACL

	// iSCSI Target IQN (iSCSI Qualified Name); example: "iqn.2005-03.org.iscsi:server".
	TargetIqn *string
}

IscsiTargetCreateProperties - Properties for iSCSI Target create or update request.

func (IscsiTargetCreateProperties) MarshalJSON 

func (i IscsiTargetCreateProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type IscsiTargetCreateProperties.

func (*IscsiTargetCreateProperties) UnmarshalJSON added in v1.1.0 

func (i *IscsiTargetCreateProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type IscsiTargetCreateProperties.

type IscsiTargetList 

type IscsiTargetList struct {
	// REQUIRED; An array of iSCSI Targets in a Disk Pool.
	Value []*IscsiTarget

	// READ-ONLY; URI to fetch the next section of the paginated response.
	NextLink *string
}

IscsiTargetList - List of iSCSI Targets.

func (IscsiTargetList) MarshalJSON 

func (i IscsiTargetList) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type IscsiTargetList.

func (*IscsiTargetList) UnmarshalJSON added in v1.1.0 

func (i *IscsiTargetList) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type IscsiTargetList.

type IscsiTargetProperties 

type IscsiTargetProperties struct {
	// REQUIRED; Mode for Target connectivity.
	ACLMode *IscsiTargetACLMode

	// REQUIRED; Operational status of the iSCSI Target.
	Status *OperationalStatus

	// REQUIRED; iSCSI Target IQN (iSCSI Qualified Name); example: "iqn.2005-03.org.iscsi:server".
	TargetIqn *string

	// READ-ONLY; State of the operation on the resource.
	ProvisioningState *ProvisioningStates

	// List of private IPv4 addresses to connect to the iSCSI Target.
	Endpoints []*string

	// List of LUNs to be exposed through iSCSI Target.
	Luns []*IscsiLun

	// The port used by iSCSI Target portal group.
	Port *int32

	// Access Control List (ACL) for an iSCSI Target; defines LUN masking policy
	StaticACLs []*ACL

	// READ-ONLY; List of identifiers for active sessions on the iSCSI target
	Sessions []*string
}

IscsiTargetProperties - Response properties for iSCSI Target operations.

func (IscsiTargetProperties) MarshalJSON 

func (i IscsiTargetProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type IscsiTargetProperties.

func (*IscsiTargetProperties) UnmarshalJSON added in v1.1.0 

func (i *IscsiTargetProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type IscsiTargetProperties.

type IscsiTargetUpdate 

type IscsiTargetUpdate struct {
	// REQUIRED; Properties for iSCSI Target update request.
	Properties *IscsiTargetUpdateProperties

	// Azure resource id. Indicates if this resource is managed by another Azure resource.
	ManagedBy *string

	// List of Azure resource ids that manage this resource.
	ManagedByExtended []*string

	// READ-ONLY; Fully qualified resource Id for the resource. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}
	ID *string

	// READ-ONLY; The name of the resource
	Name *string

	// READ-ONLY; The type of the resource. Ex- Microsoft.Compute/virtualMachines or Microsoft.Storage/storageAccounts.
	Type *string
}

IscsiTargetUpdate - Payload for iSCSI Target update requests.

func (IscsiTargetUpdate) MarshalJSON 

func (i IscsiTargetUpdate) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type IscsiTargetUpdate.

func (*IscsiTargetUpdate) UnmarshalJSON added in v1.1.0 

func (i *IscsiTargetUpdate) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type IscsiTargetUpdate.

type IscsiTargetUpdateProperties 

type IscsiTargetUpdateProperties struct {
	// List of LUNs to be exposed through iSCSI Target.
	Luns []*IscsiLun

	// Access Control List (ACL) for an iSCSI Target; defines LUN masking policy
	StaticACLs []*ACL
}

IscsiTargetUpdateProperties - Properties for iSCSI Target update request.

func (IscsiTargetUpdateProperties) MarshalJSON 

func (i IscsiTargetUpdateProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type IscsiTargetUpdateProperties.

func (*IscsiTargetUpdateProperties) UnmarshalJSON added in v1.1.0 

func (i *IscsiTargetUpdateProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type IscsiTargetUpdateProperties.

type IscsiTargetsClient 

type IscsiTargetsClient struct {
	// contains filtered or unexported fields
}

IscsiTargetsClient contains the methods for the IscsiTargets group. Don't use this type directly, use NewIscsiTargetsClient() instead.

func NewIscsiTargetsClient 

func NewIscsiTargetsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*IscsiTargetsClient, error)

NewIscsiTargetsClient creates a new instance of IscsiTargetsClient with the specified values.

  • subscriptionID - The ID of the target subscription.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*IscsiTargetsClient) BeginCreateOrUpdate 

func (client *IscsiTargetsClient) BeginCreateOrUpdate(ctx context.Context, resourceGroupName string, diskPoolName string, iscsiTargetName string, iscsiTargetCreatePayload IscsiTargetCreate, options *IscsiTargetsClientBeginCreateOrUpdateOptions) (*runtime.Poller[IscsiTargetsClientCreateOrUpdateResponse], error)

BeginCreateOrUpdate - Create or Update an iSCSI Target. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2021-08-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • diskPoolName - The name of the Disk Pool.
  • iscsiTargetName - The name of the iSCSI Target.
  • iscsiTargetCreatePayload - Request payload for iSCSI Target create operation.
  • options - IscsiTargetsClientBeginCreateOrUpdateOptions contains the optional parameters for the IscsiTargetsClient.BeginCreateOrUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/storagepool/resource-manager/Microsoft.StoragePool/stable/2021-08-01/examples/IscsiTargets_Put.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storagepool/armstoragepool"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstoragepool.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewIscsiTargetsClient().BeginCreateOrUpdate(ctx, "myResourceGroup", "myDiskPool", "myIscsiTarget", armstoragepool.IscsiTargetCreate{
		Properties: &armstoragepool.IscsiTargetCreateProperties{
			ACLMode: to.Ptr(armstoragepool.IscsiTargetACLModeDynamic),
			Luns: []*armstoragepool.IscsiLun{
				{
					Name:                       to.Ptr("lun0"),
					ManagedDiskAzureResourceID: to.Ptr("/subscriptions/11111111-1111-1111-1111-111111111111/resourceGroups/myResourceGroup/providers/Microsoft.Compute/disks/vm-name_DataDisk_1"),
				}},
			TargetIqn: to.Ptr("iqn.2005-03.org.iscsi:server1"),
		},
	}, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	res, err := poller.PollUntilDone(ctx, nil)
	if err != nil {
		log.Fatalf("failed to pull the result: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res.IscsiTarget = armstoragepool.IscsiTarget{
	// 	Name: to.Ptr("myIscsiTarget"),
	// 	Type: to.Ptr("Microsoft.StoragePool/diskPools/iscsiTargets"),
	// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/myResourceGroup/providers/Microsoft.StoragePool/diskPools/myDiskPool/iscsiTargets/myIscsiTarget"),
	// 	ManagedBy: to.Ptr("/subscriptions/11111111-1111-1111-1111-111111111111/resourceGroups/myResourceGroup/providers/Microsoft.AVS/privateClouds/myPrivateCloud/clusters/Cluster-1/datastores/datastore1"),
	// 	ManagedByExtended: []*string{
	// 		to.Ptr("/subscriptions/11111111-1111-1111-1111-111111111111/resourceGroups/myResourceGroup/providers/Microsoft.AVS/privateClouds/myPrivateCloud/clusters/Cluster-1/datastores/datastore1"),
	// 		to.Ptr("/subscriptions/11111111-1111-1111-1111-111111111111/resourceGroups/myResourceGroup/providers/Microsoft.AVS/privateClouds/myPrivateCloud/clusters/Cluster-1/datastores/datastore2")},
	// 		Properties: &armstoragepool.IscsiTargetProperties{
	// 			ACLMode: to.Ptr(armstoragepool.IscsiTargetACLModeDynamic),
	// 			Endpoints: []*string{
	// 				to.Ptr("10.0.0.1:3260")},
	// 				Luns: []*armstoragepool.IscsiLun{
	// 					{
	// 						Name: to.Ptr("lun0"),
	// 						Lun: to.Ptr[int32](3),
	// 						ManagedDiskAzureResourceID: to.Ptr("/subscriptions/11111111-1111-1111-1111-111111111111/resourceGroups/myResourceGroup/providers/Microsoft.Compute/disks/vm-name_DataDisk_1"),
	// 				}},
	// 				Port: to.Ptr[int32](3260),
	// 				ProvisioningState: to.Ptr(armstoragepool.ProvisioningStatesSucceeded),
	// 				Sessions: []*string{
	// 					to.Ptr("iqn.2005-03.org.iscsi:client")},
	// 					Status: to.Ptr(armstoragepool.OperationalStatusUnknown),
	// 					TargetIqn: to.Ptr("iqn.2005-03.org.iscsi:server1"),
	// 				},
	// 				SystemData: &armstoragepool.SystemMetadata{
	// 					CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-06-24T06:53:57.000Z"); return t}()),
	// 					CreatedBy: to.Ptr("alias"),
	// 					CreatedByType: to.Ptr(armstoragepool.CreatedByTypeUser),
	// 					LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-06-24T06:53:57.000Z"); return t}()),
	// 					LastModifiedBy: to.Ptr("alias"),
	// 					LastModifiedByType: to.Ptr(armstoragepool.CreatedByTypeUser),
	// 				},
	// 			}
}

Output:

func (*IscsiTargetsClient) BeginDelete 

func (client *IscsiTargetsClient) BeginDelete(ctx context.Context, resourceGroupName string, diskPoolName string, iscsiTargetName string, options *IscsiTargetsClientBeginDeleteOptions) (*runtime.Poller[IscsiTargetsClientDeleteResponse], error)

BeginDelete - Delete an iSCSI Target. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2021-08-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • diskPoolName - The name of the Disk Pool.
  • iscsiTargetName - The name of the iSCSI Target.
  • options - IscsiTargetsClientBeginDeleteOptions contains the optional parameters for the IscsiTargetsClient.BeginDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/storagepool/resource-manager/Microsoft.StoragePool/stable/2021-08-01/examples/IscsiTargets_Delete.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storagepool/armstoragepool"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstoragepool.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewIscsiTargetsClient().BeginDelete(ctx, "myResourceGroup", "myDiskPool", "myIscsiTarget", nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	_, err = poller.PollUntilDone(ctx, nil)
	if err != nil {
		log.Fatalf("failed to pull the result: %v", err)
	}
}

Output:

func (*IscsiTargetsClient) BeginUpdate 

func (client *IscsiTargetsClient) BeginUpdate(ctx context.Context, resourceGroupName string, diskPoolName string, iscsiTargetName string, iscsiTargetUpdatePayload IscsiTargetUpdate, options *IscsiTargetsClientBeginUpdateOptions) (*runtime.Poller[IscsiTargetsClientUpdateResponse], error)

BeginUpdate - Update an iSCSI Target. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2021-08-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • diskPoolName - The name of the Disk Pool.
  • iscsiTargetName - The name of the iSCSI Target.
  • iscsiTargetUpdatePayload - Request payload for iSCSI Target update operation.
  • options - IscsiTargetsClientBeginUpdateOptions contains the optional parameters for the IscsiTargetsClient.BeginUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/storagepool/resource-manager/Microsoft.StoragePool/stable/2021-08-01/examples/IscsiTargets_Patch.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storagepool/armstoragepool"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstoragepool.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewIscsiTargetsClient().BeginUpdate(ctx, "myResourceGroup", "myDiskPool", "myIscsiTarget", armstoragepool.IscsiTargetUpdate{
		Properties: &armstoragepool.IscsiTargetUpdateProperties{
			Luns: []*armstoragepool.IscsiLun{
				{
					Name:                       to.Ptr("lun0"),
					ManagedDiskAzureResourceID: to.Ptr("/subscriptions/11111111-1111-1111-1111-111111111111/resourceGroups/myResourceGroup/providers/Microsoft.Compute/disks/vm-name_DataDisk_1"),
				}},
			StaticACLs: []*armstoragepool.ACL{
				{
					InitiatorIqn: to.Ptr("iqn.2005-03.org.iscsi:client"),
					MappedLuns: []*string{
						to.Ptr("lun0")},
				}},
		},
	}, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	res, err := poller.PollUntilDone(ctx, nil)
	if err != nil {
		log.Fatalf("failed to pull the result: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res.IscsiTarget = armstoragepool.IscsiTarget{
	// 	Name: to.Ptr("myIscsiTarget"),
	// 	Type: to.Ptr("Microsoft.StoragePool/diskPools/iscsiTargets"),
	// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/myResourceGroup/providers/Microsoft.StoragePool/diskPools/myDiskPool/iscsiTargets/myIscsiTarget"),
	// 	ManagedBy: to.Ptr("/subscriptions/11111111-1111-1111-1111-111111111111/resourceGroups/myResourceGroup/providers/Microsoft.AVS/privateClouds/myPrivateCloud/clusters/Cluster-1/datastores/datastore1"),
	// 	ManagedByExtended: []*string{
	// 		to.Ptr("/subscriptions/11111111-1111-1111-1111-111111111111/resourceGroups/myResourceGroup/providers/Microsoft.AVS/privateClouds/myPrivateCloud/clusters/Cluster-1/datastores/datastore1"),
	// 		to.Ptr("/subscriptions/11111111-1111-1111-1111-111111111111/resourceGroups/myResourceGroup/providers/Microsoft.AVS/privateClouds/myPrivateCloud/clusters/Cluster-1/datastores/datastore2")},
	// 		Properties: &armstoragepool.IscsiTargetProperties{
	// 			ACLMode: to.Ptr(armstoragepool.IscsiTargetACLModeStatic),
	// 			Endpoints: []*string{
	// 				to.Ptr("10.0.0.1:3260")},
	// 				Luns: []*armstoragepool.IscsiLun{
	// 					{
	// 						Name: to.Ptr("lun0"),
	// 						Lun: to.Ptr[int32](3),
	// 						ManagedDiskAzureResourceID: to.Ptr("/subscriptions/11111111-1111-1111-1111-111111111111/resourceGroups/myResourceGroup/providers/Microsoft.Compute/disks/vm-name_DataDisk_1"),
	// 				}},
	// 				Port: to.Ptr[int32](3260),
	// 				ProvisioningState: to.Ptr(armstoragepool.ProvisioningStatesSucceeded),
	// 				Sessions: []*string{
	// 					to.Ptr("iqn.2005-03.org.iscsi:client")},
	// 					StaticACLs: []*armstoragepool.ACL{
	// 						{
	// 							InitiatorIqn: to.Ptr("iqn.2005-03.org.iscsi:client"),
	// 							MappedLuns: []*string{
	// 								to.Ptr("lun0")},
	// 						}},
	// 						Status: to.Ptr(armstoragepool.OperationalStatusUnknown),
	// 						TargetIqn: to.Ptr("iqn.2005-03.org.iscsi:server1"),
	// 					},
	// 					SystemData: &armstoragepool.SystemMetadata{
	// 						CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-06-24T06:53:57.000Z"); return t}()),
	// 						CreatedBy: to.Ptr("alias"),
	// 						CreatedByType: to.Ptr(armstoragepool.CreatedByTypeUser),
	// 						LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-06-24T06:53:57.000Z"); return t}()),
	// 						LastModifiedBy: to.Ptr("alias"),
	// 						LastModifiedByType: to.Ptr(armstoragepool.CreatedByTypeUser),
	// 					},
	// 				}
}

Output:

func (*IscsiTargetsClient) Get 

func (client *IscsiTargetsClient) Get(ctx context.Context, resourceGroupName string, diskPoolName string, iscsiTargetName string, options *IscsiTargetsClientGetOptions) (IscsiTargetsClientGetResponse, error)

Get - Get an iSCSI Target. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2021-08-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • diskPoolName - The name of the Disk Pool.
  • iscsiTargetName - The name of the iSCSI Target.
  • options - IscsiTargetsClientGetOptions contains the optional parameters for the IscsiTargetsClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/storagepool/resource-manager/Microsoft.StoragePool/stable/2021-08-01/examples/IscsiTargets_Get.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storagepool/armstoragepool"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstoragepool.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewIscsiTargetsClient().Get(ctx, "myResourceGroup", "myDiskPool", "myIscsiTarget", nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res.IscsiTarget = armstoragepool.IscsiTarget{
	// 	Name: to.Ptr("myIscsiTarget"),
	// 	Type: to.Ptr("Microsoft.StoragePool/diskPools/iscsiTargets"),
	// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/myResourceGroup/providers/Microsoft.StoragePool/diskPools/myDiskPool/iscsiTargets/myIscsiTarget"),
	// 	Properties: &armstoragepool.IscsiTargetProperties{
	// 		ACLMode: to.Ptr(armstoragepool.IscsiTargetACLModeStatic),
	// 		Endpoints: []*string{
	// 			to.Ptr("10.0.0.1:3260")},
	// 			Luns: []*armstoragepool.IscsiLun{
	// 				{
	// 					Name: to.Ptr("lun0"),
	// 					Lun: to.Ptr[int32](0),
	// 					ManagedDiskAzureResourceID: to.Ptr("/subscriptions/11111111-1111-1111-1111-111111111111/resourceGroups/myResourceGroup/providers/Microsoft.Compute/disks/vm-name_DataDisk_1"),
	// 			}},
	// 			Port: to.Ptr[int32](3260),
	// 			ProvisioningState: to.Ptr(armstoragepool.ProvisioningStatesSucceeded),
	// 			Sessions: []*string{
	// 				to.Ptr("iqn.2005-03.org.iscsi:client")},
	// 				StaticACLs: []*armstoragepool.ACL{
	// 					{
	// 						InitiatorIqn: to.Ptr("iqn.2005-03.org.iscsi:client"),
	// 						MappedLuns: []*string{
	// 							to.Ptr("lun0")},
	// 					}},
	// 					Status: to.Ptr(armstoragepool.OperationalStatusHealthy),
	// 					TargetIqn: to.Ptr("iqn.2005-03.org.iscsi:server1"),
	// 				},
	// 				SystemData: &armstoragepool.SystemMetadata{
	// 					CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-06-24T06:53:57.000Z"); return t}()),
	// 					CreatedBy: to.Ptr("alias"),
	// 					CreatedByType: to.Ptr(armstoragepool.CreatedByTypeUser),
	// 					LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-06-24T06:53:57.000Z"); return t}()),
	// 					LastModifiedBy: to.Ptr("alias"),
	// 					LastModifiedByType: to.Ptr(armstoragepool.CreatedByTypeUser),
	// 				},
	// 			}
}

Output:

func (*IscsiTargetsClient) NewListByDiskPoolPager added in v0.4.0 

func (client *IscsiTargetsClient) NewListByDiskPoolPager(resourceGroupName string, diskPoolName string, options *IscsiTargetsClientListByDiskPoolOptions) *runtime.Pager[IscsiTargetsClientListByDiskPoolResponse]

NewListByDiskPoolPager - Get iSCSI Targets in a Disk pool.

Generated from API version 2021-08-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • diskPoolName - The name of the Disk Pool.
  • options - IscsiTargetsClientListByDiskPoolOptions contains the optional parameters for the IscsiTargetsClient.NewListByDiskPoolPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/storagepool/resource-manager/Microsoft.StoragePool/stable/2021-08-01/examples/IscsiTargets_ListByDiskPool.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storagepool/armstoragepool"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstoragepool.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewIscsiTargetsClient().NewListByDiskPoolPager("myResourceGroup", "myDiskPool", nil)
	for pager.More() {
		page, err := pager.NextPage(ctx)
		if err != nil {
			log.Fatalf("failed to advance page: %v", err)
		}
		for _, v := range page.Value {
			// You could use page here. We use blank identifier for just demo purposes.
			_ = v
		}
		// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
		// page.IscsiTargetList = armstoragepool.IscsiTargetList{
		// 	Value: []*armstoragepool.IscsiTarget{
		// 		{
		// 			Name: to.Ptr("myIscsiTarget"),
		// 			Type: to.Ptr("Microsoft.StoragePool/diskPools/iscsiTargets"),
		// 			ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/myResourceGroup/providers/Microsoft.StoragePool/diskPools/myDiskPool/iscsiTargets/myIscsiTarget"),
		// 			ManagedBy: to.Ptr("/subscriptions/11111111-1111-1111-1111-111111111111/resourceGroups/myResourceGroup/providers/Microsoft.AVS/privateClouds/myPrivateCloud/clusters/Cluster-1/datastores/datastore1"),
		// 			ManagedByExtended: []*string{
		// 				to.Ptr("/subscriptions/11111111-1111-1111-1111-111111111111/resourceGroups/myResourceGroup/providers/Microsoft.AVS/privateClouds/myPrivateCloud/clusters/Cluster-1/datastores/datastore1"),
		// 				to.Ptr("/subscriptions/11111111-1111-1111-1111-111111111111/resourceGroups/myResourceGroup/providers/Microsoft.AVS/privateClouds/myPrivateCloud/clusters/Cluster-1/datastores/datastore2")},
		// 				Properties: &armstoragepool.IscsiTargetProperties{
		// 					ACLMode: to.Ptr(armstoragepool.IscsiTargetACLModeStatic),
		// 					Endpoints: []*string{
		// 						to.Ptr("10.0.0.1:3260")},
		// 						Luns: []*armstoragepool.IscsiLun{
		// 							{
		// 								Name: to.Ptr("lun0"),
		// 								Lun: to.Ptr[int32](3),
		// 								ManagedDiskAzureResourceID: to.Ptr("/subscriptions/11111111-1111-1111-1111-111111111111/resourceGroups/myResourceGroup/providers/Microsoft.Compute/disks/vm-name_DataDisk_1"),
		// 						}},
		// 						Port: to.Ptr[int32](3260),
		// 						ProvisioningState: to.Ptr(armstoragepool.ProvisioningStatesSucceeded),
		// 						Sessions: []*string{
		// 							to.Ptr("iqn.2005-03.org.iscsi:client")},
		// 							StaticACLs: []*armstoragepool.ACL{
		// 								{
		// 									InitiatorIqn: to.Ptr("iqn.2005-03.org.iscsi:client"),
		// 									MappedLuns: []*string{
		// 										to.Ptr("lun0")},
		// 								}},
		// 								Status: to.Ptr(armstoragepool.OperationalStatusHealthy),
		// 								TargetIqn: to.Ptr("iqn.2005-03.org.iscsi:server1"),
		// 							},
		// 							SystemData: &armstoragepool.SystemMetadata{
		// 								CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-06-24T06:53:57.000Z"); return t}()),
		// 								CreatedBy: to.Ptr("alias"),
		// 								CreatedByType: to.Ptr(armstoragepool.CreatedByTypeUser),
		// 								LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-06-24T06:53:57.000Z"); return t}()),
		// 								LastModifiedBy: to.Ptr("alias"),
		// 								LastModifiedByType: to.Ptr(armstoragepool.CreatedByTypeUser),
		// 							},
		// 						},
		// 						{
		// 							Name: to.Ptr("myIscsiTarget2"),
		// 							Type: to.Ptr("Microsoft.StoragePool/diskPools/iscsiTargets"),
		// 							ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/myResourceGroup/providers/Microsoft.StoragePool/diskPools/myDiskPool/iscsiTargets/myIscsiTarget"),
		// 							ManagedBy: to.Ptr("/subscriptions/11111111-1111-1111-1111-111111111111/resourceGroups/myResourceGroup/providers/Microsoft.AVS/privateClouds/myPrivateCloud/clusters/Cluster-1/datastores/datastore1"),
		// 							ManagedByExtended: []*string{
		// 								to.Ptr("/subscriptions/11111111-1111-1111-1111-111111111111/resourceGroups/myResourceGroup/providers/Microsoft.AVS/privateClouds/myPrivateCloud/clusters/Cluster-1/datastores/datastore1"),
		// 								to.Ptr("/subscriptions/11111111-1111-1111-1111-111111111111/resourceGroups/myResourceGroup/providers/Microsoft.AVS/privateClouds/myPrivateCloud/clusters/Cluster-1/datastores/datastore2")},
		// 								Properties: &armstoragepool.IscsiTargetProperties{
		// 									ACLMode: to.Ptr(armstoragepool.IscsiTargetACLModeDynamic),
		// 									Endpoints: []*string{
		// 										to.Ptr("10.0.0.1:3261")},
		// 										Luns: []*armstoragepool.IscsiLun{
		// 											{
		// 												Name: to.Ptr("lun0"),
		// 												Lun: to.Ptr[int32](2),
		// 												ManagedDiskAzureResourceID: to.Ptr("/subscriptions/11111111-1111-1111-1111-111111111111/resourceGroups/myResourceGroup/providers/Microsoft.Compute/disks/vm-name_DataDisk_2"),
		// 										}},
		// 										Port: to.Ptr[int32](3261),
		// 										ProvisioningState: to.Ptr(armstoragepool.ProvisioningStatesSucceeded),
		// 										Sessions: []*string{
		// 											to.Ptr("iqn.2005-03.org.iscsi:client")},
		// 											StaticACLs: []*armstoragepool.ACL{
		// 											},
		// 											Status: to.Ptr(armstoragepool.OperationalStatusHealthy),
		// 											TargetIqn: to.Ptr("iqn.2005-03.org.iscsi:server2"),
		// 										},
		// 										SystemData: &armstoragepool.SystemMetadata{
		// 											CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-06-24T06:53:57.000Z"); return t}()),
		// 											CreatedBy: to.Ptr("alias"),
		// 											CreatedByType: to.Ptr(armstoragepool.CreatedByTypeUser),
		// 											LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-06-24T06:53:57.000Z"); return t}()),
		// 											LastModifiedBy: to.Ptr("alias"),
		// 											LastModifiedByType: to.Ptr(armstoragepool.CreatedByTypeUser),
		// 										},
		// 								}},
		// 							}
	}
}

Output:

type IscsiTargetsClientBeginCreateOrUpdateOptions added in v0.2.0 

type IscsiTargetsClientBeginCreateOrUpdateOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

IscsiTargetsClientBeginCreateOrUpdateOptions contains the optional parameters for the IscsiTargetsClient.BeginCreateOrUpdate method.

type IscsiTargetsClientBeginDeleteOptions added in v0.2.0 

type IscsiTargetsClientBeginDeleteOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

IscsiTargetsClientBeginDeleteOptions contains the optional parameters for the IscsiTargetsClient.BeginDelete method.

type IscsiTargetsClientBeginUpdateOptions added in v0.2.0 

type IscsiTargetsClientBeginUpdateOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

IscsiTargetsClientBeginUpdateOptions contains the optional parameters for the IscsiTargetsClient.BeginUpdate method.

type IscsiTargetsClientCreateOrUpdateResponse added in v0.2.0 

type IscsiTargetsClientCreateOrUpdateResponse struct {
	// Response for iSCSI Target requests.
	IscsiTarget
}

IscsiTargetsClientCreateOrUpdateResponse contains the response from method IscsiTargetsClient.BeginCreateOrUpdate.

type IscsiTargetsClientDeleteResponse added in v0.2.0 

type IscsiTargetsClientDeleteResponse struct {
}

IscsiTargetsClientDeleteResponse contains the response from method IscsiTargetsClient.BeginDelete.

type IscsiTargetsClientGetOptions added in v0.2.0 

type IscsiTargetsClientGetOptions struct {
}

IscsiTargetsClientGetOptions contains the optional parameters for the IscsiTargetsClient.Get method.

type IscsiTargetsClientGetResponse added in v0.2.0 

type IscsiTargetsClientGetResponse struct {
	// Response for iSCSI Target requests.
	IscsiTarget
}

IscsiTargetsClientGetResponse contains the response from method IscsiTargetsClient.Get.

type IscsiTargetsClientListByDiskPoolOptions added in v0.2.0 

type IscsiTargetsClientListByDiskPoolOptions struct {
}

IscsiTargetsClientListByDiskPoolOptions contains the optional parameters for the IscsiTargetsClient.NewListByDiskPoolPager method.

type IscsiTargetsClientListByDiskPoolResponse added in v0.2.0 

type IscsiTargetsClientListByDiskPoolResponse struct {
	// List of iSCSI Targets.
	IscsiTargetList
}

IscsiTargetsClientListByDiskPoolResponse contains the response from method IscsiTargetsClient.NewListByDiskPoolPager.

type IscsiTargetsClientUpdateResponse added in v0.2.0 

type IscsiTargetsClientUpdateResponse struct {
	// Response for iSCSI Target requests.
	IscsiTarget
}

IscsiTargetsClientUpdateResponse contains the response from method IscsiTargetsClient.BeginUpdate.

type OperationDisplay added in v0.2.0 

type OperationDisplay struct {
	// REQUIRED; Localized friendly description for the operation, as it should be shown to the user.
	Description *string

	// REQUIRED; Localized friendly name for the operation, as it should be shown to the user.
	Operation *string

	// REQUIRED; Localized friendly form of the resource provider name.
	Provider *string

	// REQUIRED; Localized friendly form of the resource type related to this action/operation.
	Resource *string
}

OperationDisplay - Metadata about an operation.

func (OperationDisplay) MarshalJSON added in v1.1.0 

func (o OperationDisplay) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type OperationDisplay.

func (*OperationDisplay) UnmarshalJSON added in v1.1.0 

func (o *OperationDisplay) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type OperationDisplay.

type OperationListResult added in v0.2.0 

type OperationListResult struct {
	// REQUIRED; An array of operations supported by the StoragePool RP.
	Value []*RPOperation

	// URI to fetch the next section of the paginated response.
	NextLink *string
}

OperationListResult - List of operations supported by the RP.

func (OperationListResult) MarshalJSON added in v0.2.0 

func (o OperationListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type OperationListResult.

func (*OperationListResult) UnmarshalJSON added in v1.1.0 

func (o *OperationListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type OperationListResult.

type OperationalStatus 

type OperationalStatus string

OperationalStatus - Operational status of the resource. 

const (
	OperationalStatusHealthy            OperationalStatus = "Healthy"
	OperationalStatusInvalid            OperationalStatus = "Invalid"
	OperationalStatusRunning            OperationalStatus = "Running"
	OperationalStatusStopped            OperationalStatus = "Stopped"
	OperationalStatusStoppedDeallocated OperationalStatus = "Stopped (deallocated)"
	OperationalStatusUnhealthy          OperationalStatus = "Unhealthy"
	OperationalStatusUnknown            OperationalStatus = "Unknown"
	OperationalStatusUpdating           OperationalStatus = "Updating"
)

func PossibleOperationalStatusValues 

func PossibleOperationalStatusValues() []OperationalStatus

PossibleOperationalStatusValues returns the possible values for the OperationalStatus const type.

type OperationsClient 

type OperationsClient struct {
	// contains filtered or unexported fields
}

OperationsClient contains the methods for the Operations group. Don't use this type directly, use NewOperationsClient() instead.

func NewOperationsClient 

func NewOperationsClient(credential azcore.TokenCredential, options *arm.ClientOptions) (*OperationsClient, error)

NewOperationsClient creates a new instance of OperationsClient with the specified values.

  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*OperationsClient) NewListPager added in v0.4.0 

func (client *OperationsClient) NewListPager(options *OperationsClientListOptions) *runtime.Pager[OperationsClientListResponse]

NewListPager - Gets a list of StoragePool operations.

Generated from API version 2021-08-01

  • options - OperationsClientListOptions contains the optional parameters for the OperationsClient.NewListPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/storagepool/resource-manager/Microsoft.StoragePool/stable/2021-08-01/examples/Operations_List.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storagepool/armstoragepool"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstoragepool.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewOperationsClient().NewListPager(nil)
	for pager.More() {
		page, err := pager.NextPage(ctx)
		if err != nil {
			log.Fatalf("failed to advance page: %v", err)
		}
		for _, v := range page.Value {
			// You could use page here. We use blank identifier for just demo purposes.
			_ = v
		}
		// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
		// page.OperationListResult = armstoragepool.OperationListResult{
		// 	Value: []*armstoragepool.RPOperation{
		// 		{
		// 			Name: to.Ptr("Microsoft.StoragePool/diskPools/read"),
		// 			Display: &armstoragepool.OperationDisplay{
		// 				Description: to.Ptr("Read Disk Pool"),
		// 				Operation: to.Ptr("Read Microsoft.StoragePool/diskPools"),
		// 				Provider: to.Ptr("Microsoft.StoragePool"),
		// 				Resource: to.Ptr("Disk Pool"),
		// 			},
		// 			IsDataAction: to.Ptr(true),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StoragePool/diskPools/write"),
		// 			Display: &armstoragepool.OperationDisplay{
		// 				Description: to.Ptr("Create or Update Disk Pool"),
		// 				Operation: to.Ptr("Create or Update Microsoft.StoragePool/diskPools"),
		// 				Provider: to.Ptr("Microsoft.StoragePool"),
		// 				Resource: to.Ptr("Disk Pool"),
		// 			},
		// 			IsDataAction: to.Ptr(true),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StoragePool/diskPools/delete"),
		// 			Display: &armstoragepool.OperationDisplay{
		// 				Description: to.Ptr("Delete Disk Pool"),
		// 				Operation: to.Ptr("Delete Microsoft.StoragePool/diskPools"),
		// 				Provider: to.Ptr("Microsoft.StoragePool"),
		// 				Resource: to.Ptr("Microsoft.StoragePool/diskPools"),
		// 			},
		// 			IsDataAction: to.Ptr(true),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StoragePool/diskPools/start/action"),
		// 			Display: &armstoragepool.OperationDisplay{
		// 				Description: to.Ptr("Start Disk Pool"),
		// 				Operation: to.Ptr("Start Microsoft.StoragePool/diskPools"),
		// 				Provider: to.Ptr("Microsoft.StoragePool"),
		// 				Resource: to.Ptr("Microsoft.StoragePool/diskPools"),
		// 			},
		// 			IsDataAction: to.Ptr(false),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StoragePool/diskPools/deallocate/action"),
		// 			Display: &armstoragepool.OperationDisplay{
		// 				Description: to.Ptr("Deallocate Disk Pool"),
		// 				Operation: to.Ptr("Deallocate Microsoft.StoragePool/diskPools"),
		// 				Provider: to.Ptr("Microsoft.StoragePool"),
		// 				Resource: to.Ptr("Microsoft.StoragePool/diskPools"),
		// 			},
		// 			IsDataAction: to.Ptr(false),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StoragePool/diskPools/iscsiTargets/read"),
		// 			Display: &armstoragepool.OperationDisplay{
		// 				Description: to.Ptr("Read iSCSI targets"),
		// 				Operation: to.Ptr("Read Microsoft.StoragePool/diskPools/iscsiTargets"),
		// 				Provider: to.Ptr("Microsoft.StoragePool"),
		// 				Resource: to.Ptr("iSCSI targets"),
		// 			},
		// 			IsDataAction: to.Ptr(true),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StoragePool/diskPools/iscsiTargets/write"),
		// 			Display: &armstoragepool.OperationDisplay{
		// 				Description: to.Ptr("Create or Update iSCSI targets"),
		// 				Operation: to.Ptr("Create or Update Microsoft.StoragePool/diskPools/iscsiTargets"),
		// 				Provider: to.Ptr("Microsoft.StoragePool"),
		// 				Resource: to.Ptr("iSCSI targets"),
		// 			},
		// 			IsDataAction: to.Ptr(true),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.StoragePool/diskPools/iscsiTargets/delete"),
		// 			Display: &armstoragepool.OperationDisplay{
		// 				Description: to.Ptr("Delete iSCSI targets"),
		// 				Operation: to.Ptr("Delete Microsoft.StoragePool/diskPools/iscsiTargets"),
		// 				Provider: to.Ptr("Microsoft.StoragePool"),
		// 				Resource: to.Ptr("iSCSI targets"),
		// 			},
		// 			IsDataAction: to.Ptr(true),
		// 	}},
		// }
	}
}

Output:

type OperationsClientListOptions added in v0.2.0 

type OperationsClientListOptions struct {
}

OperationsClientListOptions contains the optional parameters for the OperationsClient.NewListPager method.

type OperationsClientListResponse added in v0.2.0 

type OperationsClientListResponse struct {
	// List of operations supported by the RP.
	OperationListResult
}

OperationsClientListResponse contains the response from method OperationsClient.NewListPager.

type OutboundEnvironmentEndpoint 

type OutboundEnvironmentEndpoint struct {
	// The type of service accessed by the App Service Environment, e.g., Azure Storage, Azure SQL Database, and Azure Active
	// Directory.
	Category *string

	// The endpoints that the App Service Environment reaches the service at.
	Endpoints []*EndpointDependency
}

OutboundEnvironmentEndpoint - Endpoints accessed for a common purpose that the App Service Environment requires outbound network access to.

func (OutboundEnvironmentEndpoint) MarshalJSON 

func (o OutboundEnvironmentEndpoint) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type OutboundEnvironmentEndpoint.

func (*OutboundEnvironmentEndpoint) UnmarshalJSON added in v1.1.0 

func (o *OutboundEnvironmentEndpoint) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type OutboundEnvironmentEndpoint.

type OutboundEnvironmentEndpointList 

type OutboundEnvironmentEndpointList struct {
	// REQUIRED; Collection of resources.
	Value []*OutboundEnvironmentEndpoint

	// READ-ONLY; Link to next page of resources.
	NextLink *string
}

OutboundEnvironmentEndpointList - Collection of Outbound Environment Endpoints

func (OutboundEnvironmentEndpointList) MarshalJSON 

func (o OutboundEnvironmentEndpointList) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type OutboundEnvironmentEndpointList.

func (*OutboundEnvironmentEndpointList) UnmarshalJSON added in v1.1.0 

func (o *OutboundEnvironmentEndpointList) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type OutboundEnvironmentEndpointList.

type ProvisioningStates 

type ProvisioningStates string

ProvisioningStates - Provisioning state of the iSCSI Target. 

const (
	ProvisioningStatesCanceled  ProvisioningStates = "Canceled"
	ProvisioningStatesCreating  ProvisioningStates = "Creating"
	ProvisioningStatesDeleting  ProvisioningStates = "Deleting"
	ProvisioningStatesFailed    ProvisioningStates = "Failed"
	ProvisioningStatesInvalid   ProvisioningStates = "Invalid"
	ProvisioningStatesPending   ProvisioningStates = "Pending"
	ProvisioningStatesSucceeded ProvisioningStates = "Succeeded"
	ProvisioningStatesUpdating  ProvisioningStates = "Updating"
)

func PossibleProvisioningStatesValues 

func PossibleProvisioningStatesValues() []ProvisioningStates

PossibleProvisioningStatesValues returns the possible values for the ProvisioningStates const type.

type ProxyResource 

type ProxyResource struct {
	// READ-ONLY; Fully qualified resource Id for the resource. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}
	ID *string

	// READ-ONLY; The name of the resource
	Name *string

	// READ-ONLY; The type of the resource. Ex- Microsoft.Compute/virtualMachines or Microsoft.Storage/storageAccounts.
	Type *string
}

ProxyResource - The resource model definition for a ARM proxy resource. It will have everything other than required location and tags

func (ProxyResource) MarshalJSON added in v1.1.0 

func (p ProxyResource) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ProxyResource.

func (*ProxyResource) UnmarshalJSON added in v1.1.0 

func (p *ProxyResource) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ProxyResource.

type RPOperation added in v0.2.0 

type RPOperation struct {
	// REQUIRED; Additional metadata about RP operation.
	Display *OperationDisplay

	// REQUIRED; Indicates whether the operation applies to data-plane.
	IsDataAction *bool

	// REQUIRED; The name of the operation being performed on this particular object
	Name *string

	// Indicates the action type.
	ActionType *string

	// The intended executor of the operation; governs the display of the operation in the RBAC UX and the audit logs UX.
	Origin *string
}

RPOperation - Description of a StoragePool RP Operation

func (RPOperation) MarshalJSON added in v1.1.0 

func (r RPOperation) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type RPOperation.

func (*RPOperation) UnmarshalJSON added in v1.1.0 

func (r *RPOperation) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type RPOperation.

type Resource 

type Resource struct {
	// READ-ONLY; Fully qualified resource Id for the resource. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}
	ID *string

	// READ-ONLY; The name of the resource
	Name *string

	// READ-ONLY; The type of the resource. Ex- Microsoft.Compute/virtualMachines or Microsoft.Storage/storageAccounts.
	Type *string
}

Resource - ARM resource model definition.

func (Resource) MarshalJSON 

func (r Resource) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type Resource.

func (*Resource) UnmarshalJSON added in v1.1.0 

func (r *Resource) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type Resource.

type ResourceSKUCapability 

type ResourceSKUCapability struct {
	// READ-ONLY; Capability name
	Name *string

	// READ-ONLY; Capability value
	Value *string
}

ResourceSKUCapability - Capability a resource SKU has.

func (ResourceSKUCapability) MarshalJSON added in v1.1.0 

func (r ResourceSKUCapability) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ResourceSKUCapability.

func (*ResourceSKUCapability) UnmarshalJSON added in v1.1.0 

func (r *ResourceSKUCapability) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ResourceSKUCapability.

type ResourceSKUInfo 

type ResourceSKUInfo struct {
	// READ-ONLY; StoragePool RP API version
	APIVersion *string

	// READ-ONLY; List of additional capabilities for StoragePool resource.
	Capabilities []*ResourceSKUCapability

	// READ-ONLY; Zones and zone capabilities in those locations where the SKU is available.
	LocationInfo *ResourceSKULocationInfo

	// READ-ONLY; Sku name
	Name *string

	// READ-ONLY; StoragePool resource type
	ResourceType *string

	// READ-ONLY; The restrictions because of which SKU cannot be used. This is empty if there are no restrictions.
	Restrictions []*ResourceSKURestrictions

	// READ-ONLY; Sku tier
	Tier *string
}

ResourceSKUInfo - Resource SKU Details

func (ResourceSKUInfo) MarshalJSON 

func (r ResourceSKUInfo) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ResourceSKUInfo.

func (*ResourceSKUInfo) UnmarshalJSON added in v1.1.0 

func (r *ResourceSKUInfo) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ResourceSKUInfo.

type ResourceSKUListResult 

type ResourceSKUListResult struct {
	// URI to fetch the next section of the paginated response.
	NextLink *string

	// The list of StoragePool resource skus.
	Value []*ResourceSKUInfo
}

ResourceSKUListResult - List Disk Pool skus operation response.

func (ResourceSKUListResult) MarshalJSON 

func (r ResourceSKUListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ResourceSKUListResult.

func (*ResourceSKUListResult) UnmarshalJSON added in v1.1.0 

func (r *ResourceSKUListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ResourceSKUListResult.

type ResourceSKULocationInfo 

type ResourceSKULocationInfo struct {
	// READ-ONLY; Location of the SKU
	Location *string

	// READ-ONLY; Details of capabilities available to a SKU in specific zones.
	ZoneDetails []*ResourceSKUZoneDetails

	// READ-ONLY; List of availability zones where the SKU is supported.
	Zones []*string
}

ResourceSKULocationInfo - Zone and capability info for resource sku

func (ResourceSKULocationInfo) MarshalJSON 

func (r ResourceSKULocationInfo) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ResourceSKULocationInfo.

func (*ResourceSKULocationInfo) UnmarshalJSON added in v1.1.0 

func (r *ResourceSKULocationInfo) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ResourceSKULocationInfo.

type ResourceSKURestrictionInfo 

type ResourceSKURestrictionInfo struct {
	// READ-ONLY; Locations where the SKU is restricted
	Locations []*string

	// READ-ONLY; List of availability zones where the SKU is restricted.
	Zones []*string
}

ResourceSKURestrictionInfo - Describes an available Compute SKU Restriction Information.

func (ResourceSKURestrictionInfo) MarshalJSON 

func (r ResourceSKURestrictionInfo) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ResourceSKURestrictionInfo.

func (*ResourceSKURestrictionInfo) UnmarshalJSON added in v1.1.0 

func (r *ResourceSKURestrictionInfo) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ResourceSKURestrictionInfo.

type ResourceSKURestrictions 

type ResourceSKURestrictions struct {
	// READ-ONLY; The reason for restriction.
	ReasonCode *ResourceSKURestrictionsReasonCode

	// READ-ONLY; The information about the restriction where the SKU cannot be used.
	RestrictionInfo *ResourceSKURestrictionInfo

	// READ-ONLY; The type of restrictions.
	Type *ResourceSKURestrictionsType

	// READ-ONLY; The value of restrictions. If the restriction type is set to location. This would be different locations where
	// the SKU is restricted.
	Values []*string
}

ResourceSKURestrictions - Describes scaling information of a SKU.

func (ResourceSKURestrictions) MarshalJSON 

func (r ResourceSKURestrictions) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ResourceSKURestrictions.

func (*ResourceSKURestrictions) UnmarshalJSON added in v1.1.0 

func (r *ResourceSKURestrictions) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ResourceSKURestrictions.

type ResourceSKURestrictionsReasonCode 

type ResourceSKURestrictionsReasonCode string

ResourceSKURestrictionsReasonCode - The reason for restriction. 

const (
	ResourceSKURestrictionsReasonCodeNotAvailableForSubscription ResourceSKURestrictionsReasonCode = "NotAvailableForSubscription"
	ResourceSKURestrictionsReasonCodeQuotaID                     ResourceSKURestrictionsReasonCode = "QuotaId"
)

func PossibleResourceSKURestrictionsReasonCodeValues 

func PossibleResourceSKURestrictionsReasonCodeValues() []ResourceSKURestrictionsReasonCode

PossibleResourceSKURestrictionsReasonCodeValues returns the possible values for the ResourceSKURestrictionsReasonCode const type.

type ResourceSKURestrictionsType 

type ResourceSKURestrictionsType string

ResourceSKURestrictionsType - The type of restrictions. 

const (
	ResourceSKURestrictionsTypeLocation ResourceSKURestrictionsType = "Location"
	ResourceSKURestrictionsTypeZone     ResourceSKURestrictionsType = "Zone"
)

func PossibleResourceSKURestrictionsTypeValues 

func PossibleResourceSKURestrictionsTypeValues() []ResourceSKURestrictionsType

PossibleResourceSKURestrictionsTypeValues returns the possible values for the ResourceSKURestrictionsType const type.

type ResourceSKUZoneDetails 

type ResourceSKUZoneDetails struct {
	// READ-ONLY; A list of capabilities that are available for the SKU in the specified list of zones.
	Capabilities []*ResourceSKUCapability

	// READ-ONLY; The set of zones that the SKU is available in with the specified capabilities.
	Name []*string
}

ResourceSKUZoneDetails - Describes The zonal capabilities of a SKU.

func (ResourceSKUZoneDetails) MarshalJSON 

func (r ResourceSKUZoneDetails) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ResourceSKUZoneDetails.

func (*ResourceSKUZoneDetails) UnmarshalJSON added in v1.1.0 

func (r *ResourceSKUZoneDetails) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ResourceSKUZoneDetails.

type ResourceSKUsClient 

type ResourceSKUsClient struct {
	// contains filtered or unexported fields
}

ResourceSKUsClient contains the methods for the ResourceSKUs group. Don't use this type directly, use NewResourceSKUsClient() instead.

func NewResourceSKUsClient 

func NewResourceSKUsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*ResourceSKUsClient, error)

NewResourceSKUsClient creates a new instance of ResourceSKUsClient with the specified values.

  • subscriptionID - The ID of the target subscription.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*ResourceSKUsClient) NewListPager added in v0.4.0 

func (client *ResourceSKUsClient) NewListPager(location string, options *ResourceSKUsClientListOptions) *runtime.Pager[ResourceSKUsClientListResponse]

NewListPager - Lists available StoragePool resources and skus in an Azure location.

Generated from API version 2021-08-01

  • location - The location of the resource.
  • options - ResourceSKUsClientListOptions contains the optional parameters for the ResourceSKUsClient.NewListPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/storagepool/resource-manager/Microsoft.StoragePool/stable/2021-08-01/examples/Skus_List.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storagepool/armstoragepool"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstoragepool.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewResourceSKUsClient().NewListPager("eastus", nil)
	for pager.More() {
		page, err := pager.NextPage(ctx)
		if err != nil {
			log.Fatalf("failed to advance page: %v", err)
		}
		for _, v := range page.Value {
			// You could use page here. We use blank identifier for just demo purposes.
			_ = v
		}
		// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
		// page.ResourceSKUListResult = armstoragepool.ResourceSKUListResult{
		// 	Value: []*armstoragepool.ResourceSKUInfo{
		// 		{
		// 			Name: to.Ptr("Standard_V1"),
		// 			APIVersion: to.Ptr("2021-08-01"),
		// 			Capabilities: []*armstoragepool.ResourceSKUCapability{
		// 				{
		// 					Name: to.Ptr("MaxNumberOfDisks"),
		// 					Value: to.Ptr("1"),
		// 			}},
		// 			LocationInfo: &armstoragepool.ResourceSKULocationInfo{
		// 				Location: to.Ptr("eastus"),
		// 				ZoneDetails: []*armstoragepool.ResourceSKUZoneDetails{
		// 					{
		// 						Name: []*string{
		// 							to.Ptr("2")},
		// 							Capabilities: []*armstoragepool.ResourceSKUCapability{
		// 								{
		// 									Name: to.Ptr("DiskPool.CapabilityA"),
		// 									Value: to.Ptr("True"),
		// 							}},
		// 						},
		// 						{
		// 							Name: []*string{
		// 								to.Ptr("1")},
		// 								Capabilities: []*armstoragepool.ResourceSKUCapability{
		// 									{
		// 										Name: to.Ptr("DiskPool.CapabilityA"),
		// 										Value: to.Ptr("True"),
		// 									},
		// 									{
		// 										Name: to.Ptr("DiskPool.CapabilityB"),
		// 										Value: to.Ptr("True"),
		// 								}},
		// 						}},
		// 						Zones: []*string{
		// 							to.Ptr("2"),
		// 							to.Ptr("1")},
		// 						},
		// 						ResourceType: to.Ptr("diskPools"),
		// 						Restrictions: []*armstoragepool.ResourceSKURestrictions{
		// 							{
		// 								Type: to.Ptr(armstoragepool.ResourceSKURestrictionsTypeLocation),
		// 								ReasonCode: to.Ptr(armstoragepool.ResourceSKURestrictionsReasonCodeNotAvailableForSubscription),
		// 								RestrictionInfo: &armstoragepool.ResourceSKURestrictionInfo{
		// 									Locations: []*string{
		// 										to.Ptr("FranceSouth")},
		// 									},
		// 									Values: []*string{
		// 										to.Ptr("FranceSouth")},
		// 									},
		// 									{
		// 										Type: to.Ptr(armstoragepool.ResourceSKURestrictionsTypeZone),
		// 										ReasonCode: to.Ptr(armstoragepool.ResourceSKURestrictionsReasonCodeNotAvailableForSubscription),
		// 										RestrictionInfo: &armstoragepool.ResourceSKURestrictionInfo{
		// 											Locations: []*string{
		// 												to.Ptr("FranceCentral")},
		// 												Zones: []*string{
		// 													to.Ptr("2"),
		// 													to.Ptr("3"),
		// 													to.Ptr("1")},
		// 												},
		// 												Values: []*string{
		// 													to.Ptr("FranceCentral")},
		// 											}},
		// 											Tier: to.Ptr("Standard"),
		// 										},
		// 										{
		// 											Name: to.Ptr("Standard_V1"),
		// 											Capabilities: []*armstoragepool.ResourceSKUCapability{
		// 												{
		// 													Name: to.Ptr("MaxNumberOfDisks"),
		// 													Value: to.Ptr("1"),
		// 											}},
		// 											LocationInfo: &armstoragepool.ResourceSKULocationInfo{
		// 												Location: to.Ptr("eastus"),
		// 												ZoneDetails: []*armstoragepool.ResourceSKUZoneDetails{
		// 													{
		// 														Name: []*string{
		// 															to.Ptr("2")},
		// 															Capabilities: []*armstoragepool.ResourceSKUCapability{
		// 																{
		// 																	Name: to.Ptr("UltraSSDAvailable"),
		// 																	Value: to.Ptr("True"),
		// 															}},
		// 														},
		// 														{
		// 															Name: []*string{
		// 																to.Ptr("1")},
		// 																Capabilities: []*armstoragepool.ResourceSKUCapability{
		// 																	{
		// 																		Name: to.Ptr("UltraSSDAvailable"),
		// 																		Value: to.Ptr("True"),
		// 																}},
		// 														}},
		// 														Zones: []*string{
		// 															to.Ptr("2"),
		// 															to.Ptr("1")},
		// 														},
		// 														ResourceType: to.Ptr("diskPools"),
		// 														Tier: to.Ptr("Standard"),
		// 												}},
		// 											}
	}
}

Output:

type ResourceSKUsClientListOptions added in v0.2.0 

type ResourceSKUsClientListOptions struct {
}

ResourceSKUsClientListOptions contains the optional parameters for the ResourceSKUsClient.NewListPager method.

type ResourceSKUsClientListResponse added in v0.2.0 

type ResourceSKUsClientListResponse struct {
	// List Disk Pool skus operation response.
	ResourceSKUListResult
}

ResourceSKUsClientListResponse contains the response from method ResourceSKUsClient.NewListPager.

type SKU 

type SKU struct {
	// REQUIRED; Sku name
	Name *string

	// Sku tier
	Tier *string
}

SKU - Sku for ARM resource

func (SKU) MarshalJSON added in v1.1.0 

func (s SKU) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type SKU.

func (*SKU) UnmarshalJSON added in v1.1.0 

func (s *SKU) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type SKU.

type SystemMetadata 

type SystemMetadata struct {
	// The timestamp of resource creation (UTC).
	CreatedAt *time.Time

	// The identity that created the resource.
	CreatedBy *string

	// The type of identity that created the resource.
	CreatedByType *CreatedByType

	// The type of identity that last modified the resource.
	LastModifiedAt *time.Time

	// The identity that last modified the resource.
	LastModifiedBy *string

	// The type of identity that last modified the resource.
	LastModifiedByType *CreatedByType
}

SystemMetadata - Metadata pertaining to creation and last modification of the resource.

func (SystemMetadata) MarshalJSON 

func (s SystemMetadata) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type SystemMetadata.

func (*SystemMetadata) UnmarshalJSON 

func (s *SystemMetadata) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type SystemMetadata.

type TrackedResource 

type TrackedResource struct {
	// REQUIRED; The geo-location where the resource lives.
	Location *string

	// Resource tags.
	Tags map[string]*string

	// READ-ONLY; Fully qualified resource Id for the resource. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}
	ID *string

	// READ-ONLY; The name of the resource
	Name *string

	// READ-ONLY; The type of the resource. Ex- Microsoft.Compute/virtualMachines or Microsoft.Storage/storageAccounts.
	Type *string
}

TrackedResource - The resource model definition for a ARM tracked top level resource.

func (TrackedResource) MarshalJSON 

func (t TrackedResource) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type TrackedResource.

func (*TrackedResource) UnmarshalJSON added in v1.1.0 

func (t *TrackedResource) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type TrackedResource.

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.