armpurestorageblock

package module
v1.0.0 Latest Latest
Warning

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

 Go to latest Published: Jul 3, 2025 License: MIT Imports: 14 Imported by: 0

README

Azure Pure Storage Block Module for Go

The armpurestorageblock module provides operations for working with Azure Pure Storage Block.

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 Pure Storage Block module:

go get github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/purestorageblock/armpurestorageblock

Authorization

When creating a client, you will need to provide a credential for authenticating with Azure Pure Storage Block. 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 Pure Storage Block 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 := armpurestorageblock.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 := armpurestorageblock.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.NewAvsStorageContainerVolumesClient()

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 Purestorageblock 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 ActionType 

type ActionType string

ActionType - Extensible enum. Indicates the action type. "Internal" refers to actions that are for internal only APIs. 

const (
	// ActionTypeInternal - Actions are for internal-only APIs.
	ActionTypeInternal ActionType = "Internal"
)

func PossibleActionTypeValues 

func PossibleActionTypeValues() []ActionType

PossibleActionTypeValues returns the possible values for the ActionType const type.

type Address 

type Address struct {
	// REQUIRED; Address line 1
	AddressLine1 *string

	// REQUIRED; Name of the city
	City *string

	// REQUIRED; Name of the country
	Country *string

	// REQUIRED; Postal code
	PostalCode *string

	// REQUIRED; State (if any)
	State *string

	// Address line 2
	AddressLine2 *string
}

Address details

func (Address) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type Address.

func (*Address) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type Address.

type Alert 

type Alert struct {
	// REQUIRED; Severity level
	Level *AlertLevel

	// REQUIRED; A short description of the alert
	Message *string
}

Alert - Health alerts

func (Alert) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type Alert.

func (*Alert) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type Alert.

type AlertLevel 

type AlertLevel string

AlertLevel - Severity level of the alert 

const (
	// AlertLevelError - Error level
	AlertLevelError AlertLevel = "error"
	// AlertLevelInfo - Information level
	AlertLevelInfo AlertLevel = "info"
	// AlertLevelWarning - Warning level
	AlertLevelWarning AlertLevel = "warning"
)

func PossibleAlertLevelValues 

func PossibleAlertLevelValues() []AlertLevel

PossibleAlertLevelValues returns the possible values for the AlertLevel const type.

type AvsConnection 

type AvsConnection struct {
	// REQUIRED; Indicates whether service initialization is complete
	ServiceInitializationCompleted *bool

	// Explicit service account credentials
	ServiceInitializationHandle *ServiceInitializationHandle

	// Encoded service account credentials alongside connection information
	ServiceInitializationHandleEnc *string
}

AvsConnection - Transient information about an on-going connection to an AVS instance

func (AvsConnection) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type AvsConnection.

func (*AvsConnection) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AvsConnection.

type AvsDiskDetails 

type AvsDiskDetails struct {
	// REQUIRED; Azure resource ID of the AVS storage container containing this disk/volume
	AvsStorageContainerResourceID *string

	// REQUIRED; VMware ID assigned to the disk/volume
	AvsVMInternalID *string

	// REQUIRED; Name of the AVS VM connected to this disk/volume
	AvsVMName *string

	// REQUIRED; Azure resource ID of the AVS VM connected to this disk/volume
	AvsVMResourceID *string

	// REQUIRED; VMware ID of the disk/volume
	DiskID *string

	// REQUIRED; VMware name of the disk/volume
	DiskName *string

	// REQUIRED; Name of the top-level folder in the datastore that contains the disk/volume
	Folder *string
}

AvsDiskDetails - AVS disk/volume information

func (AvsDiskDetails) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type AvsDiskDetails.

func (*AvsDiskDetails) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AvsDiskDetails.

type AvsStatus 

type AvsStatus struct {
	// REQUIRED; If true, an AVS connection has been successfully completed
	AvsEnabled *bool

	// REQUIRED; Human-readable current AVS connection status
	CurrentConnectionStatus *string

	// Azure resource ID of the AVS SDDC the pool is connected to
	ClusterResourceID *string
}

AvsStatus - Status of storage pool / AVS connection

func (AvsStatus) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type AvsStatus.

func (*AvsStatus) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AvsStatus.

type AvsStorageContainer 

type AvsStorageContainer struct {
	// The resource-specific properties for this resource.
	Properties *AvsStorageContainerProperties

	// READ-ONLY; Name of the storage container
	Name *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 Manager metadata containing createdBy and modifiedBy information.
	SystemData *SystemData

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

AvsStorageContainer - AVS storage container resource type, representing a VMware storage container in a storage pool, which can be associated to and mounted as a datastore

func (AvsStorageContainer) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type AvsStorageContainer.

func (*AvsStorageContainer) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AvsStorageContainer.

type AvsStorageContainerListResult 

type AvsStorageContainerListResult struct {
	// REQUIRED; The AvsStorageContainer items on this page
	Value []*AvsStorageContainer

	// The link to the next page of items
	NextLink *string
}

AvsStorageContainerListResult - The response of a AvsStorageContainer list operation.

func (AvsStorageContainerListResult) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type AvsStorageContainerListResult.

func (*AvsStorageContainerListResult) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AvsStorageContainerListResult.

type AvsStorageContainerProperties 

type AvsStorageContainerProperties struct {
	// READ-ONLY; Name of the storage container
	ResourceName *string

	// Maximum amount of bytes that can be provisioned in this storage container; it must be a multiple of 512; each time a volume
	// is provisioned in this container, its provisionedSize will be counted against the provisionLimit and the provisioning will
	// fail if it goes over (minimum: 1048576 (1MiB), maximum: 4503599627370496 (4PiB)); by default it is unrestricted
	ProvisionedLimit *int64

	// READ-ONLY; VMware datastore associated with this storage container (if any)
	Datastore *string

	// READ-ONLY; Whether the datastore is mounted in VMware or not
	Mounted *bool

	// READ-ONLY; Storage space usage
	Space *Space
}

AvsStorageContainerProperties - AVS storage container properties

func (AvsStorageContainerProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type AvsStorageContainerProperties.

func (*AvsStorageContainerProperties) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AvsStorageContainerProperties.

type AvsStorageContainerVolume 

type AvsStorageContainerVolume struct {
	// The resource-specific properties for this resource.
	Properties *VolumeProperties

	// READ-ONLY; ID of the volume in the storage container
	Name *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 Manager metadata containing createdBy and modifiedBy information.
	SystemData *SystemData

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

AvsStorageContainerVolume - A volume contained in an AVS storage container

func (AvsStorageContainerVolume) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type AvsStorageContainerVolume.

func (*AvsStorageContainerVolume) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AvsStorageContainerVolume.

type AvsStorageContainerVolumeListResult 

type AvsStorageContainerVolumeListResult struct {
	// REQUIRED; The AvsStorageContainerVolume items on this page
	Value []*AvsStorageContainerVolume

	// The link to the next page of items
	NextLink *string
}

AvsStorageContainerVolumeListResult - The response of a AvsStorageContainerVolume list operation.

func (AvsStorageContainerVolumeListResult) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type AvsStorageContainerVolumeListResult.

func (*AvsStorageContainerVolumeListResult) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AvsStorageContainerVolumeListResult.

type AvsStorageContainerVolumeUpdate 

type AvsStorageContainerVolumeUpdate struct {
	// The resource-specific properties for this resource.
	Properties *AvsStorageContainerVolumeUpdateProperties
}

AvsStorageContainerVolumeUpdate - The type used for update operations of the AvsStorageContainerVolume.

func (AvsStorageContainerVolumeUpdate) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type AvsStorageContainerVolumeUpdate.

func (*AvsStorageContainerVolumeUpdate) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AvsStorageContainerVolumeUpdate.

type AvsStorageContainerVolumeUpdateProperties 

type AvsStorageContainerVolumeUpdateProperties struct {
	// Volume's soft-deletion state
	SoftDeletion *SoftDeletion
}

AvsStorageContainerVolumeUpdateProperties - The updatable properties of the AvsStorageContainerVolume.

func (AvsStorageContainerVolumeUpdateProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type AvsStorageContainerVolumeUpdateProperties.

func (*AvsStorageContainerVolumeUpdateProperties) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AvsStorageContainerVolumeUpdateProperties.

type AvsStorageContainerVolumesClient 

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

AvsStorageContainerVolumesClient contains the methods for the AvsStorageContainerVolumes group. Don't use this type directly, use NewAvsStorageContainerVolumesClient() instead.

func NewAvsStorageContainerVolumesClient 

func NewAvsStorageContainerVolumesClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*AvsStorageContainerVolumesClient, error)

NewAvsStorageContainerVolumesClient creates a new instance of AvsStorageContainerVolumesClient with the specified values.

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

func (*AvsStorageContainerVolumesClient) BeginDelete 

func (client *AvsStorageContainerVolumesClient) BeginDelete(ctx context.Context, resourceGroupName string, storagePoolName string, storageContainerName string, volumeID string, options *AvsStorageContainerVolumesClientBeginDeleteOptions) (*runtime.Poller[AvsStorageContainerVolumesClientDeleteResponse], error)

BeginDelete - Delete a volume in an AVS storage container If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • storagePoolName - Name of the storage pool
  • storageContainerName - Name of the storage container
  • volumeID - ID of the volume in the storage container
  • options - AvsStorageContainerVolumesClientBeginDeleteOptions contains the optional parameters for the AvsStorageContainerVolumesClient.BeginDelete method.
Example

Generated from example definition: 2024-11-01/AvsStorageContainerVolumes_Delete_MaximumSet_Gen.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/purestorageblock/armpurestorageblock"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armpurestorageblock.NewClientFactory("BC47D6CC-AA80-4374-86F8-19D94EC70666", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewAvsStorageContainerVolumesClient().BeginDelete(ctx, "rgpurestorage", "storagePoolname", "name", "cbdec-ddbb", 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)
	}
}

func (*AvsStorageContainerVolumesClient) BeginUpdate 

func (client *AvsStorageContainerVolumesClient) BeginUpdate(ctx context.Context, resourceGroupName string, storagePoolName string, storageContainerName string, volumeID string, properties AvsStorageContainerVolumeUpdate, options *AvsStorageContainerVolumesClientBeginUpdateOptions) (*runtime.Poller[AvsStorageContainerVolumesClientUpdateResponse], error)

BeginUpdate - Update a volume in an AVS storage container If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • storagePoolName - Name of the storage pool
  • storageContainerName - Name of the storage container
  • volumeID - ID of the volume in the storage container
  • properties - The resource properties to be updated.
  • options - AvsStorageContainerVolumesClientBeginUpdateOptions contains the optional parameters for the AvsStorageContainerVolumesClient.BeginUpdate method.
Example

Generated from example definition: 2024-11-01/AvsStorageContainerVolumes_Update_MaximumSet_Gen.json 

package main

import (
	"context"
	"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/purestorageblock/armpurestorageblock"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armpurestorageblock.NewClientFactory("BC47D6CC-AA80-4374-86F8-19D94EC70666", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewAvsStorageContainerVolumesClient().BeginUpdate(ctx, "rgpurestorage", "storagePoolname", "name", "cbdec-ddbb", armpurestorageblock.AvsStorageContainerVolumeUpdate{
		Properties: &armpurestorageblock.AvsStorageContainerVolumeUpdateProperties{
			SoftDeletion: &armpurestorageblock.SoftDeletion{
				Destroyed: to.Ptr(true),
			},
		},
	}, 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 = armpurestorageblock.AvsStorageContainerVolumesClientUpdateResponse{
	// 	AvsStorageContainerVolume: &armpurestorageblock.AvsStorageContainerVolume{
	// 		Properties: &armpurestorageblock.VolumeProperties{
	// 			StoragePoolInternalID: to.Ptr("xkcbzbtfhftbnowayannq"),
	// 			StoragePoolResourceID: to.Ptr("mrnioblkjhwry"),
	// 			VolumeInternalID: to.Ptr("ivdmuth"),
	// 			DisplayName: to.Ptr("mcdetkfvt"),
	// 			Space: &armpurestorageblock.Space{
	// 				TotalUsed: to.Ptr[int64](28),
	// 				Unique: to.Ptr[int64](4),
	// 				Snapshots: to.Ptr[int64](5),
	// 				Shared: to.Ptr[int64](9),
	// 			},
	// 			SoftDeletion: &armpurestorageblock.SoftDeletion{
	// 				Destroyed: to.Ptr(true),
	// 				EradicationTimestamp: to.Ptr("kaxjtehra"),
	// 			},
	// 			CreatedTimestamp: to.Ptr("pwhsjhrcszrhsmzc"),
	// 			ProvisionedSize: to.Ptr[int64](14),
	// 			VolumeType: to.Ptr(armpurestorageblock.VolumeTypeAVS),
	// 			Avs: &armpurestorageblock.AvsDiskDetails{
	// 				DiskID: to.Ptr("egehzvidnjgevc"),
	// 				DiskName: to.Ptr("gqpqpkxjyj"),
	// 				Folder: to.Ptr("oxdbbh"),
	// 				AvsVMInternalID: to.Ptr("xoiliugbcvkhdl"),
	// 				AvsVMResourceID: to.Ptr("jblyybyfhtikdhwx"),
	// 				AvsVMName: to.Ptr("gaeydwwisfuonbuwtnkdk"),
	// 				AvsStorageContainerResourceID: to.Ptr("svwilhkpx"),
	// 			},
	// 			ProvisioningState: to.Ptr(armpurestorageblock.ResourceProvisioningStateSucceeded),
	// 		},
	// 		ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}"),
	// 		Name: to.Ptr("eyomi"),
	// 		Type: to.Ptr("kaapjwvnvm"),
	// 		SystemData: &armpurestorageblock.SystemData{
	// 			CreatedBy: to.Ptr("ruoitchmuomrbscg"),
	// 			CreatedByType: to.Ptr(armpurestorageblock.CreatedByTypeUser),
	// 			CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-10-04T05:29:25.341Z"); return t}()),
	// 			LastModifiedBy: to.Ptr("thfyhokbrldzmghuylqbwpbublj"),
	// 			LastModifiedByType: to.Ptr(armpurestorageblock.CreatedByTypeUser),
	// 			LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-10-04T05:29:25.345Z"); return t}()),
	// 		},
	// 	},
	// }
}

func (*AvsStorageContainerVolumesClient) Get 

func (client *AvsStorageContainerVolumesClient) Get(ctx context.Context, resourceGroupName string, storagePoolName string, storageContainerName string, volumeID string, options *AvsStorageContainerVolumesClientGetOptions) (AvsStorageContainerVolumesClientGetResponse, error)

Get - Get a volume in an AVS storage container If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • storagePoolName - Name of the storage pool
  • storageContainerName - Name of the storage container
  • volumeID - ID of the volume in the storage container
  • options - AvsStorageContainerVolumesClientGetOptions contains the optional parameters for the AvsStorageContainerVolumesClient.Get method.
Example

Generated from example definition: 2024-11-01/AvsStorageContainerVolumes_Get_MaximumSet_Gen.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/purestorageblock/armpurestorageblock"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armpurestorageblock.NewClientFactory("BC47D6CC-AA80-4374-86F8-19D94EC70666", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewAvsStorageContainerVolumesClient().Get(ctx, "rgpurestorage", "storagePoolname", "name", "cbdec-ddbb", 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 = armpurestorageblock.AvsStorageContainerVolumesClientGetResponse{
	// 	AvsStorageContainerVolume: &armpurestorageblock.AvsStorageContainerVolume{
	// 		Properties: &armpurestorageblock.VolumeProperties{
	// 			StoragePoolInternalID: to.Ptr("xkcbzbtfhftbnowayannq"),
	// 			StoragePoolResourceID: to.Ptr("mrnioblkjhwry"),
	// 			VolumeInternalID: to.Ptr("ivdmuth"),
	// 			DisplayName: to.Ptr("mcdetkfvt"),
	// 			Space: &armpurestorageblock.Space{
	// 				TotalUsed: to.Ptr[int64](28),
	// 				Unique: to.Ptr[int64](4),
	// 				Snapshots: to.Ptr[int64](5),
	// 				Shared: to.Ptr[int64](9),
	// 			},
	// 			SoftDeletion: &armpurestorageblock.SoftDeletion{
	// 				Destroyed: to.Ptr(true),
	// 				EradicationTimestamp: to.Ptr("kaxjtehra"),
	// 			},
	// 			CreatedTimestamp: to.Ptr("pwhsjhrcszrhsmzc"),
	// 			ProvisionedSize: to.Ptr[int64](14),
	// 			VolumeType: to.Ptr(armpurestorageblock.VolumeTypeAVS),
	// 			Avs: &armpurestorageblock.AvsDiskDetails{
	// 				DiskID: to.Ptr("egehzvidnjgevc"),
	// 				DiskName: to.Ptr("gqpqpkxjyj"),
	// 				Folder: to.Ptr("oxdbbh"),
	// 				AvsVMInternalID: to.Ptr("xoiliugbcvkhdl"),
	// 				AvsVMResourceID: to.Ptr("jblyybyfhtikdhwx"),
	// 				AvsVMName: to.Ptr("gaeydwwisfuonbuwtnkdk"),
	// 				AvsStorageContainerResourceID: to.Ptr("svwilhkpx"),
	// 			},
	// 			ProvisioningState: to.Ptr(armpurestorageblock.ResourceProvisioningStateSucceeded),
	// 		},
	// 		ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}"),
	// 		Name: to.Ptr("eyomi"),
	// 		Type: to.Ptr("kaapjwvnvm"),
	// 		SystemData: &armpurestorageblock.SystemData{
	// 			CreatedBy: to.Ptr("ruoitchmuomrbscg"),
	// 			CreatedByType: to.Ptr(armpurestorageblock.CreatedByTypeUser),
	// 			CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-10-04T05:29:25.341Z"); return t}()),
	// 			LastModifiedBy: to.Ptr("thfyhokbrldzmghuylqbwpbublj"),
	// 			LastModifiedByType: to.Ptr(armpurestorageblock.CreatedByTypeUser),
	// 			LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-10-04T05:29:25.345Z"); return t}()),
	// 		},
	// 	},
	// }
}

func (*AvsStorageContainerVolumesClient) NewListByAvsStorageContainerPager 

func (client *AvsStorageContainerVolumesClient) NewListByAvsStorageContainerPager(resourceGroupName string, storagePoolName string, storageContainerName string, options *AvsStorageContainerVolumesClientListByAvsStorageContainerOptions) *runtime.Pager[AvsStorageContainerVolumesClientListByAvsStorageContainerResponse]

NewListByAvsStorageContainerPager - List volumes in an AVS storage container

Generated from API version 2024-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • storagePoolName - Name of the storage pool
  • storageContainerName - Name of the storage container
  • options - AvsStorageContainerVolumesClientListByAvsStorageContainerOptions contains the optional parameters for the AvsStorageContainerVolumesClient.NewListByAvsStorageContainerPager method.
Example

Generated from example definition: 2024-11-01/AvsStorageContainerVolumes_ListByAvsStorageContainer_MaximumSet_Gen.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/purestorageblock/armpurestorageblock"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armpurestorageblock.NewClientFactory("BC47D6CC-AA80-4374-86F8-19D94EC70666", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewAvsStorageContainerVolumesClient().NewListByAvsStorageContainerPager("rgpurestorage", "storagePoolname", "name", 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 = armpurestorageblock.AvsStorageContainerVolumesClientListByAvsStorageContainerResponse{
		// 	AvsStorageContainerVolumeListResult: armpurestorageblock.AvsStorageContainerVolumeListResult{
		// 		Value: []*armpurestorageblock.AvsStorageContainerVolume{
		// 			{
		// 				Properties: &armpurestorageblock.VolumeProperties{
		// 					StoragePoolInternalID: to.Ptr("xkcbzbtfhftbnowayannq"),
		// 					StoragePoolResourceID: to.Ptr("mrnioblkjhwry"),
		// 					VolumeInternalID: to.Ptr("ivdmuth"),
		// 					DisplayName: to.Ptr("mcdetkfvt"),
		// 					Space: &armpurestorageblock.Space{
		// 						TotalUsed: to.Ptr[int64](28),
		// 						Unique: to.Ptr[int64](4),
		// 						Snapshots: to.Ptr[int64](5),
		// 						Shared: to.Ptr[int64](9),
		// 					},
		// 					SoftDeletion: &armpurestorageblock.SoftDeletion{
		// 						Destroyed: to.Ptr(true),
		// 						EradicationTimestamp: to.Ptr("kaxjtehra"),
		// 					},
		// 					CreatedTimestamp: to.Ptr("pwhsjhrcszrhsmzc"),
		// 					ProvisionedSize: to.Ptr[int64](14),
		// 					VolumeType: to.Ptr(armpurestorageblock.VolumeTypeAVS),
		// 					Avs: &armpurestorageblock.AvsDiskDetails{
		// 						DiskID: to.Ptr("egehzvidnjgevc"),
		// 						DiskName: to.Ptr("gqpqpkxjyj"),
		// 						Folder: to.Ptr("oxdbbh"),
		// 						AvsVMInternalID: to.Ptr("xoiliugbcvkhdl"),
		// 						AvsVMResourceID: to.Ptr("jblyybyfhtikdhwx"),
		// 						AvsVMName: to.Ptr("gaeydwwisfuonbuwtnkdk"),
		// 						AvsStorageContainerResourceID: to.Ptr("svwilhkpx"),
		// 					},
		// 					ProvisioningState: to.Ptr(armpurestorageblock.ResourceProvisioningStateSucceeded),
		// 				},
		// 				ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}"),
		// 				Name: to.Ptr("eyomi"),
		// 				Type: to.Ptr("kaapjwvnvm"),
		// 				SystemData: &armpurestorageblock.SystemData{
		// 					CreatedBy: to.Ptr("ruoitchmuomrbscg"),
		// 					CreatedByType: to.Ptr(armpurestorageblock.CreatedByTypeUser),
		// 					CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-10-04T05:29:25.341Z"); return t}()),
		// 					LastModifiedBy: to.Ptr("thfyhokbrldzmghuylqbwpbublj"),
		// 					LastModifiedByType: to.Ptr(armpurestorageblock.CreatedByTypeUser),
		// 					LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-10-04T05:29:25.345Z"); return t}()),
		// 				},
		// 			},
		// 		},
		// 		NextLink: to.Ptr("https://microsoft.com/a"),
		// 	},
		// }
	}
}

type AvsStorageContainerVolumesClientBeginDeleteOptions 

type AvsStorageContainerVolumesClientBeginDeleteOptions struct {
	// Resumes the long-running operation from the provided token.
	ResumeToken string
}

AvsStorageContainerVolumesClientBeginDeleteOptions contains the optional parameters for the AvsStorageContainerVolumesClient.BeginDelete method.

type AvsStorageContainerVolumesClientBeginUpdateOptions 

type AvsStorageContainerVolumesClientBeginUpdateOptions struct {
	// Resumes the long-running operation from the provided token.
	ResumeToken string
}

AvsStorageContainerVolumesClientBeginUpdateOptions contains the optional parameters for the AvsStorageContainerVolumesClient.BeginUpdate method.

type AvsStorageContainerVolumesClientDeleteResponse 

type AvsStorageContainerVolumesClientDeleteResponse struct {
}

AvsStorageContainerVolumesClientDeleteResponse contains the response from method AvsStorageContainerVolumesClient.BeginDelete.

type AvsStorageContainerVolumesClientGetOptions 

type AvsStorageContainerVolumesClientGetOptions struct {
}

AvsStorageContainerVolumesClientGetOptions contains the optional parameters for the AvsStorageContainerVolumesClient.Get method.

type AvsStorageContainerVolumesClientGetResponse 

type AvsStorageContainerVolumesClientGetResponse struct {
	// A volume contained in an AVS storage container
	AvsStorageContainerVolume
}

AvsStorageContainerVolumesClientGetResponse contains the response from method AvsStorageContainerVolumesClient.Get.

type AvsStorageContainerVolumesClientListByAvsStorageContainerOptions 

type AvsStorageContainerVolumesClientListByAvsStorageContainerOptions struct {
}

AvsStorageContainerVolumesClientListByAvsStorageContainerOptions contains the optional parameters for the AvsStorageContainerVolumesClient.NewListByAvsStorageContainerPager method.

type AvsStorageContainerVolumesClientListByAvsStorageContainerResponse 

type AvsStorageContainerVolumesClientListByAvsStorageContainerResponse struct {
	// The response of a AvsStorageContainerVolume list operation.
	AvsStorageContainerVolumeListResult
}

AvsStorageContainerVolumesClientListByAvsStorageContainerResponse contains the response from method AvsStorageContainerVolumesClient.NewListByAvsStorageContainerPager.

type AvsStorageContainerVolumesClientUpdateResponse 

type AvsStorageContainerVolumesClientUpdateResponse struct {
	// A volume contained in an AVS storage container
	AvsStorageContainerVolume
}

AvsStorageContainerVolumesClientUpdateResponse contains the response from method AvsStorageContainerVolumesClient.BeginUpdate.

type AvsStorageContainersClient 

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

AvsStorageContainersClient contains the methods for the AvsStorageContainers group. Don't use this type directly, use NewAvsStorageContainersClient() instead.

func NewAvsStorageContainersClient 

func NewAvsStorageContainersClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*AvsStorageContainersClient, error)

NewAvsStorageContainersClient creates a new instance of AvsStorageContainersClient with the specified values.

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

func (*AvsStorageContainersClient) BeginDelete 

func (client *AvsStorageContainersClient) BeginDelete(ctx context.Context, resourceGroupName string, storagePoolName string, storageContainerName string, options *AvsStorageContainersClientBeginDeleteOptions) (*runtime.Poller[AvsStorageContainersClientDeleteResponse], error)

BeginDelete - Delete an AVS storage container If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • storagePoolName - Name of the storage pool
  • storageContainerName - Name of the storage container
  • options - AvsStorageContainersClientBeginDeleteOptions contains the optional parameters for the AvsStorageContainersClient.BeginDelete method.
Example

Generated from example definition: 2024-11-01/AvsStorageContainers_Delete_MaximumSet_Gen.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/purestorageblock/armpurestorageblock"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armpurestorageblock.NewClientFactory("BC47D6CC-AA80-4374-86F8-19D94EC70666", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewAvsStorageContainersClient().BeginDelete(ctx, "rgpurestorage", "storagePoolName", "storageContainerName", 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)
	}
}

func (*AvsStorageContainersClient) Get 

func (client *AvsStorageContainersClient) Get(ctx context.Context, resourceGroupName string, storagePoolName string, storageContainerName string, options *AvsStorageContainersClientGetOptions) (AvsStorageContainersClientGetResponse, error)

Get - Get an AVS storage container If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • storagePoolName - Name of the storage pool
  • storageContainerName - Name of the storage container
  • options - AvsStorageContainersClientGetOptions contains the optional parameters for the AvsStorageContainersClient.Get method.
Example

Generated from example definition: 2024-11-01/AvsStorageContainers_Get_MaximumSet_Gen.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/purestorageblock/armpurestorageblock"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armpurestorageblock.NewClientFactory("BC47D6CC-AA80-4374-86F8-19D94EC70666", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewAvsStorageContainersClient().Get(ctx, "rgpurestorage", "storagePoolName", "storageContainerName", 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 = armpurestorageblock.AvsStorageContainersClientGetResponse{
	// 	AvsStorageContainer: &armpurestorageblock.AvsStorageContainer{
	// 		Properties: &armpurestorageblock.AvsStorageContainerProperties{
	// 			Space: &armpurestorageblock.Space{
	// 				TotalUsed: to.Ptr[int64](28),
	// 				Unique: to.Ptr[int64](4),
	// 				Snapshots: to.Ptr[int64](5),
	// 				Shared: to.Ptr[int64](9),
	// 			},
	// 			ResourceName: to.Ptr("name"),
	// 			ProvisionedLimit: to.Ptr[int64](24),
	// 			Datastore: to.Ptr("name"),
	// 			Mounted: to.Ptr(true),
	// 		},
	// 		ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}"),
	// 		Name: to.Ptr("acezain"),
	// 		Type: to.Ptr("rhdmvrbnpxcydalkvtfsb"),
	// 		SystemData: &armpurestorageblock.SystemData{
	// 			CreatedBy: to.Ptr("ruoitchmuomrbscg"),
	// 			CreatedByType: to.Ptr(armpurestorageblock.CreatedByTypeUser),
	// 			CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-10-04T05:29:25.341Z"); return t}()),
	// 			LastModifiedBy: to.Ptr("thfyhokbrldzmghuylqbwpbublj"),
	// 			LastModifiedByType: to.Ptr(armpurestorageblock.CreatedByTypeUser),
	// 			LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-10-04T05:29:25.345Z"); return t}()),
	// 		},
	// 	},
	// }
}

func (*AvsStorageContainersClient) NewListByStoragePoolPager 

func (client *AvsStorageContainersClient) NewListByStoragePoolPager(resourceGroupName string, storagePoolName string, options *AvsStorageContainersClientListByStoragePoolOptions) *runtime.Pager[AvsStorageContainersClientListByStoragePoolResponse]

NewListByStoragePoolPager - List AVS storage containers by storage pool

Generated from API version 2024-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • storagePoolName - Name of the storage pool
  • options - AvsStorageContainersClientListByStoragePoolOptions contains the optional parameters for the AvsStorageContainersClient.NewListByStoragePoolPager method.
Example

Generated from example definition: 2024-11-01/AvsStorageContainers_ListByStoragePool_MaximumSet_Gen.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/purestorageblock/armpurestorageblock"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armpurestorageblock.NewClientFactory("BC47D6CC-AA80-4374-86F8-19D94EC70666", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewAvsStorageContainersClient().NewListByStoragePoolPager("rgpurestorage", "spName", 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 = armpurestorageblock.AvsStorageContainersClientListByStoragePoolResponse{
		// 	AvsStorageContainerListResult: armpurestorageblock.AvsStorageContainerListResult{
		// 		Value: []*armpurestorageblock.AvsStorageContainer{
		// 			{
		// 				Properties: &armpurestorageblock.AvsStorageContainerProperties{
		// 					Space: &armpurestorageblock.Space{
		// 						TotalUsed: to.Ptr[int64](28),
		// 						Unique: to.Ptr[int64](4),
		// 						Snapshots: to.Ptr[int64](5),
		// 						Shared: to.Ptr[int64](9),
		// 					},
		// 					ResourceName: to.Ptr("name"),
		// 					ProvisionedLimit: to.Ptr[int64](24),
		// 					Datastore: to.Ptr("name"),
		// 					Mounted: to.Ptr(true),
		// 				},
		// 				ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}"),
		// 				Name: to.Ptr("acezain"),
		// 				Type: to.Ptr("rhdmvrbnpxcydalkvtfsb"),
		// 				SystemData: &armpurestorageblock.SystemData{
		// 					CreatedBy: to.Ptr("ruoitchmuomrbscg"),
		// 					CreatedByType: to.Ptr(armpurestorageblock.CreatedByTypeUser),
		// 					CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-10-04T05:29:25.341Z"); return t}()),
		// 					LastModifiedBy: to.Ptr("thfyhokbrldzmghuylqbwpbublj"),
		// 					LastModifiedByType: to.Ptr(armpurestorageblock.CreatedByTypeUser),
		// 					LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-10-04T05:29:25.345Z"); return t}()),
		// 				},
		// 			},
		// 		},
		// 		NextLink: to.Ptr("https://microsoft.com/a"),
		// 	},
		// }
	}
}

type AvsStorageContainersClientBeginDeleteOptions 

type AvsStorageContainersClientBeginDeleteOptions struct {
	// Resumes the long-running operation from the provided token.
	ResumeToken string
}

AvsStorageContainersClientBeginDeleteOptions contains the optional parameters for the AvsStorageContainersClient.BeginDelete method.

type AvsStorageContainersClientDeleteResponse 

type AvsStorageContainersClientDeleteResponse struct {
}

AvsStorageContainersClientDeleteResponse contains the response from method AvsStorageContainersClient.BeginDelete.

type AvsStorageContainersClientGetOptions 

type AvsStorageContainersClientGetOptions struct {
}

AvsStorageContainersClientGetOptions contains the optional parameters for the AvsStorageContainersClient.Get method.

type AvsStorageContainersClientGetResponse 

type AvsStorageContainersClientGetResponse struct {
	// AVS storage container resource type, representing a VMware storage container in a storage pool, which can be associated
	// to and mounted as a datastore
	AvsStorageContainer
}

AvsStorageContainersClientGetResponse contains the response from method AvsStorageContainersClient.Get.

type AvsStorageContainersClientListByStoragePoolOptions 

type AvsStorageContainersClientListByStoragePoolOptions struct {
}

AvsStorageContainersClientListByStoragePoolOptions contains the optional parameters for the AvsStorageContainersClient.NewListByStoragePoolPager method.

type AvsStorageContainersClientListByStoragePoolResponse 

type AvsStorageContainersClientListByStoragePoolResponse struct {
	// The response of a AvsStorageContainer list operation.
	AvsStorageContainerListResult
}

AvsStorageContainersClientListByStoragePoolResponse contains the response from method AvsStorageContainersClient.NewListByStoragePoolPager.

type AvsVM 

type AvsVM struct {
	// The resource-specific properties for this resource.
	Properties *AvsVMProperties

	// READ-ONLY; ID of the AVS VM
	Name *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 Manager metadata containing createdBy and modifiedBy information.
	SystemData *SystemData

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

AvsVM - AVS VM resource type, representing all the volumes associated to an AVS VM as defined by VMware

func (AvsVM) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type AvsVM.

func (*AvsVM) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AvsVM.

type AvsVMDetails 

type AvsVMDetails struct {
	// REQUIRED; Pure Storage's internal ID for this AVS VM
	AvsVMInternalID *string

	// REQUIRED; ID of the AVS VM using this set of volumes
	VMID *string

	// REQUIRED; Name of the VMware VM using this set of volumes
	VMName *string

	// REQUIRED; Type of the VMware VM using this set of volumes
	VMType *VMType
}

AvsVMDetails - AVS VM details

func (AvsVMDetails) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type AvsVMDetails.

func (*AvsVMDetails) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AvsVMDetails.

type AvsVMListResult 

type AvsVMListResult struct {
	// REQUIRED; The AvsVm items on this page
	Value []*AvsVM

	// The link to the next page of items
	NextLink *string
}

AvsVMListResult - The response of a AvsVm list operation.

func (AvsVMListResult) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type AvsVMListResult.

func (*AvsVMListResult) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AvsVMListResult.

type AvsVMProperties 

type AvsVMProperties struct {
	// AVS VM's soft-deletion state
	SoftDeletion *SoftDeletion

	// READ-ONLY; AVS VM details
	Avs *AvsVMDetails

	// READ-ONLY; Date at which the AVS VM was created, as an RFC 3339 timestamp
	CreatedTimestamp *string

	// READ-ONLY; Human-readable name of the AVS VM
	DisplayName *string

	// READ-ONLY; Provisioning state of the resource.
	ProvisioningState *ResourceProvisioningState

	// READ-ONLY; Contains properties related to used Flash space
	Space *Space

	// READ-ONLY; Pure Storage's internal ID for the storage pool
	StoragePoolInternalID *string

	// READ-ONLY; Azure resource ID of the storage pool
	StoragePoolResourceID *string

	// READ-ONLY; Specify which control plane handles the lifecycle of the volume container
	VolumeContainerType *VolumeContainerType
}

AvsVMProperties - AVS VM properties

func (AvsVMProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type AvsVMProperties.

func (*AvsVMProperties) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AvsVMProperties.

type AvsVMUpdate 

type AvsVMUpdate struct {
	// The resource-specific properties for this resource.
	Properties *AvsVMUpdateProperties
}

AvsVMUpdate - The type used for update operations of the AvsVm.

func (AvsVMUpdate) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type AvsVMUpdate.

func (*AvsVMUpdate) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AvsVMUpdate.

type AvsVMUpdateProperties 

type AvsVMUpdateProperties struct {
	// AVS VM's soft-deletion state
	SoftDeletion *SoftDeletion
}

AvsVMUpdateProperties - The updatable properties of the AvsVm.

func (AvsVMUpdateProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type AvsVMUpdateProperties.

func (*AvsVMUpdateProperties) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AvsVMUpdateProperties.

type AvsVMVolume 

type AvsVMVolume struct {
	// The resource-specific properties for this resource.
	Properties *VolumeProperties

	// READ-ONLY; ID of the volume in the AVS VM
	Name *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 Manager metadata containing createdBy and modifiedBy information.
	SystemData *SystemData

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

AvsVMVolume - Any volume associated to a particular AVS VM

func (AvsVMVolume) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type AvsVMVolume.

func (*AvsVMVolume) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AvsVMVolume.

type AvsVMVolumeListResult 

type AvsVMVolumeListResult struct {
	// REQUIRED; The AvsVmVolume items on this page
	Value []*AvsVMVolume

	// The link to the next page of items
	NextLink *string
}

AvsVMVolumeListResult - The response of a AvsVmVolume list operation.

func (AvsVMVolumeListResult) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type AvsVMVolumeListResult.

func (*AvsVMVolumeListResult) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AvsVMVolumeListResult.

type AvsVMVolumeUpdate 

type AvsVMVolumeUpdate struct {
	// The resource-specific properties for this resource.
	Properties *AvsVMVolumeUpdateProperties
}

AvsVMVolumeUpdate - The type used for update operations of the AvsVmVolume.

func (AvsVMVolumeUpdate) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type AvsVMVolumeUpdate.

func (*AvsVMVolumeUpdate) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AvsVMVolumeUpdate.

type AvsVMVolumeUpdateProperties 

type AvsVMVolumeUpdateProperties struct {
	// Volume's soft-deletion state
	SoftDeletion *SoftDeletion
}

AvsVMVolumeUpdateProperties - The updatable properties of the AvsVmVolume.

func (AvsVMVolumeUpdateProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type AvsVMVolumeUpdateProperties.

func (*AvsVMVolumeUpdateProperties) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AvsVMVolumeUpdateProperties.

type AvsVMVolumesClient 

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

AvsVMVolumesClient contains the methods for the AvsVMVolumes group. Don't use this type directly, use NewAvsVMVolumesClient() instead.

func NewAvsVMVolumesClient 

func NewAvsVMVolumesClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*AvsVMVolumesClient, error)

NewAvsVMVolumesClient creates a new instance of AvsVMVolumesClient with the specified values.

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

func (*AvsVMVolumesClient) BeginDelete 

func (client *AvsVMVolumesClient) BeginDelete(ctx context.Context, resourceGroupName string, storagePoolName string, avsVMID string, volumeID string, options *AvsVMVolumesClientBeginDeleteOptions) (*runtime.Poller[AvsVMVolumesClientDeleteResponse], error)

BeginDelete - Delete a volume in an AVS VM If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • storagePoolName - Name of the storage pool
  • avsVMID - ID of the AVS VM
  • volumeID - ID of the volume in the AVS VM
  • options - AvsVMVolumesClientBeginDeleteOptions contains the optional parameters for the AvsVMVolumesClient.BeginDelete method.
Example

Generated from example definition: 2024-11-01/AvsVmVolumes_Delete_MaximumSet_Gen.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/purestorageblock/armpurestorageblock"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armpurestorageblock.NewClientFactory("BC47D6CC-AA80-4374-86F8-19D94EC70666", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewAvsVMVolumesClient().BeginDelete(ctx, "rgpurestorage", "storagePoolname", "cbdec-ddbb", "cbdec-ddbb", 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)
	}
}

func (*AvsVMVolumesClient) BeginUpdate 

func (client *AvsVMVolumesClient) BeginUpdate(ctx context.Context, resourceGroupName string, storagePoolName string, avsVMID string, volumeID string, properties AvsVMVolumeUpdate, options *AvsVMVolumesClientBeginUpdateOptions) (*runtime.Poller[AvsVMVolumesClientUpdateResponse], error)

BeginUpdate - Update a volume in an AVS VM If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • storagePoolName - Name of the storage pool
  • avsVMID - ID of the AVS VM
  • volumeID - ID of the volume in the AVS VM
  • properties - The resource properties to be updated.
  • options - AvsVMVolumesClientBeginUpdateOptions contains the optional parameters for the AvsVMVolumesClient.BeginUpdate method.
Example

Generated from example definition: 2024-11-01/AvsVmVolumes_Update_MaximumSet_Gen.json 

package main

import (
	"context"
	"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/purestorageblock/armpurestorageblock"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armpurestorageblock.NewClientFactory("BC47D6CC-AA80-4374-86F8-19D94EC70666", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewAvsVMVolumesClient().BeginUpdate(ctx, "rgpurestorage", "storagePoolname", "cbdec-ddbb", "cbdec-ddbb", armpurestorageblock.AvsVMVolumeUpdate{
		Properties: &armpurestorageblock.AvsVMVolumeUpdateProperties{
			SoftDeletion: &armpurestorageblock.SoftDeletion{
				Destroyed: to.Ptr(true),
			},
		},
	}, 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 = armpurestorageblock.AvsVMVolumesClientUpdateResponse{
	// 	AvsVMVolume: &armpurestorageblock.AvsVMVolume{
	// 		Properties: &armpurestorageblock.VolumeProperties{
	// 			StoragePoolInternalID: to.Ptr("xkcbzbtfhftbnowayannq"),
	// 			StoragePoolResourceID: to.Ptr("mrnioblkjhwry"),
	// 			VolumeInternalID: to.Ptr("ivdmuth"),
	// 			DisplayName: to.Ptr("mcdetkfvt"),
	// 			Space: &armpurestorageblock.Space{
	// 				TotalUsed: to.Ptr[int64](28),
	// 				Unique: to.Ptr[int64](4),
	// 				Snapshots: to.Ptr[int64](5),
	// 				Shared: to.Ptr[int64](9),
	// 			},
	// 			SoftDeletion: &armpurestorageblock.SoftDeletion{
	// 				Destroyed: to.Ptr(true),
	// 				EradicationTimestamp: to.Ptr("kaxjtehra"),
	// 			},
	// 			CreatedTimestamp: to.Ptr("pwhsjhrcszrhsmzc"),
	// 			ProvisionedSize: to.Ptr[int64](14),
	// 			VolumeType: to.Ptr(armpurestorageblock.VolumeTypeAVS),
	// 			Avs: &armpurestorageblock.AvsDiskDetails{
	// 				DiskID: to.Ptr("egehzvidnjgevc"),
	// 				DiskName: to.Ptr("gqpqpkxjyj"),
	// 				Folder: to.Ptr("oxdbbh"),
	// 				AvsVMInternalID: to.Ptr("xoiliugbcvkhdl"),
	// 				AvsVMResourceID: to.Ptr("jblyybyfhtikdhwx"),
	// 				AvsVMName: to.Ptr("gaeydwwisfuonbuwtnkdk"),
	// 				AvsStorageContainerResourceID: to.Ptr("svwilhkpx"),
	// 			},
	// 			ProvisioningState: to.Ptr(armpurestorageblock.ResourceProvisioningStateSucceeded),
	// 		},
	// 		ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}"),
	// 		Name: to.Ptr("hnglbdwyocdmggwii"),
	// 		Type: to.Ptr("jprfxakifyliuzougfctzpfhozq"),
	// 		SystemData: &armpurestorageblock.SystemData{
	// 			CreatedBy: to.Ptr("ruoitchmuomrbscg"),
	// 			CreatedByType: to.Ptr(armpurestorageblock.CreatedByTypeUser),
	// 			CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-10-04T05:29:25.341Z"); return t}()),
	// 			LastModifiedBy: to.Ptr("thfyhokbrldzmghuylqbwpbublj"),
	// 			LastModifiedByType: to.Ptr(armpurestorageblock.CreatedByTypeUser),
	// 			LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-10-04T05:29:25.345Z"); return t}()),
	// 		},
	// 	},
	// }
}

func (*AvsVMVolumesClient) Get 

func (client *AvsVMVolumesClient) Get(ctx context.Context, resourceGroupName string, storagePoolName string, avsVMID string, volumeID string, options *AvsVMVolumesClientGetOptions) (AvsVMVolumesClientGetResponse, error)

Get - Get a volume in an AVS VM If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • storagePoolName - Name of the storage pool
  • avsVMID - ID of the AVS VM
  • volumeID - ID of the volume in the AVS VM
  • options - AvsVMVolumesClientGetOptions contains the optional parameters for the AvsVMVolumesClient.Get method.
Example

Generated from example definition: 2024-11-01/AvsVmVolumes_Get_MaximumSet_Gen.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/purestorageblock/armpurestorageblock"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armpurestorageblock.NewClientFactory("BC47D6CC-AA80-4374-86F8-19D94EC70666", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewAvsVMVolumesClient().Get(ctx, "rgpurestorage", "storagePoolname", "cbdec-ddbb", "cbdec-ddbb", 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 = armpurestorageblock.AvsVMVolumesClientGetResponse{
	// 	AvsVMVolume: &armpurestorageblock.AvsVMVolume{
	// 		Properties: &armpurestorageblock.VolumeProperties{
	// 			StoragePoolInternalID: to.Ptr("xkcbzbtfhftbnowayannq"),
	// 			StoragePoolResourceID: to.Ptr("mrnioblkjhwry"),
	// 			VolumeInternalID: to.Ptr("ivdmuth"),
	// 			DisplayName: to.Ptr("mcdetkfvt"),
	// 			Space: &armpurestorageblock.Space{
	// 				TotalUsed: to.Ptr[int64](28),
	// 				Unique: to.Ptr[int64](4),
	// 				Snapshots: to.Ptr[int64](5),
	// 				Shared: to.Ptr[int64](9),
	// 			},
	// 			SoftDeletion: &armpurestorageblock.SoftDeletion{
	// 				Destroyed: to.Ptr(true),
	// 				EradicationTimestamp: to.Ptr("kaxjtehra"),
	// 			},
	// 			CreatedTimestamp: to.Ptr("pwhsjhrcszrhsmzc"),
	// 			ProvisionedSize: to.Ptr[int64](14),
	// 			VolumeType: to.Ptr(armpurestorageblock.VolumeTypeAVS),
	// 			Avs: &armpurestorageblock.AvsDiskDetails{
	// 				DiskID: to.Ptr("egehzvidnjgevc"),
	// 				DiskName: to.Ptr("gqpqpkxjyj"),
	// 				Folder: to.Ptr("oxdbbh"),
	// 				AvsVMInternalID: to.Ptr("xoiliugbcvkhdl"),
	// 				AvsVMResourceID: to.Ptr("jblyybyfhtikdhwx"),
	// 				AvsVMName: to.Ptr("gaeydwwisfuonbuwtnkdk"),
	// 				AvsStorageContainerResourceID: to.Ptr("svwilhkpx"),
	// 			},
	// 			ProvisioningState: to.Ptr(armpurestorageblock.ResourceProvisioningStateSucceeded),
	// 		},
	// 		ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}"),
	// 		Name: to.Ptr("hnglbdwyocdmggwii"),
	// 		Type: to.Ptr("jprfxakifyliuzougfctzpfhozq"),
	// 		SystemData: &armpurestorageblock.SystemData{
	// 			CreatedBy: to.Ptr("ruoitchmuomrbscg"),
	// 			CreatedByType: to.Ptr(armpurestorageblock.CreatedByTypeUser),
	// 			CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-10-04T05:29:25.341Z"); return t}()),
	// 			LastModifiedBy: to.Ptr("thfyhokbrldzmghuylqbwpbublj"),
	// 			LastModifiedByType: to.Ptr(armpurestorageblock.CreatedByTypeUser),
	// 			LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-10-04T05:29:25.345Z"); return t}()),
	// 		},
	// 	},
	// }
}

func (*AvsVMVolumesClient) NewListByAvsVMPager 

func (client *AvsVMVolumesClient) NewListByAvsVMPager(resourceGroupName string, storagePoolName string, avsVMID string, options *AvsVMVolumesClientListByAvsVMOptions) *runtime.Pager[AvsVMVolumesClientListByAvsVMResponse]

NewListByAvsVMPager - List volumes in an AVS VM

Generated from API version 2024-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • storagePoolName - Name of the storage pool
  • avsVMID - ID of the AVS VM
  • options - AvsVMVolumesClientListByAvsVMOptions contains the optional parameters for the AvsVMVolumesClient.NewListByAvsVMPager method.
Example

Generated from example definition: 2024-11-01/AvsVmVolumes_ListByAvsVm_MaximumSet_Gen.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/purestorageblock/armpurestorageblock"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armpurestorageblock.NewClientFactory("BC47D6CC-AA80-4374-86F8-19D94EC70666", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewAvsVMVolumesClient().NewListByAvsVMPager("rgpurestorage", "storagePoolname", "cbdec-ddbb", 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 = armpurestorageblock.AvsVMVolumesClientListByAvsVMResponse{
		// 	AvsVMVolumeListResult: armpurestorageblock.AvsVMVolumeListResult{
		// 		Value: []*armpurestorageblock.AvsVMVolume{
		// 			{
		// 				Properties: &armpurestorageblock.VolumeProperties{
		// 					StoragePoolInternalID: to.Ptr("xkcbzbtfhftbnowayannq"),
		// 					StoragePoolResourceID: to.Ptr("mrnioblkjhwry"),
		// 					VolumeInternalID: to.Ptr("ivdmuth"),
		// 					DisplayName: to.Ptr("mcdetkfvt"),
		// 					Space: &armpurestorageblock.Space{
		// 						TotalUsed: to.Ptr[int64](28),
		// 						Unique: to.Ptr[int64](4),
		// 						Snapshots: to.Ptr[int64](5),
		// 						Shared: to.Ptr[int64](9),
		// 					},
		// 					SoftDeletion: &armpurestorageblock.SoftDeletion{
		// 						Destroyed: to.Ptr(true),
		// 						EradicationTimestamp: to.Ptr("kaxjtehra"),
		// 					},
		// 					CreatedTimestamp: to.Ptr("pwhsjhrcszrhsmzc"),
		// 					ProvisionedSize: to.Ptr[int64](14),
		// 					VolumeType: to.Ptr(armpurestorageblock.VolumeTypeAVS),
		// 					Avs: &armpurestorageblock.AvsDiskDetails{
		// 						DiskID: to.Ptr("egehzvidnjgevc"),
		// 						DiskName: to.Ptr("gqpqpkxjyj"),
		// 						Folder: to.Ptr("oxdbbh"),
		// 						AvsVMInternalID: to.Ptr("xoiliugbcvkhdl"),
		// 						AvsVMResourceID: to.Ptr("jblyybyfhtikdhwx"),
		// 						AvsVMName: to.Ptr("gaeydwwisfuonbuwtnkdk"),
		// 						AvsStorageContainerResourceID: to.Ptr("svwilhkpx"),
		// 					},
		// 					ProvisioningState: to.Ptr(armpurestorageblock.ResourceProvisioningStateSucceeded),
		// 				},
		// 				ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}"),
		// 				Name: to.Ptr("hnglbdwyocdmggwii"),
		// 				Type: to.Ptr("jprfxakifyliuzougfctzpfhozq"),
		// 				SystemData: &armpurestorageblock.SystemData{
		// 					CreatedBy: to.Ptr("ruoitchmuomrbscg"),
		// 					CreatedByType: to.Ptr(armpurestorageblock.CreatedByTypeUser),
		// 					CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-10-04T05:29:25.341Z"); return t}()),
		// 					LastModifiedBy: to.Ptr("thfyhokbrldzmghuylqbwpbublj"),
		// 					LastModifiedByType: to.Ptr(armpurestorageblock.CreatedByTypeUser),
		// 					LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-10-04T05:29:25.345Z"); return t}()),
		// 				},
		// 			},
		// 		},
		// 		NextLink: to.Ptr("https://microsoft.com/aqekkjck"),
		// 	},
		// }
	}
}

type AvsVMVolumesClientBeginDeleteOptions 

type AvsVMVolumesClientBeginDeleteOptions struct {
	// Resumes the long-running operation from the provided token.
	ResumeToken string
}

AvsVMVolumesClientBeginDeleteOptions contains the optional parameters for the AvsVMVolumesClient.BeginDelete method.

type AvsVMVolumesClientBeginUpdateOptions 

type AvsVMVolumesClientBeginUpdateOptions struct {
	// Resumes the long-running operation from the provided token.
	ResumeToken string
}

AvsVMVolumesClientBeginUpdateOptions contains the optional parameters for the AvsVMVolumesClient.BeginUpdate method.

type AvsVMVolumesClientDeleteResponse 

type AvsVMVolumesClientDeleteResponse struct {
}

AvsVMVolumesClientDeleteResponse contains the response from method AvsVMVolumesClient.BeginDelete.

type AvsVMVolumesClientGetOptions 

type AvsVMVolumesClientGetOptions struct {
}

AvsVMVolumesClientGetOptions contains the optional parameters for the AvsVMVolumesClient.Get method.

type AvsVMVolumesClientGetResponse 

type AvsVMVolumesClientGetResponse struct {
	// Any volume associated to a particular AVS VM
	AvsVMVolume
}

AvsVMVolumesClientGetResponse contains the response from method AvsVMVolumesClient.Get.

type AvsVMVolumesClientListByAvsVMOptions 

type AvsVMVolumesClientListByAvsVMOptions struct {
}

AvsVMVolumesClientListByAvsVMOptions contains the optional parameters for the AvsVMVolumesClient.NewListByAvsVMPager method.

type AvsVMVolumesClientListByAvsVMResponse 

type AvsVMVolumesClientListByAvsVMResponse struct {
	// The response of a AvsVmVolume list operation.
	AvsVMVolumeListResult
}

AvsVMVolumesClientListByAvsVMResponse contains the response from method AvsVMVolumesClient.NewListByAvsVMPager.

type AvsVMVolumesClientUpdateResponse 

type AvsVMVolumesClientUpdateResponse struct {
	// Any volume associated to a particular AVS VM
	AvsVMVolume
}

AvsVMVolumesClientUpdateResponse contains the response from method AvsVMVolumesClient.BeginUpdate.

type AvsVMsClient 

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

AvsVMsClient contains the methods for the AvsVMs group. Don't use this type directly, use NewAvsVMsClient() instead.

func NewAvsVMsClient 

func NewAvsVMsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*AvsVMsClient, error)

NewAvsVMsClient creates a new instance of AvsVMsClient with the specified values.

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

func (*AvsVMsClient) BeginDelete 

func (client *AvsVMsClient) BeginDelete(ctx context.Context, resourceGroupName string, storagePoolName string, avsVMID string, options *AvsVMsClientBeginDeleteOptions) (*runtime.Poller[AvsVMsClientDeleteResponse], error)

BeginDelete - Delete an AVS VM If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • storagePoolName - Name of the storage pool
  • avsVMID - ID of the AVS VM
  • options - AvsVMsClientBeginDeleteOptions contains the optional parameters for the AvsVMsClient.BeginDelete method.
Example

Generated from example definition: 2024-11-01/AvsVms_Delete_MaximumSet_Gen.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/purestorageblock/armpurestorageblock"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armpurestorageblock.NewClientFactory("BC47D6CC-AA80-4374-86F8-19D94EC70666", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewAvsVMsClient().BeginDelete(ctx, "rgpurestorage", "storagePoolname", "cbdec-ddbb", 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)
	}
}

func (*AvsVMsClient) BeginUpdate 

func (client *AvsVMsClient) BeginUpdate(ctx context.Context, resourceGroupName string, storagePoolName string, avsVMID string, properties AvsVMUpdate, options *AvsVMsClientBeginUpdateOptions) (*runtime.Poller[AvsVMsClientUpdateResponse], error)

BeginUpdate - Update an AVS VM If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • storagePoolName - Name of the storage pool
  • avsVMID - ID of the AVS VM
  • properties - The resource properties to be updated.
  • options - AvsVMsClientBeginUpdateOptions contains the optional parameters for the AvsVMsClient.BeginUpdate method.
Example

Generated from example definition: 2024-11-01/AvsVms_Update_MaximumSet_Gen.json 

package main

import (
	"context"
	"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/purestorageblock/armpurestorageblock"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armpurestorageblock.NewClientFactory("BC47D6CC-AA80-4374-86F8-19D94EC70666", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewAvsVMsClient().BeginUpdate(ctx, "rgpurestorage", "storagePoolname", "cbdec-ddbb", armpurestorageblock.AvsVMUpdate{
		Properties: &armpurestorageblock.AvsVMUpdateProperties{
			SoftDeletion: &armpurestorageblock.SoftDeletion{
				Destroyed: to.Ptr(true),
			},
		},
	}, 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 = armpurestorageblock.AvsVMsClientUpdateResponse{
	// 	AvsVM: &armpurestorageblock.AvsVM{
	// 		Properties: &armpurestorageblock.AvsVMProperties{
	// 			StoragePoolInternalID: to.Ptr("zpchlbmnmgympdfqeuchp"),
	// 			StoragePoolResourceID: to.Ptr("refrmhvh"),
	// 			DisplayName: to.Ptr("zcpusnyyozsxptnvia"),
	// 			CreatedTimestamp: to.Ptr("eeczpavimq"),
	// 			SoftDeletion: &armpurestorageblock.SoftDeletion{
	// 				Destroyed: to.Ptr(true),
	// 				EradicationTimestamp: to.Ptr("kaxjtehra"),
	// 			},
	// 			VolumeContainerType: to.Ptr(armpurestorageblock.VolumeContainerTypeAVS),
	// 			Avs: &armpurestorageblock.AvsVMDetails{
	// 				VMID: to.Ptr("ljsdq"),
	// 				VMName: to.Ptr("hskuenhnxpscuqikeohkyjfebgzapx"),
	// 				VMType: to.Ptr(armpurestorageblock.VMTypeVVol),
	// 				AvsVMInternalID: to.Ptr("wnamcozqs"),
	// 			},
	// 			Space: &armpurestorageblock.Space{
	// 				TotalUsed: to.Ptr[int64](28),
	// 				Unique: to.Ptr[int64](4),
	// 				Snapshots: to.Ptr[int64](5),
	// 				Shared: to.Ptr[int64](9),
	// 			},
	// 			ProvisioningState: to.Ptr(armpurestorageblock.ResourceProvisioningStateSucceeded),
	// 		},
	// 		ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}"),
	// 		Name: to.Ptr("ifvdmtawvkzz"),
	// 		Type: to.Ptr("qsfuizcaje"),
	// 		SystemData: &armpurestorageblock.SystemData{
	// 			CreatedBy: to.Ptr("ruoitchmuomrbscg"),
	// 			CreatedByType: to.Ptr(armpurestorageblock.CreatedByTypeUser),
	// 			CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-10-04T05:29:25.341Z"); return t}()),
	// 			LastModifiedBy: to.Ptr("thfyhokbrldzmghuylqbwpbublj"),
	// 			LastModifiedByType: to.Ptr(armpurestorageblock.CreatedByTypeUser),
	// 			LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-10-04T05:29:25.345Z"); return t}()),
	// 		},
	// 	},
	// }
}

func (*AvsVMsClient) Get 

func (client *AvsVMsClient) Get(ctx context.Context, resourceGroupName string, storagePoolName string, avsVMID string, options *AvsVMsClientGetOptions) (AvsVMsClientGetResponse, error)

Get - Get an AVS VM If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • storagePoolName - Name of the storage pool
  • avsVMID - ID of the AVS VM
  • options - AvsVMsClientGetOptions contains the optional parameters for the AvsVMsClient.Get method.
Example

Generated from example definition: 2024-11-01/AvsVms_Get_MaximumSet_Gen.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/purestorageblock/armpurestorageblock"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armpurestorageblock.NewClientFactory("BC47D6CC-AA80-4374-86F8-19D94EC70666", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewAvsVMsClient().Get(ctx, "rgpurestorage", "storagePoolname", "cbdec-ddbb", 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 = armpurestorageblock.AvsVMsClientGetResponse{
	// 	AvsVM: &armpurestorageblock.AvsVM{
	// 		Properties: &armpurestorageblock.AvsVMProperties{
	// 			StoragePoolInternalID: to.Ptr("zpchlbmnmgympdfqeuchp"),
	// 			StoragePoolResourceID: to.Ptr("refrmhvh"),
	// 			DisplayName: to.Ptr("zcpusnyyozsxptnvia"),
	// 			CreatedTimestamp: to.Ptr("eeczpavimq"),
	// 			SoftDeletion: &armpurestorageblock.SoftDeletion{
	// 				Destroyed: to.Ptr(true),
	// 				EradicationTimestamp: to.Ptr("kaxjtehra"),
	// 			},
	// 			VolumeContainerType: to.Ptr(armpurestorageblock.VolumeContainerTypeAVS),
	// 			Avs: &armpurestorageblock.AvsVMDetails{
	// 				VMID: to.Ptr("ljsdq"),
	// 				VMName: to.Ptr("hskuenhnxpscuqikeohkyjfebgzapx"),
	// 				VMType: to.Ptr(armpurestorageblock.VMTypeVVol),
	// 				AvsVMInternalID: to.Ptr("wnamcozqs"),
	// 			},
	// 			Space: &armpurestorageblock.Space{
	// 				TotalUsed: to.Ptr[int64](28),
	// 				Unique: to.Ptr[int64](4),
	// 				Snapshots: to.Ptr[int64](5),
	// 				Shared: to.Ptr[int64](9),
	// 			},
	// 			ProvisioningState: to.Ptr(armpurestorageblock.ResourceProvisioningStateSucceeded),
	// 		},
	// 		ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}"),
	// 		Name: to.Ptr("ifvdmtawvkzz"),
	// 		Type: to.Ptr("qsfuizcaje"),
	// 		SystemData: &armpurestorageblock.SystemData{
	// 			CreatedBy: to.Ptr("ruoitchmuomrbscg"),
	// 			CreatedByType: to.Ptr(armpurestorageblock.CreatedByTypeUser),
	// 			CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-10-04T05:29:25.341Z"); return t}()),
	// 			LastModifiedBy: to.Ptr("thfyhokbrldzmghuylqbwpbublj"),
	// 			LastModifiedByType: to.Ptr(armpurestorageblock.CreatedByTypeUser),
	// 			LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-10-04T05:29:25.345Z"); return t}()),
	// 		},
	// 	},
	// }
}

func (*AvsVMsClient) NewListByStoragePoolPager 

func (client *AvsVMsClient) NewListByStoragePoolPager(resourceGroupName string, storagePoolName string, options *AvsVMsClientListByStoragePoolOptions) *runtime.Pager[AvsVMsClientListByStoragePoolResponse]

NewListByStoragePoolPager - List AVS VMs by storage pool

Generated from API version 2024-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • storagePoolName - Name of the storage pool
  • options - AvsVMsClientListByStoragePoolOptions contains the optional parameters for the AvsVMsClient.NewListByStoragePoolPager method.
Example

Generated from example definition: 2024-11-01/AvsVms_ListByStoragePool_MaximumSet_Gen.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/purestorageblock/armpurestorageblock"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armpurestorageblock.NewClientFactory("BC47D6CC-AA80-4374-86F8-19D94EC70666", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewAvsVMsClient().NewListByStoragePoolPager("rgpurestorage", "storagePoolname", 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 = armpurestorageblock.AvsVMsClientListByStoragePoolResponse{
		// 	AvsVMListResult: armpurestorageblock.AvsVMListResult{
		// 		Value: []*armpurestorageblock.AvsVM{
		// 			{
		// 				Properties: &armpurestorageblock.AvsVMProperties{
		// 					StoragePoolInternalID: to.Ptr("zpchlbmnmgympdfqeuchp"),
		// 					StoragePoolResourceID: to.Ptr("refrmhvh"),
		// 					DisplayName: to.Ptr("zcpusnyyozsxptnvia"),
		// 					CreatedTimestamp: to.Ptr("eeczpavimq"),
		// 					SoftDeletion: &armpurestorageblock.SoftDeletion{
		// 						Destroyed: to.Ptr(true),
		// 						EradicationTimestamp: to.Ptr("kaxjtehra"),
		// 					},
		// 					VolumeContainerType: to.Ptr(armpurestorageblock.VolumeContainerTypeAVS),
		// 					Avs: &armpurestorageblock.AvsVMDetails{
		// 						VMID: to.Ptr("ljsdq"),
		// 						VMName: to.Ptr("hskuenhnxpscuqikeohkyjfebgzapx"),
		// 						VMType: to.Ptr(armpurestorageblock.VMTypeVVol),
		// 						AvsVMInternalID: to.Ptr("wnamcozqs"),
		// 					},
		// 					Space: &armpurestorageblock.Space{
		// 						TotalUsed: to.Ptr[int64](28),
		// 						Unique: to.Ptr[int64](4),
		// 						Snapshots: to.Ptr[int64](5),
		// 						Shared: to.Ptr[int64](9),
		// 					},
		// 					ProvisioningState: to.Ptr(armpurestorageblock.ResourceProvisioningStateSucceeded),
		// 				},
		// 				ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}"),
		// 				Name: to.Ptr("ifvdmtawvkzz"),
		// 				Type: to.Ptr("qsfuizcaje"),
		// 				SystemData: &armpurestorageblock.SystemData{
		// 					CreatedBy: to.Ptr("ruoitchmuomrbscg"),
		// 					CreatedByType: to.Ptr(armpurestorageblock.CreatedByTypeUser),
		// 					CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-10-04T05:29:25.341Z"); return t}()),
		// 					LastModifiedBy: to.Ptr("thfyhokbrldzmghuylqbwpbublj"),
		// 					LastModifiedByType: to.Ptr(armpurestorageblock.CreatedByTypeUser),
		// 					LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-10-04T05:29:25.345Z"); return t}()),
		// 				},
		// 			},
		// 		},
		// 		NextLink: to.Ptr("https://microsoft.com/annrdra"),
		// 	},
		// }
	}
}

type AvsVMsClientBeginDeleteOptions 

type AvsVMsClientBeginDeleteOptions struct {
	// Resumes the long-running operation from the provided token.
	ResumeToken string
}

AvsVMsClientBeginDeleteOptions contains the optional parameters for the AvsVMsClient.BeginDelete method.

type AvsVMsClientBeginUpdateOptions 

type AvsVMsClientBeginUpdateOptions struct {
	// Resumes the long-running operation from the provided token.
	ResumeToken string
}

AvsVMsClientBeginUpdateOptions contains the optional parameters for the AvsVMsClient.BeginUpdate method.

type AvsVMsClientDeleteResponse 

type AvsVMsClientDeleteResponse struct {
}

AvsVMsClientDeleteResponse contains the response from method AvsVMsClient.BeginDelete.

type AvsVMsClientGetOptions 

type AvsVMsClientGetOptions struct {
}

AvsVMsClientGetOptions contains the optional parameters for the AvsVMsClient.Get method.

type AvsVMsClientGetResponse 

type AvsVMsClientGetResponse struct {
	// AVS VM resource type, representing all the volumes associated to an AVS VM as defined by VMware
	AvsVM
}

AvsVMsClientGetResponse contains the response from method AvsVMsClient.Get.

type AvsVMsClientListByStoragePoolOptions 

type AvsVMsClientListByStoragePoolOptions struct {
}

AvsVMsClientListByStoragePoolOptions contains the optional parameters for the AvsVMsClient.NewListByStoragePoolPager method.

type AvsVMsClientListByStoragePoolResponse 

type AvsVMsClientListByStoragePoolResponse struct {
	// The response of a AvsVm list operation.
	AvsVMListResult
}

AvsVMsClientListByStoragePoolResponse contains the response from method AvsVMsClient.NewListByStoragePoolPager.

type AvsVMsClientUpdateResponse 

type AvsVMsClientUpdateResponse struct {
	// AVS VM resource type, representing all the volumes associated to an AVS VM as defined by VMware
	AvsVM
}

AvsVMsClientUpdateResponse contains the response from method AvsVMsClient.BeginUpdate.

type AzureVmwareService 

type AzureVmwareService struct {
	// REQUIRED; If true, an AVS SDDC is successfully connected to the storage pool
	AvsEnabled *bool

	// Azure resource ID of the AVS SDDC the storage pool is connected to
	ClusterResourceID *string
}

AzureVmwareService - Connected AVS status

func (AzureVmwareService) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type AzureVmwareService.

func (*AzureVmwareService) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AzureVmwareService.

type BandwidthUsage 

type BandwidthUsage struct {
	// REQUIRED; Number of bytes written and read per second (maximum value over the last 10 minutes)
	Current *int64

	// REQUIRED; Maximum bandwidth value that can be provisioned for the storage pool
	Max *int64

	// REQUIRED; Bandwidth value currently provisioned for the storage pool, in MB/s
	Provisioned *int64
}

BandwidthUsage - Bandwidth usage metrics

func (BandwidthUsage) MarshalJSON 

func (b BandwidthUsage) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type BandwidthUsage.

func (*BandwidthUsage) UnmarshalJSON 

func (b *BandwidthUsage) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type BandwidthUsage.

type BillingUsageProperty 

type BillingUsageProperty struct {
	// REQUIRED; Current value of the billing usage property
	CurrentValue *string

	// REQUIRED; Unique identifier for the billing usage property
	PropertyID *string

	// REQUIRED; Name of the billing usage property
	PropertyName *string

	// REQUIRED; Severity level of the usage
	Severity *UsageSeverity

	// Previous value of the billing usage property
	PreviousValue *string

	// Status message for the billing usage against a property
	StatusMessage *string

	// Optional list of sub-properties providing additional details
	SubProperties []*BillingUsageProperty
}

BillingUsageProperty - Represents an individual billing usage property

func (BillingUsageProperty) MarshalJSON 

func (b BillingUsageProperty) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type BillingUsageProperty.

func (*BillingUsageProperty) UnmarshalJSON 

func (b *BillingUsageProperty) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type BillingUsageProperty.

type ClientFactory 

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 

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. The value must be an UUID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*ClientFactory) NewAvsStorageContainerVolumesClient 

func (c *ClientFactory) NewAvsStorageContainerVolumesClient() *AvsStorageContainerVolumesClient

NewAvsStorageContainerVolumesClient creates a new instance of AvsStorageContainerVolumesClient.

func (*ClientFactory) NewAvsStorageContainersClient 

func (c *ClientFactory) NewAvsStorageContainersClient() *AvsStorageContainersClient

NewAvsStorageContainersClient creates a new instance of AvsStorageContainersClient.

func (*ClientFactory) NewAvsVMVolumesClient 

func (c *ClientFactory) NewAvsVMVolumesClient() *AvsVMVolumesClient

NewAvsVMVolumesClient creates a new instance of AvsVMVolumesClient.

func (*ClientFactory) NewAvsVMsClient 

func (c *ClientFactory) NewAvsVMsClient() *AvsVMsClient

NewAvsVMsClient creates a new instance of AvsVMsClient.

func (*ClientFactory) NewOperationsClient 

func (c *ClientFactory) NewOperationsClient() *OperationsClient

NewOperationsClient creates a new instance of OperationsClient.

func (*ClientFactory) NewReservationsClient 

func (c *ClientFactory) NewReservationsClient() *ReservationsClient

NewReservationsClient creates a new instance of ReservationsClient.

func (*ClientFactory) NewStoragePoolsClient 

func (c *ClientFactory) NewStoragePoolsClient() *StoragePoolsClient

NewStoragePoolsClient creates a new instance of StoragePoolsClient.

type CompanyDetails 

type CompanyDetails struct {
	// REQUIRED; Company name
	CompanyName *string

	// Company address
	Address *Address
}

CompanyDetails - Company details

func (CompanyDetails) MarshalJSON 

func (c CompanyDetails) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type CompanyDetails.

func (*CompanyDetails) UnmarshalJSON 

func (c *CompanyDetails) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type CompanyDetails.

type CreatedByType 

type CreatedByType string

CreatedByType - The kind of entity that created the resource. 

const (
	// CreatedByTypeApplication - The entity was created by an application.
	CreatedByTypeApplication CreatedByType = "Application"
	// CreatedByTypeKey - The entity was created by a key.
	CreatedByTypeKey CreatedByType = "Key"
	// CreatedByTypeManagedIdentity - The entity was created by a managed identity.
	CreatedByTypeManagedIdentity CreatedByType = "ManagedIdentity"
	// CreatedByTypeUser - The entity was created by a user.
	CreatedByTypeUser CreatedByType = "User"
)

func PossibleCreatedByTypeValues 

func PossibleCreatedByTypeValues() []CreatedByType

PossibleCreatedByTypeValues returns the possible values for the CreatedByType const type.

type HealthDetails 

type HealthDetails struct {
	// REQUIRED; Bandwidth usage metrics
	BandwidthUsage *BandwidthUsage

	// REQUIRED; Data reduction ratio achieved on this pool
	DataReductionRatio *float64

	// REQUIRED; Estimated maximum capacity of the pool, in bytes, based on current usage and data reduction ratio
	EstimatedMaxCapacity *int64

	// REQUIRED; IOPS usage metrics
	IopsUsage *IopsUsage

	// REQUIRED; Storage space usage
	Space *Space

	// REQUIRED; How full the pool is right now, in %, compared to the maximum size it can grow to; estimated based on current
	// usage and data reduction ratio
	UsedCapacityPercentage *float64
}

HealthDetails - Health metrics for a storage pool

func (HealthDetails) MarshalJSON 

func (h HealthDetails) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type HealthDetails.

func (*HealthDetails) UnmarshalJSON 

func (h *HealthDetails) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type HealthDetails.

type IopsUsage 

type IopsUsage struct {
	// REQUIRED; Current number of IOPS (maximum value over the last 10 minutes)
	Current *int64

	// REQUIRED; Maximum IOPS value that can be provisioned for the storage pool
	Max *int64

	// REQUIRED; IOPS value currently provisioned for the storage pool
	Provisioned *int64
}

IopsUsage - IOPS usage metrics

func (IopsUsage) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type IopsUsage.

func (*IopsUsage) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type IopsUsage.

type LimitDetails 

type LimitDetails struct {
	// REQUIRED; internal
	PerformancePolicy *PerformancePolicyLimits

	// REQUIRED; internal
	ProtectionPolicy *ProtectionPolicyLimits

	// REQUIRED; Limits used for storage pool resources
	StoragePool *StoragePoolLimits

	// REQUIRED; Limits used for volume resources
	Volume *VolumeLimits
}

LimitDetails - Limits constraining certain resource properties

func (LimitDetails) MarshalJSON 

func (l LimitDetails) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type LimitDetails.

func (*LimitDetails) UnmarshalJSON 

func (l *LimitDetails) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type LimitDetails.

type ManagedServiceIdentity 

type ManagedServiceIdentity struct {
	// REQUIRED; The type of managed identity assigned to this resource.
	Type *ManagedServiceIdentityType

	// The identities assigned to this resource by the user.
	UserAssignedIdentities map[string]*UserAssignedIdentity

	// READ-ONLY; The service principal ID of the system assigned identity. This property will only be provided for a system assigned
	// identity.
	PrincipalID *string

	// READ-ONLY; The tenant ID of the system assigned identity. This property will only be provided for a system assigned identity.
	TenantID *string
}

ManagedServiceIdentity - Managed service identity (system assigned and/or user assigned identities)

func (ManagedServiceIdentity) MarshalJSON 

func (m ManagedServiceIdentity) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ManagedServiceIdentity.

func (*ManagedServiceIdentity) UnmarshalJSON 

func (m *ManagedServiceIdentity) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ManagedServiceIdentity.

type ManagedServiceIdentityType 

type ManagedServiceIdentityType string

ManagedServiceIdentityType - Type of managed service identity (where both SystemAssigned and UserAssigned types are allowed). 

const (
	// ManagedServiceIdentityTypeNone - No managed identity.
	ManagedServiceIdentityTypeNone ManagedServiceIdentityType = "None"
	// ManagedServiceIdentityTypeSystemAssigned - System assigned managed identity.
	ManagedServiceIdentityTypeSystemAssigned ManagedServiceIdentityType = "SystemAssigned"
	// ManagedServiceIdentityTypeSystemAssignedUserAssigned - System and user assigned managed identity.
	ManagedServiceIdentityTypeSystemAssignedUserAssigned ManagedServiceIdentityType = "SystemAssigned,UserAssigned"
	// ManagedServiceIdentityTypeUserAssigned - User assigned managed identity.
	ManagedServiceIdentityTypeUserAssigned ManagedServiceIdentityType = "UserAssigned"
)

func PossibleManagedServiceIdentityTypeValues 

func PossibleManagedServiceIdentityTypeValues() []ManagedServiceIdentityType

PossibleManagedServiceIdentityTypeValues returns the possible values for the ManagedServiceIdentityType const type.

type MarketplaceDetails 

type MarketplaceDetails struct {
	// REQUIRED; Offer details of the marketplace subscription
	OfferDetails *OfferDetails

	// Marketplace subscription status
	SubscriptionStatus *MarketplaceSubscriptionStatus

	// READ-ONLY; Marketplace subscription ID
	SubscriptionID *string
}

MarketplaceDetails - Marketplace details

func (MarketplaceDetails) MarshalJSON 

func (m MarketplaceDetails) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type MarketplaceDetails.

func (*MarketplaceDetails) UnmarshalJSON 

func (m *MarketplaceDetails) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type MarketplaceDetails.

type MarketplaceSubscriptionStatus 

type MarketplaceSubscriptionStatus string

MarketplaceSubscriptionStatus - Marketplace subscription status 

const (
	// MarketplaceSubscriptionStatusPendingFulfillmentStart - Marketplace subscription purchased but not yet activated
	MarketplaceSubscriptionStatusPendingFulfillmentStart MarketplaceSubscriptionStatus = "PendingFulfillmentStart"
	// MarketplaceSubscriptionStatusSubscribed - Marketplace subscription activated
	MarketplaceSubscriptionStatusSubscribed MarketplaceSubscriptionStatus = "Subscribed"
	// MarketplaceSubscriptionStatusSuspended - Marketplace subscription suspended due to missing customer payment
	MarketplaceSubscriptionStatusSuspended MarketplaceSubscriptionStatus = "Suspended"
	// MarketplaceSubscriptionStatusUnsubscribed - Marketplace subscription cancelled
	MarketplaceSubscriptionStatusUnsubscribed MarketplaceSubscriptionStatus = "Unsubscribed"
)

func PossibleMarketplaceSubscriptionStatusValues 

func PossibleMarketplaceSubscriptionStatusValues() []MarketplaceSubscriptionStatus

PossibleMarketplaceSubscriptionStatusValues returns the possible values for the MarketplaceSubscriptionStatus const type.

type OfferDetails 

type OfferDetails struct {
	// REQUIRED; Offer ID for the marketplace offer
	OfferID *string

	// REQUIRED; Plan ID for the marketplace offer
	PlanID *string

	// REQUIRED; Publisher ID for the marketplace offer
	PublisherID *string

	// Plan Name for the marketplace offer
	PlanName *string

	// Term ID for the marketplace offer
	TermID *string

	// Term Unit for the marketplace offer
	TermUnit *string
}

OfferDetails - Offer details for the marketplace that is selected by the user

func (OfferDetails) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type OfferDetails.

func (*OfferDetails) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type OfferDetails.

type Operation 

type Operation struct {
	// Localized display information for this particular operation.
	Display *OperationDisplay

	// READ-ONLY; Extensible enum. Indicates the action type. "Internal" refers to actions that are for internal only APIs.
	ActionType *ActionType

	// READ-ONLY; Whether the operation applies to data-plane. This is "true" for data-plane operations and "false" for Azure
	// Resource Manager/control-plane operations.
	IsDataAction *bool

	// READ-ONLY; The name of the operation, as per Resource-Based Access Control (RBAC). Examples: "Microsoft.Compute/virtualMachines/write",
	// "Microsoft.Compute/virtualMachines/capture/action"
	Name *string

	// READ-ONLY; The intended executor of the operation; as in Resource Based Access Control (RBAC) and audit logs UX. Default
	// value is "user,system"
	Origin *Origin
}

Operation - REST API Operation

Details of a REST API operation, returned from the Resource Provider Operations API

func (Operation) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type Operation.

func (*Operation) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type Operation.

type OperationDisplay 

type OperationDisplay struct {
	// READ-ONLY; The short, localized friendly description of the operation; suitable for tool tips and detailed views.
	Description *string

	// READ-ONLY; The concise, localized friendly name for the operation; suitable for dropdowns. E.g. "Create or Update Virtual
	// Machine", "Restart Virtual Machine".
	Operation *string

	// READ-ONLY; The localized friendly form of the resource provider name, e.g. "Microsoft Monitoring Insights" or "Microsoft
	// Compute".
	Provider *string

	// READ-ONLY; The localized friendly name of the resource type related to this operation. E.g. "Virtual Machines" or "Job
	// Schedule Collections".
	Resource *string
}

OperationDisplay - Localized display information for and operation.

func (OperationDisplay) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type OperationDisplay.

func (*OperationDisplay) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type OperationDisplay.

type OperationListResult 

type OperationListResult struct {
	// REQUIRED; The Operation items on this page
	Value []*Operation

	// The link to the next page of items
	NextLink *string
}

OperationListResult - A list of REST API operations supported by an Azure Resource Provider. It contains an URL link to get the next set of results.

func (OperationListResult) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type OperationListResult.

func (*OperationListResult) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type OperationListResult.

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 

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

NewListPager - List the operations for the provider

Generated from API version 2024-11-01

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

Generated from example definition: 2024-11-01/Operations_List_MaximumSet_Gen.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/purestorageblock/armpurestorageblock"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armpurestorageblock.NewClientFactory("<subscriptionID>", 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 = armpurestorageblock.OperationsClientListResponse{
		// 	OperationListResult: armpurestorageblock.OperationListResult{
		// 		Value: []*armpurestorageblock.Operation{
		// 			{
		// 				Name: to.Ptr("wikaab"),
		// 				IsDataAction: to.Ptr(true),
		// 				Display: &armpurestorageblock.OperationDisplay{
		// 					Provider: to.Ptr("oqlfyrrvbitoadnqagqkgxylxkow"),
		// 					Resource: to.Ptr("dxeqyes"),
		// 					Operation: to.Ptr("mk"),
		// 					Description: to.Ptr("zcgnhznothktczdlyovbbjwnxep"),
		// 				},
		// 				Origin: to.Ptr(armpurestorageblock.OriginUser),
		// 				ActionType: to.Ptr(armpurestorageblock.ActionTypeInternal),
		// 			},
		// 		},
		// 		NextLink: to.Ptr("https://microsoft.com/a"),
		// 	},
		// }
	}
}
Example (OperationsListMinimumGenSet)

Generated from example definition: 2024-11-01/Operations_List_MinimumSet_Gen.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/purestorageblock/armpurestorageblock"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armpurestorageblock.NewClientFactory("<subscriptionID>", 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 = armpurestorageblock.OperationsClientListResponse{
		// 	OperationListResult: armpurestorageblock.OperationListResult{
		// 	},
		// }
	}
}

type OperationsClientListOptions 

type OperationsClientListOptions struct {
}

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

type OperationsClientListResponse 

type OperationsClientListResponse struct {
	// A list of REST API operations supported by an Azure Resource Provider. It contains an URL link to get the next set of results.
	OperationListResult
}

OperationsClientListResponse contains the response from method OperationsClient.NewListPager.

type Origin 

type Origin string

Origin - The intended executor of the operation; as in Resource Based Access Control (RBAC) and audit logs UX. Default value is "user,system" 

const (
	// OriginSystem - Indicates the operation is initiated by a system.
	OriginSystem Origin = "system"
	// OriginUser - Indicates the operation is initiated by a user.
	OriginUser Origin = "user"
	// OriginUserSystem - Indicates the operation is initiated by a user or system.
	OriginUserSystem Origin = "user,system"
)

func PossibleOriginValues 

func PossibleOriginValues() []Origin

PossibleOriginValues returns the possible values for the Origin const type.

type PerformancePolicyLimits 

type PerformancePolicyLimits struct {
	// REQUIRED; internal
	BandwidthLimit *RangeLimits

	// REQUIRED; internal
	IopsLimit *RangeLimits
}

PerformancePolicyLimits - internal

func (PerformancePolicyLimits) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type PerformancePolicyLimits.

func (*PerformancePolicyLimits) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type PerformancePolicyLimits.

type ProtectionPolicyLimits 

type ProtectionPolicyLimits struct {
	// REQUIRED; internal
	Frequency *RangeLimits

	// REQUIRED; internal
	Retention *RangeLimits
}

ProtectionPolicyLimits - internal

func (ProtectionPolicyLimits) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ProtectionPolicyLimits.

func (*ProtectionPolicyLimits) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ProtectionPolicyLimits.

type ProvisioningState 

type ProvisioningState string

ProvisioningState - The status of the current operation. 

const (
	// ProvisioningStateAccepted - Change accepted for processing
	ProvisioningStateAccepted ProvisioningState = "Accepted"
	// ProvisioningStateCanceled - Resource creation was canceled.
	ProvisioningStateCanceled ProvisioningState = "Canceled"
	// ProvisioningStateDeleting - Deletion in progress
	ProvisioningStateDeleting ProvisioningState = "Deleting"
	// ProvisioningStateFailed - Resource creation failed.
	ProvisioningStateFailed ProvisioningState = "Failed"
	// ProvisioningStateSucceeded - Resource has been created.
	ProvisioningStateSucceeded ProvisioningState = "Succeeded"
)

func PossibleProvisioningStateValues 

func PossibleProvisioningStateValues() []ProvisioningState

PossibleProvisioningStateValues returns the possible values for the ProvisioningState const type.

type RangeLimits 

type RangeLimits struct {
	// REQUIRED; Maximum value of the property
	Max *int64

	// REQUIRED; Minimum value of the property
	Min *int64
}

RangeLimits - Minimum and maximum values for a property

func (RangeLimits) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type RangeLimits.

func (*RangeLimits) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type RangeLimits.

type Reservation 

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

	// The resource-specific properties for this resource.
	Properties *ReservationPropertiesBaseResourceProperties

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

	// READ-ONLY; Name of the reservation.
	Name *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 Manager metadata containing createdBy and modifiedBy information.
	SystemData *SystemData

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

Reservation - Pure Storage cloud service resource type, also called reservation

func (Reservation) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type Reservation.

func (*Reservation) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type Reservation.

type ReservationBillingStatus 

type ReservationBillingStatus struct {
	// REQUIRED; Weighted average of the data-reduction ratio for all associated pools
	DrrWeightedAverage *float64

	// REQUIRED; Extra capacity added when rounding up low-usage pools to 30TiB. In bytes
	ExtraUsedCapacityLowUsageRounding *int64

	// REQUIRED; Extra capacity added because of low DRR storage pools; In bytes
	ExtraUsedCapacityNonReducible *int64

	// REQUIRED; Extra capacity discounted due to plan forgiving some low-DRR usage. In bytes
	ExtraUsedCapacityNonReduciblePlanDiscount *int64

	// REQUIRED; How many associated storage pools reported low data reduction ratio (DRR)
	LowDrrPoolCount *int32

	// REQUIRED; Timestamp for the latest update of this billing status, in RFC 3339 format
	Timestamp *string

	// REQUIRED; The sum of total used capacity for all pools with low DRR, if the DRR penalty applies. In bytes
	TotalNonReducibleReported *int64

	// REQUIRED; Total performance amount included in plan. In bytes per second
	TotalPerformanceIncludedPlan *int64

	// REQUIRED; Total performance amount reported at on-demand price. In MB per second
	TotalPerformanceOverage *int64

	// REQUIRED; The sum of all performance settings across the pools under this reservation. In MB per second
	TotalPerformanceReported *int64

	// REQUIRED; Total used capacity actually billed. In bytes
	TotalUsedCapacityBilled *int64

	// REQUIRED; Total used capacity included in plan. In bytes
	TotalUsedCapacityIncludedPlan *int64

	// REQUIRED; Total used capacity reported at on-demand price. In bytes
	TotalUsedCapacityOverage *int64

	// REQUIRED; Total used capacity as reported by associated storage pools. In bytes
	TotalUsedCapacityReported *int64
}

ReservationBillingStatus - Latest billing status for this reservation

func (ReservationBillingStatus) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ReservationBillingStatus.

func (*ReservationBillingStatus) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ReservationBillingStatus.

type ReservationBillingUsageReport 

type ReservationBillingUsageReport struct {
	// REQUIRED; A list of detailed billing usage properties
	BillingUsageProperties []*BillingUsageProperty

	// REQUIRED; Overall status message of the billing usage report
	OverallStatusMessage *string

	// REQUIRED; Latest formatted billing report for this reservation
	Timestamp *string
}

ReservationBillingUsageReport - Represents a billing usage report, including overall status and detailed properties

func (ReservationBillingUsageReport) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ReservationBillingUsageReport.

func (*ReservationBillingUsageReport) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ReservationBillingUsageReport.

type ReservationListResult 

type ReservationListResult struct {
	// REQUIRED; The Reservation items on this page
	Value []*Reservation

	// The link to the next page of items
	NextLink *string
}

ReservationListResult - The response of a Reservation list operation.

func (ReservationListResult) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ReservationListResult.

func (*ReservationListResult) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ReservationListResult.

type ReservationPropertiesBaseResourceProperties 

type ReservationPropertiesBaseResourceProperties struct {
	// REQUIRED; Marketplace details
	Marketplace *MarketplaceDetails

	// REQUIRED; User details
	User *UserDetails

	// READ-ONLY; Provisioning state of the resource
	ProvisioningState *ProvisioningState

	// READ-ONLY; Pure Storage's internal ID for the reservation
	ReservationInternalID *string
}

ReservationPropertiesBaseResourceProperties - Properties of a Reservation resource.

func (ReservationPropertiesBaseResourceProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ReservationPropertiesBaseResourceProperties.

func (*ReservationPropertiesBaseResourceProperties) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ReservationPropertiesBaseResourceProperties.

type ReservationUpdate 

type ReservationUpdate struct {
	// The resource-specific properties for this resource.
	Properties *ReservationUpdateProperties

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

ReservationUpdate - The type used for update operations of the Reservation.

func (ReservationUpdate) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ReservationUpdate.

func (*ReservationUpdate) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ReservationUpdate.

type ReservationUpdateProperties 

type ReservationUpdateProperties struct {
	// User details
	User *UserDetails
}

ReservationUpdateProperties - The updatable properties of the Reservation.

func (ReservationUpdateProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ReservationUpdateProperties.

func (*ReservationUpdateProperties) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ReservationUpdateProperties.

type ReservationsClient 

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

ReservationsClient contains the methods for the Reservations group. Don't use this type directly, use NewReservationsClient() instead.

func NewReservationsClient 

func NewReservationsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*ReservationsClient, error)

NewReservationsClient creates a new instance of ReservationsClient with the specified values.

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

func (*ReservationsClient) BeginCreate 

func (client *ReservationsClient) BeginCreate(ctx context.Context, resourceGroupName string, reservationName string, resource Reservation, options *ReservationsClientBeginCreateOptions) (*runtime.Poller[ReservationsClientCreateResponse], error)

BeginCreate - Create a reservation If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • reservationName - Name of the reservation.
  • resource - Resource create parameters.
  • options - ReservationsClientBeginCreateOptions contains the optional parameters for the ReservationsClient.BeginCreate method.

func (*ReservationsClient) BeginDelete 

func (client *ReservationsClient) BeginDelete(ctx context.Context, resourceGroupName string, reservationName string, options *ReservationsClientBeginDeleteOptions) (*runtime.Poller[ReservationsClientDeleteResponse], error)

BeginDelete - Delete a reservation If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • reservationName - Name of the reservation.
  • options - ReservationsClientBeginDeleteOptions contains the optional parameters for the ReservationsClient.BeginDelete method.

func (*ReservationsClient) BeginUpdate 

func (client *ReservationsClient) BeginUpdate(ctx context.Context, resourceGroupName string, reservationName string, properties ReservationUpdate, options *ReservationsClientBeginUpdateOptions) (*runtime.Poller[ReservationsClientUpdateResponse], error)

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

Generated from API version 2024-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • reservationName - Name of the reservation.
  • properties - The resource properties to be updated.
  • options - ReservationsClientBeginUpdateOptions contains the optional parameters for the ReservationsClient.BeginUpdate method.

func (*ReservationsClient) Get 

func (client *ReservationsClient) Get(ctx context.Context, resourceGroupName string, reservationName string, options *ReservationsClientGetOptions) (ReservationsClientGetResponse, error)

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

Generated from API version 2024-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • reservationName - Name of the reservation.
  • options - ReservationsClientGetOptions contains the optional parameters for the ReservationsClient.Get method.

func (*ReservationsClient) GetBillingReport 

func (client *ReservationsClient) GetBillingReport(ctx context.Context, resourceGroupName string, reservationName string, options *ReservationsClientGetBillingReportOptions) (ReservationsClientGetBillingReportResponse, error)

GetBillingReport - Provides a summarized report along with actions for resources billed via given reservation If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • reservationName - Name of the reservation.
  • options - ReservationsClientGetBillingReportOptions contains the optional parameters for the ReservationsClient.GetBillingReport method.
Example

Generated from example definition: 2024-11-01/Reservations_GetBillingReport_MaximumSet_Gen.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/purestorageblock/armpurestorageblock"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armpurestorageblock.NewClientFactory("BC47D6CC-AA80-4374-86F8-19D94EC70666", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewReservationsClient().GetBillingReport(ctx, "rgpurestorage", "reservationname", 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 = armpurestorageblock.ReservationsClientGetBillingReportResponse{
	// 	ReservationBillingUsageReport: &armpurestorageblock.ReservationBillingUsageReport{
	// 		Timestamp: to.Ptr("2024-10-04T05:29:25.345Z"),
	// 		BillingUsageProperties: []*armpurestorageblock.BillingUsageProperty{
	// 			{
	// 				PropertyID: to.Ptr("fknpxmzbrocjevhnuxohiwl"),
	// 				PropertyName: to.Ptr("rznqcuwmulhtvp"),
	// 				CurrentValue: to.Ptr("ndiuedcwtwpedirqdq"),
	// 				PreviousValue: to.Ptr("fqnvq"),
	// 				Severity: to.Ptr(armpurestorageblock.UsageSeverityALERT),
	// 				StatusMessage: to.Ptr("vkce"),
	// 				SubProperties: []*armpurestorageblock.BillingUsageProperty{
	// 				},
	// 			},
	// 		},
	// 		OverallStatusMessage: to.Ptr("aurwogtwwsxjoocpsobslpv"),
	// 	},
	// }
}

func (*ReservationsClient) GetBillingStatus 

func (client *ReservationsClient) GetBillingStatus(ctx context.Context, resourceGroupName string, reservationName string, options *ReservationsClientGetBillingStatusOptions) (ReservationsClientGetBillingStatusResponse, error)

GetBillingStatus - Provides various statistics about resources billed via given reservation. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • reservationName - Name of the reservation.
  • options - ReservationsClientGetBillingStatusOptions contains the optional parameters for the ReservationsClient.GetBillingStatus method.
Example

Generated from example definition: 2024-11-01/Reservations_GetBillingStatus_MaximumSet_Gen.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/purestorageblock/armpurestorageblock"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armpurestorageblock.NewClientFactory("BC47D6CC-AA80-4374-86F8-19D94EC70666", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewReservationsClient().GetBillingStatus(ctx, "rgpurestorage", "reservationname", 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 = armpurestorageblock.ReservationsClientGetBillingStatusResponse{
	// 	ReservationBillingStatus: &armpurestorageblock.ReservationBillingStatus{
	// 		Timestamp: to.Ptr("2024-10-04T05:29:25.345Z"),
	// 		TotalUsedCapacityReported: to.Ptr[int64](8),
	// 		LowDrrPoolCount: to.Ptr[int32](5),
	// 		DrrWeightedAverage: to.Ptr[float64](15),
	// 		TotalNonReducibleReported: to.Ptr[int64](9),
	// 		ExtraUsedCapacityNonReducible: to.Ptr[int64](12),
	// 		ExtraUsedCapacityLowUsageRounding: to.Ptr[int64](9),
	// 		ExtraUsedCapacityNonReduciblePlanDiscount: to.Ptr[int64](19),
	// 		TotalUsedCapacityBilled: to.Ptr[int64](7),
	// 		TotalUsedCapacityIncludedPlan: to.Ptr[int64](18),
	// 		TotalUsedCapacityOverage: to.Ptr[int64](28),
	// 		TotalPerformanceReported: to.Ptr[int64](29),
	// 		TotalPerformanceIncludedPlan: to.Ptr[int64](23),
	// 		TotalPerformanceOverage: to.Ptr[int64](16),
	// 	},
	// }
}

func (*ReservationsClient) GetResourceLimits 

func (client *ReservationsClient) GetResourceLimits(ctx context.Context, resourceGroupName string, reservationName string, options *ReservationsClientGetResourceLimitsOptions) (ReservationsClientGetResourceLimitsResponse, error)

GetResourceLimits - Limits constraining certain resource properties. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • reservationName - Name of the reservation.
  • options - ReservationsClientGetResourceLimitsOptions contains the optional parameters for the ReservationsClient.GetResourceLimits method.
Example

Generated from example definition: 2024-11-01/Reservations_GetResourceLimits_MaximumSet_Gen.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/purestorageblock/armpurestorageblock"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armpurestorageblock.NewClientFactory("BC47D6CC-AA80-4374-86F8-19D94EC70666", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewReservationsClient().GetResourceLimits(ctx, "rgpurestorage", "storagePoolname", 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 = armpurestorageblock.ReservationsClientGetResourceLimitsResponse{
	// 	LimitDetails: &armpurestorageblock.LimitDetails{
	// 		StoragePool: &armpurestorageblock.StoragePoolLimits{
	// 			ProvisionedBandwidthMbPerSec: &armpurestorageblock.RangeLimits{
	// 				Min: to.Ptr[int64](26),
	// 				Max: to.Ptr[int64](2),
	// 			},
	// 			ProvisionedIops: &armpurestorageblock.RangeLimits{
	// 				Min: to.Ptr[int64](26),
	// 				Max: to.Ptr[int64](2),
	// 			},
	// 			PhysicalAvailabilityZones: []*string{
	// 				to.Ptr("bhcreafgubemvymffktiojnkblw"),
	// 			},
	// 		},
	// 		Volume: &armpurestorageblock.VolumeLimits{
	// 			ProvisionedSize: &armpurestorageblock.RangeLimits{
	// 				Min: to.Ptr[int64](26),
	// 				Max: to.Ptr[int64](2),
	// 			},
	// 		},
	// 		ProtectionPolicy: &armpurestorageblock.ProtectionPolicyLimits{
	// 			Frequency: &armpurestorageblock.RangeLimits{
	// 				Min: to.Ptr[int64](26),
	// 				Max: to.Ptr[int64](2),
	// 			},
	// 			Retention: &armpurestorageblock.RangeLimits{
	// 				Min: to.Ptr[int64](26),
	// 				Max: to.Ptr[int64](2),
	// 			},
	// 		},
	// 		PerformancePolicy: &armpurestorageblock.PerformancePolicyLimits{
	// 			IopsLimit: &armpurestorageblock.RangeLimits{
	// 				Min: to.Ptr[int64](26),
	// 				Max: to.Ptr[int64](2),
	// 			},
	// 			BandwidthLimit: &armpurestorageblock.RangeLimits{
	// 				Min: to.Ptr[int64](26),
	// 				Max: to.Ptr[int64](2),
	// 			},
	// 		},
	// 	},
	// }
}

func (*ReservationsClient) NewListByResourceGroupPager 

func (client *ReservationsClient) NewListByResourceGroupPager(resourceGroupName string, options *ReservationsClientListByResourceGroupOptions) *runtime.Pager[ReservationsClientListByResourceGroupResponse]

NewListByResourceGroupPager - List reservations by resource group

Generated from API version 2024-11-01

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

func (*ReservationsClient) NewListBySubscriptionPager 

func (client *ReservationsClient) NewListBySubscriptionPager(options *ReservationsClientListBySubscriptionOptions) *runtime.Pager[ReservationsClientListBySubscriptionResponse]

NewListBySubscriptionPager - List reservations by Azure subscription ID

Generated from API version 2024-11-01

  • options - ReservationsClientListBySubscriptionOptions contains the optional parameters for the ReservationsClient.NewListBySubscriptionPager method.

type ReservationsClientBeginCreateOptions 

type ReservationsClientBeginCreateOptions struct {
	// Resumes the long-running operation from the provided token.
	ResumeToken string
}

ReservationsClientBeginCreateOptions contains the optional parameters for the ReservationsClient.BeginCreate method.

type ReservationsClientBeginDeleteOptions 

type ReservationsClientBeginDeleteOptions struct {
	// Resumes the long-running operation from the provided token.
	ResumeToken string
}

ReservationsClientBeginDeleteOptions contains the optional parameters for the ReservationsClient.BeginDelete method.

type ReservationsClientBeginUpdateOptions 

type ReservationsClientBeginUpdateOptions struct {
	// Resumes the long-running operation from the provided token.
	ResumeToken string
}

ReservationsClientBeginUpdateOptions contains the optional parameters for the ReservationsClient.BeginUpdate method.

type ReservationsClientCreateResponse 

type ReservationsClientCreateResponse struct {
	// Pure Storage cloud service resource type, also called reservation
	Reservation
}

ReservationsClientCreateResponse contains the response from method ReservationsClient.BeginCreate.

type ReservationsClientDeleteResponse 

type ReservationsClientDeleteResponse struct {
}

ReservationsClientDeleteResponse contains the response from method ReservationsClient.BeginDelete.

type ReservationsClientGetBillingReportOptions 

type ReservationsClientGetBillingReportOptions struct {
}

ReservationsClientGetBillingReportOptions contains the optional parameters for the ReservationsClient.GetBillingReport method.

type ReservationsClientGetBillingReportResponse 

type ReservationsClientGetBillingReportResponse struct {
	// Represents a billing usage report, including overall status and detailed properties
	ReservationBillingUsageReport
}

ReservationsClientGetBillingReportResponse contains the response from method ReservationsClient.GetBillingReport.

type ReservationsClientGetBillingStatusOptions 

type ReservationsClientGetBillingStatusOptions struct {
}

ReservationsClientGetBillingStatusOptions contains the optional parameters for the ReservationsClient.GetBillingStatus method.

type ReservationsClientGetBillingStatusResponse 

type ReservationsClientGetBillingStatusResponse struct {
	// Latest billing status for this reservation
	ReservationBillingStatus
}

ReservationsClientGetBillingStatusResponse contains the response from method ReservationsClient.GetBillingStatus.

type ReservationsClientGetOptions 

type ReservationsClientGetOptions struct {
}

ReservationsClientGetOptions contains the optional parameters for the ReservationsClient.Get method.

type ReservationsClientGetResourceLimitsOptions 

type ReservationsClientGetResourceLimitsOptions struct {
}

ReservationsClientGetResourceLimitsOptions contains the optional parameters for the ReservationsClient.GetResourceLimits method.

type ReservationsClientGetResourceLimitsResponse 

type ReservationsClientGetResourceLimitsResponse struct {
	// Limits constraining certain resource properties
	LimitDetails
}

ReservationsClientGetResourceLimitsResponse contains the response from method ReservationsClient.GetResourceLimits.

type ReservationsClientGetResponse 

type ReservationsClientGetResponse struct {
	// Pure Storage cloud service resource type, also called reservation
	Reservation
}

ReservationsClientGetResponse contains the response from method ReservationsClient.Get.

type ReservationsClientListByResourceGroupOptions 

type ReservationsClientListByResourceGroupOptions struct {
}

ReservationsClientListByResourceGroupOptions contains the optional parameters for the ReservationsClient.NewListByResourceGroupPager method.

type ReservationsClientListByResourceGroupResponse 

type ReservationsClientListByResourceGroupResponse struct {
	// The response of a Reservation list operation.
	ReservationListResult
}

ReservationsClientListByResourceGroupResponse contains the response from method ReservationsClient.NewListByResourceGroupPager.

type ReservationsClientListBySubscriptionOptions 

type ReservationsClientListBySubscriptionOptions struct {
}

ReservationsClientListBySubscriptionOptions contains the optional parameters for the ReservationsClient.NewListBySubscriptionPager method.

type ReservationsClientListBySubscriptionResponse 

type ReservationsClientListBySubscriptionResponse struct {
	// The response of a Reservation list operation.
	ReservationListResult
}

ReservationsClientListBySubscriptionResponse contains the response from method ReservationsClient.NewListBySubscriptionPager.

type ReservationsClientUpdateResponse 

type ReservationsClientUpdateResponse struct {
	// Pure Storage cloud service resource type, also called reservation
	Reservation
}

ReservationsClientUpdateResponse contains the response from method ReservationsClient.BeginUpdate.

type ResourceProvisioningState 

type ResourceProvisioningState string

ResourceProvisioningState - The provisioning state of a resource type. 

const (
	// ResourceProvisioningStateCanceled - Resource creation was canceled.
	ResourceProvisioningStateCanceled ResourceProvisioningState = "Canceled"
	// ResourceProvisioningStateFailed - Resource creation failed.
	ResourceProvisioningStateFailed ResourceProvisioningState = "Failed"
	// ResourceProvisioningStateSucceeded - Resource has been created.
	ResourceProvisioningStateSucceeded ResourceProvisioningState = "Succeeded"
)

func PossibleResourceProvisioningStateValues 

func PossibleResourceProvisioningStateValues() []ResourceProvisioningState

PossibleResourceProvisioningStateValues returns the possible values for the ResourceProvisioningState const type.

type ServiceInitializationHandle 

type ServiceInitializationHandle struct {
	// Azure resource ID of the AVS SDDC the pool is connecting to
	ClusterResourceID *string

	// Requested service account username
	ServiceAccountUsername *string
}

ServiceInitializationHandle - Initialization handle used to configure the AVS SDDC to communicate with the storage pool

func (ServiceInitializationHandle) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ServiceInitializationHandle.

func (*ServiceInitializationHandle) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ServiceInitializationHandle.

type ServiceInitializationInfo 

type ServiceInitializationInfo struct {
	// Service account password
	ServiceAccountPassword *string

	// Service account username
	ServiceAccountUsername *string

	// AVS instance's vSphere certificate
	VSphereCertificate *string

	// AVS instance's vSphere IP address
	VSphereIP *string
}

ServiceInitializationInfo - Explicit service initialization data

func (ServiceInitializationInfo) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ServiceInitializationInfo.

func (*ServiceInitializationInfo) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ServiceInitializationInfo.

type SoftDeletion 

type SoftDeletion struct {
	// REQUIRED; If false, the resource is active; if true, the resource has been destroyed; resources can be soft-deleted by
	// setting destroyed to true, and recovered by setting it to false
	Destroyed *bool

	// READ-ONLY; Date at which the resource will be eradicated and impossible to recover, as an RFC 3339 timestamp; invalid if
	// destroyed is false;
	EradicationTimestamp *string
}

SoftDeletion - Soft-deletion state

func (SoftDeletion) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type SoftDeletion.

func (*SoftDeletion) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SoftDeletion.

type Space 

type Space struct {
	// REQUIRED; Space occupied by duplicated data, meaning data shared with other volumes and snapshots as a result of data deduplication,
	// in bytes
	Shared *int64

	// REQUIRED; Space occupied by data unique to one or more snapshots, in bytes
	Snapshots *int64

	// REQUIRED; Total space occupied by customer data (i.e., being billed for), in bytes
	TotalUsed *int64

	// REQUIRED; Unique space occupied by customer data, in bytes; for a volume, this is the amount of storage that would be freed
	// by deleting the volume, since snapshot and shared data would be kept
	Unique *int64
}

Space - Storage space usage

func (Space) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type Space.

func (*Space) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type Space.

type StoragePool 

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

	// READ-ONLY; Name of the storage pool
	Name *string

	// The managed service identities assigned to this resource.
	Identity *ManagedServiceIdentity

	// The resource-specific properties for this resource.
	Properties *StoragePoolProperties

	// 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 Manager metadata containing createdBy and modifiedBy information.
	SystemData *SystemData

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

StoragePool - Storage pool resource

func (StoragePool) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type StoragePool.

func (*StoragePool) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type StoragePool.

type StoragePoolEnableAvsConnectionPost 

type StoragePoolEnableAvsConnectionPost struct {
	// REQUIRED; Azure resource ID of the AVS SDDC to connect to
	ClusterResourceID *string
}

StoragePoolEnableAvsConnectionPost - EnableAvsConnection payload information

func (StoragePoolEnableAvsConnectionPost) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type StoragePoolEnableAvsConnectionPost.

func (*StoragePoolEnableAvsConnectionPost) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type StoragePoolEnableAvsConnectionPost.

type StoragePoolFinalizeAvsConnectionPost 

type StoragePoolFinalizeAvsConnectionPost struct {
	// Explicit AVS connection information
	ServiceInitializationData *ServiceInitializationInfo

	// Encoded AVS connection information
	ServiceInitializationDataEnc *string
}

StoragePoolFinalizeAvsConnectionPost - FinalizeAvsConnection payload information, either encoded or explicit

func (StoragePoolFinalizeAvsConnectionPost) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type StoragePoolFinalizeAvsConnectionPost.

func (*StoragePoolFinalizeAvsConnectionPost) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type StoragePoolFinalizeAvsConnectionPost.

type StoragePoolHealthInfo 

type StoragePoolHealthInfo struct {
	// REQUIRED; List of health alerts
	Alerts []*Alert

	// REQUIRED; Health metrics
	Health *HealthDetails
}

StoragePoolHealthInfo - Health information for a storage pool

func (StoragePoolHealthInfo) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type StoragePoolHealthInfo.

func (*StoragePoolHealthInfo) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type StoragePoolHealthInfo.

type StoragePoolLimits 

type StoragePoolLimits struct {
	// REQUIRED; List of physical availability zones in the region in which storage pools can be deployed; some Azure regions
	// do not support the necessary resources in all availability zones
	PhysicalAvailabilityZones []*string

	// REQUIRED; Allowed provisioned bandwidth range for a storage pool, in MB/s
	ProvisionedBandwidthMbPerSec *RangeLimits

	// REQUIRED; Allowed provisioned IOPS range for a storage pool, as a number of operations
	ProvisionedIops *RangeLimits
}

StoragePoolLimits - Limits used for storage pool creation

func (StoragePoolLimits) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type StoragePoolLimits.

func (*StoragePoolLimits) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type StoragePoolLimits.

type StoragePoolListResult 

type StoragePoolListResult struct {
	// REQUIRED; The StoragePool items on this page
	Value []*StoragePool

	// The link to the next page of items
	NextLink *string
}

StoragePoolListResult - The response of a StoragePool list operation.

func (StoragePoolListResult) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type StoragePoolListResult.

func (*StoragePoolListResult) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type StoragePoolListResult.

type StoragePoolProperties 

type StoragePoolProperties struct {
	// REQUIRED; Azure Availability Zone the Pool is located in
	AvailabilityZone *string

	// REQUIRED; Total bandwidth provisioned for the pool, in MB/s
	ProvisionedBandwidthMbPerSec *int64

	// REQUIRED; Azure resource ID of the Pure Storage Cloud service (reservation resource) this storage pool belongs to
	ReservationResourceID *string

	// REQUIRED; Network properties of the storage pool
	VnetInjection *VnetInjection

	// READ-ONLY; AVS connection state summary
	Avs *AzureVmwareService

	// READ-ONLY; How long a destroyed object is kept before being eradicated, in seconds
	DataRetentionPeriod *int64

	// READ-ONLY; Total I/O operations per second (IOPS) provisioned for the pool
	ProvisionedIops *int64

	// READ-ONLY; Provisioning state of the resource
	ProvisioningState *ProvisioningState

	// READ-ONLY; Pure Storage's internal ID of the storage pool
	StoragePoolInternalID *string
}

StoragePoolProperties - Properties of a storage pool

func (StoragePoolProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type StoragePoolProperties.

func (*StoragePoolProperties) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type StoragePoolProperties.

type StoragePoolUpdate 

type StoragePoolUpdate struct {
	// The managed service identities assigned to this resource.
	Identity *ManagedServiceIdentity

	// The resource-specific properties for this resource.
	Properties *StoragePoolUpdateProperties

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

StoragePoolUpdate - The type used for update operations of the StoragePool.

func (StoragePoolUpdate) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type StoragePoolUpdate.

func (*StoragePoolUpdate) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type StoragePoolUpdate.

type StoragePoolUpdateProperties 

type StoragePoolUpdateProperties struct {
	// Total bandwidth provisioned for the pool, in MB/s
	ProvisionedBandwidthMbPerSec *int64
}

StoragePoolUpdateProperties - The updatable properties of the StoragePool.

func (StoragePoolUpdateProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type StoragePoolUpdateProperties.

func (*StoragePoolUpdateProperties) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type StoragePoolUpdateProperties.

type StoragePoolsClient 

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

StoragePoolsClient contains the methods for the StoragePools group. Don't use this type directly, use NewStoragePoolsClient() instead.

func NewStoragePoolsClient 

func NewStoragePoolsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*StoragePoolsClient, error)

NewStoragePoolsClient creates a new instance of StoragePoolsClient with the specified values.

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

func (*StoragePoolsClient) BeginCreate 

func (client *StoragePoolsClient) BeginCreate(ctx context.Context, resourceGroupName string, storagePoolName string, resource StoragePool, options *StoragePoolsClientBeginCreateOptions) (*runtime.Poller[StoragePoolsClientCreateResponse], error)

BeginCreate - Create a storage pool If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • storagePoolName - Name of the storage pool
  • resource - Resource create parameters.
  • options - StoragePoolsClientBeginCreateOptions contains the optional parameters for the StoragePoolsClient.BeginCreate method.
Example

Generated from example definition: 2024-11-01/StoragePools_Create_MaximumSet_Gen.json 

package main

import (
	"context"
	"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/purestorageblock/armpurestorageblock"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armpurestorageblock.NewClientFactory("BC47D6CC-AA80-4374-86F8-19D94EC70666", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewStoragePoolsClient().BeginCreate(ctx, "rgpurestorage", "storagePoolname", armpurestorageblock.StoragePool{
		Properties: &armpurestorageblock.StoragePoolProperties{
			AvailabilityZone: to.Ptr("vknyl"),
			VnetInjection: &armpurestorageblock.VnetInjection{
				SubnetID: to.Ptr("tnlctolrxdvnkjiphlrdxq"),
				VnetID:   to.Ptr("zbumtytyqwewjcyckwqchiypshv"),
			},
			ProvisionedBandwidthMbPerSec: to.Ptr[int64](17),
			Avs: &armpurestorageblock.AzureVmwareService{
				AvsEnabled:        to.Ptr(true),
				ClusterResourceID: to.Ptr("zekrdsarbkwcbvpzhmuwoazogziwms"),
			},
			ReservationResourceID: to.Ptr("xiowoxnbtcotutcmmrofvgdi"),
		},
		Identity: &armpurestorageblock.ManagedServiceIdentity{
			Type: to.Ptr(armpurestorageblock.ManagedServiceIdentityTypeNone),
			UserAssignedIdentities: map[string]*armpurestorageblock.UserAssignedIdentity{
				"key4211": {},
			},
		},
		Tags: map[string]*string{
			"key7593": to.Ptr("vsyiygyurvwlfaezpuqu"),
		},
		Location: to.Ptr("lonlc"),
	}, 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 = armpurestorageblock.StoragePoolsClientCreateResponse{
	// 	StoragePool: &armpurestorageblock.StoragePool{
	// 		Properties: &armpurestorageblock.StoragePoolProperties{
	// 			StoragePoolInternalID: to.Ptr("zcvzukcmphctpzrebsgtcr"),
	// 			AvailabilityZone: to.Ptr("vknyl"),
	// 			VnetInjection: &armpurestorageblock.VnetInjection{
	// 				SubnetID: to.Ptr("tnlctolrxdvnkjiphlrdxq"),
	// 				VnetID: to.Ptr("zbumtytyqwewjcyckwqchiypshv"),
	// 			},
	// 			DataRetentionPeriod: to.Ptr[int64](23),
	// 			ProvisionedBandwidthMbPerSec: to.Ptr[int64](17),
	// 			ProvisionedIops: to.Ptr[int64](3),
	// 			Avs: &armpurestorageblock.AzureVmwareService{
	// 				AvsEnabled: to.Ptr(true),
	// 				ClusterResourceID: to.Ptr("zekrdsarbkwcbvpzhmuwoazogziwms"),
	// 			},
	// 			ProvisioningState: to.Ptr(armpurestorageblock.ProvisioningStateSucceeded),
	// 			ReservationResourceID: to.Ptr("xiowoxnbtcotutcmmrofvgdi"),
	// 		},
	// 		Identity: &armpurestorageblock.ManagedServiceIdentity{
	// 			PrincipalID: to.Ptr("550e8400-e29b-41d4-a716-446655440000"),
	// 			TenantID: to.Ptr("550e8400-e29b-41d4-a716-446655440000"),
	// 			Type: to.Ptr(armpurestorageblock.ManagedServiceIdentityTypeNone),
	// 			UserAssignedIdentities: map[string]*armpurestorageblock.UserAssignedIdentity{
	// 				"key4211": &armpurestorageblock.UserAssignedIdentity{
	// 					PrincipalID: to.Ptr("550e8400-e29b-41d4-a716-446655440000"),
	// 					ClientID: to.Ptr("550e8400-e29b-41d4-a716-446655440000"),
	// 				},
	// 			},
	// 		},
	// 		Tags: map[string]*string{
	// 			"key7593": to.Ptr("vsyiygyurvwlfaezpuqu"),
	// 		},
	// 		Location: to.Ptr("lonlc"),
	// 		ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}"),
	// 		Name: to.Ptr("imnjvmnlsmalufopyw"),
	// 		Type: to.Ptr("hjztnpxxisrllusazxy"),
	// 		SystemData: &armpurestorageblock.SystemData{
	// 			CreatedBy: to.Ptr("ruoitchmuomrbscg"),
	// 			CreatedByType: to.Ptr(armpurestorageblock.CreatedByTypeUser),
	// 			CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-10-04T05:29:25.341Z"); return t}()),
	// 			LastModifiedBy: to.Ptr("thfyhokbrldzmghuylqbwpbublj"),
	// 			LastModifiedByType: to.Ptr(armpurestorageblock.CreatedByTypeUser),
	// 			LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-10-04T05:29:25.345Z"); return t}()),
	// 		},
	// 	},
	// }
}

func (*StoragePoolsClient) BeginDelete 

func (client *StoragePoolsClient) BeginDelete(ctx context.Context, resourceGroupName string, storagePoolName string, options *StoragePoolsClientBeginDeleteOptions) (*runtime.Poller[StoragePoolsClientDeleteResponse], error)

BeginDelete - Delete a storage pool If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • storagePoolName - Name of the storage pool
  • options - StoragePoolsClientBeginDeleteOptions contains the optional parameters for the StoragePoolsClient.BeginDelete method.
Example

Generated from example definition: 2024-11-01/StoragePools_Delete_MaximumSet_Gen.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/purestorageblock/armpurestorageblock"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armpurestorageblock.NewClientFactory("BC47D6CC-AA80-4374-86F8-19D94EC70666", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewStoragePoolsClient().BeginDelete(ctx, "rgpurestorage", "storagePoolname", 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)
	}
}

func (*StoragePoolsClient) BeginDisableAvsConnection 

func (client *StoragePoolsClient) BeginDisableAvsConnection(ctx context.Context, resourceGroupName string, storagePoolName string, options *StoragePoolsClientBeginDisableAvsConnectionOptions) (*runtime.Poller[StoragePoolsClientDisableAvsConnectionResponse], error)

BeginDisableAvsConnection - Disable the existing AVS connection If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • storagePoolName - Name of the storage pool
  • options - StoragePoolsClientBeginDisableAvsConnectionOptions contains the optional parameters for the StoragePoolsClient.BeginDisableAvsConnection method.
Example

Generated from example definition: 2024-11-01/StoragePools_DisableAvsConnection_MaximumSet_Gen.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/purestorageblock/armpurestorageblock"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armpurestorageblock.NewClientFactory("BC47D6CC-AA80-4374-86F8-19D94EC70666", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewStoragePoolsClient().BeginDisableAvsConnection(ctx, "rgpurestorage", "storagePoolname", 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)
	}
}

func (*StoragePoolsClient) BeginEnableAvsConnection 

func (client *StoragePoolsClient) BeginEnableAvsConnection(ctx context.Context, resourceGroupName string, storagePoolName string, properties StoragePoolEnableAvsConnectionPost, options *StoragePoolsClientBeginEnableAvsConnectionOptions) (*runtime.Poller[StoragePoolsClientEnableAvsConnectionResponse], error)

BeginEnableAvsConnection - Initiate a connection between the storage pool and a specified AVS SDDC resource If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • storagePoolName - Name of the storage pool
  • properties - Storage pool EnableAvsConnection properties
  • options - StoragePoolsClientBeginEnableAvsConnectionOptions contains the optional parameters for the StoragePoolsClient.BeginEnableAvsConnection method.
Example

Generated from example definition: 2024-11-01/StoragePools_EnableAvsConnection_MaximumSet_Gen.json 

package main

import (
	"context"
	"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/purestorageblock/armpurestorageblock"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armpurestorageblock.NewClientFactory("BC47D6CC-AA80-4374-86F8-19D94EC70666", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewStoragePoolsClient().BeginEnableAvsConnection(ctx, "rgpurestorage", "storagePoolname", armpurestorageblock.StoragePoolEnableAvsConnectionPost{
		ClusterResourceID: to.Ptr("tghkgktlddwlszbeh"),
	}, 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)
	}
}

func (*StoragePoolsClient) BeginFinalizeAvsConnection 

func (client *StoragePoolsClient) BeginFinalizeAvsConnection(ctx context.Context, resourceGroupName string, storagePoolName string, properties StoragePoolFinalizeAvsConnectionPost, options *StoragePoolsClientBeginFinalizeAvsConnectionOptions) (*runtime.Poller[StoragePoolsClientFinalizeAvsConnectionResponse], error)

BeginFinalizeAvsConnection - Finalize an already started AVS connection to a specific AVS SDDC If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • storagePoolName - Name of the storage pool
  • properties - Storage pool FinalizeAvsConnection properties
  • options - StoragePoolsClientBeginFinalizeAvsConnectionOptions contains the optional parameters for the StoragePoolsClient.BeginFinalizeAvsConnection method.
Example

Generated from example definition: 2024-11-01/StoragePools_FinalizeAvsConnection_MaximumSet_Gen.json 

package main

import (
	"context"
	"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/purestorageblock/armpurestorageblock"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armpurestorageblock.NewClientFactory("BC47D6CC-AA80-4374-86F8-19D94EC70666", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewStoragePoolsClient().BeginFinalizeAvsConnection(ctx, "rgpurestorage", "storagePoolname", armpurestorageblock.StoragePoolFinalizeAvsConnectionPost{
		ServiceInitializationDataEnc: to.Ptr("hlgzaxrohv"),
		ServiceInitializationData: &armpurestorageblock.ServiceInitializationInfo{
			ServiceAccountUsername: to.Ptr("axchgm"),
			ServiceAccountPassword: to.Ptr("i"),
			VSphereIP:              to.Ptr("lhbajnykbznxnxpxozyfdjaciennks"),
			VSphereCertificate:     to.Ptr("s"),
		},
	}, 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)
	}
}

func (*StoragePoolsClient) BeginRepairAvsConnection 

func (client *StoragePoolsClient) BeginRepairAvsConnection(ctx context.Context, resourceGroupName string, storagePoolName string, options *StoragePoolsClientBeginRepairAvsConnectionOptions) (*runtime.Poller[StoragePoolsClientRepairAvsConnectionResponse], error)

BeginRepairAvsConnection - Test and repair, if needed, all configuration elements of the storage pool connection to the AVS instance If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • storagePoolName - Name of the storage pool
  • options - StoragePoolsClientBeginRepairAvsConnectionOptions contains the optional parameters for the StoragePoolsClient.BeginRepairAvsConnection method.
Example

Generated from example definition: 2024-11-01/StoragePools_RepairAvsConnection_MaximumSet_Gen.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/purestorageblock/armpurestorageblock"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armpurestorageblock.NewClientFactory("BC47D6CC-AA80-4374-86F8-19D94EC70666", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewStoragePoolsClient().BeginRepairAvsConnection(ctx, "rgpurestorage", "storagePoolname", 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)
	}
}

func (*StoragePoolsClient) BeginUpdate 

func (client *StoragePoolsClient) BeginUpdate(ctx context.Context, resourceGroupName string, storagePoolName string, properties StoragePoolUpdate, options *StoragePoolsClientBeginUpdateOptions) (*runtime.Poller[StoragePoolsClientUpdateResponse], error)

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

Generated from API version 2024-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • storagePoolName - Name of the storage pool
  • properties - The resource properties to be updated.
  • options - StoragePoolsClientBeginUpdateOptions contains the optional parameters for the StoragePoolsClient.BeginUpdate method.
Example

Generated from example definition: 2024-11-01/StoragePools_Update_MaximumSet_Gen.json 

package main

import (
	"context"
	"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/purestorageblock/armpurestorageblock"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armpurestorageblock.NewClientFactory("BC47D6CC-AA80-4374-86F8-19D94EC70666", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewStoragePoolsClient().BeginUpdate(ctx, "rgpurestorage", "storagePoolname", armpurestorageblock.StoragePoolUpdate{
		Identity: &armpurestorageblock.ManagedServiceIdentity{
			Type: to.Ptr(armpurestorageblock.ManagedServiceIdentityTypeNone),
			UserAssignedIdentities: map[string]*armpurestorageblock.UserAssignedIdentity{
				"key4211": {},
			},
		},
		Tags: map[string]*string{
			"key9065": to.Ptr("ebgmkwxqewe"),
		},
		Properties: &armpurestorageblock.StoragePoolUpdateProperties{
			ProvisionedBandwidthMbPerSec: to.Ptr[int64](23),
		},
	}, 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 = armpurestorageblock.StoragePoolsClientUpdateResponse{
	// 	StoragePool: &armpurestorageblock.StoragePool{
	// 		Properties: &armpurestorageblock.StoragePoolProperties{
	// 			StoragePoolInternalID: to.Ptr("zcvzukcmphctpzrebsgtcr"),
	// 			AvailabilityZone: to.Ptr("vknyl"),
	// 			VnetInjection: &armpurestorageblock.VnetInjection{
	// 				SubnetID: to.Ptr("tnlctolrxdvnkjiphlrdxq"),
	// 				VnetID: to.Ptr("zbumtytyqwewjcyckwqchiypshv"),
	// 			},
	// 			DataRetentionPeriod: to.Ptr[int64](23),
	// 			ProvisionedBandwidthMbPerSec: to.Ptr[int64](17),
	// 			ProvisionedIops: to.Ptr[int64](3),
	// 			Avs: &armpurestorageblock.AzureVmwareService{
	// 				AvsEnabled: to.Ptr(true),
	// 				ClusterResourceID: to.Ptr("zekrdsarbkwcbvpzhmuwoazogziwms"),
	// 			},
	// 			ProvisioningState: to.Ptr(armpurestorageblock.ProvisioningStateSucceeded),
	// 			ReservationResourceID: to.Ptr("xiowoxnbtcotutcmmrofvgdi"),
	// 		},
	// 		Identity: &armpurestorageblock.ManagedServiceIdentity{
	// 			PrincipalID: to.Ptr("550e8400-e29b-41d4-a716-446655440000"),
	// 			TenantID: to.Ptr("550e8400-e29b-41d4-a716-446655440000"),
	// 			Type: to.Ptr(armpurestorageblock.ManagedServiceIdentityTypeNone),
	// 			UserAssignedIdentities: map[string]*armpurestorageblock.UserAssignedIdentity{
	// 				"key4211": &armpurestorageblock.UserAssignedIdentity{
	// 					PrincipalID: to.Ptr("550e8400-e29b-41d4-a716-446655440000"),
	// 					ClientID: to.Ptr("550e8400-e29b-41d4-a716-446655440000"),
	// 				},
	// 			},
	// 		},
	// 		Tags: map[string]*string{
	// 			"key7593": to.Ptr("vsyiygyurvwlfaezpuqu"),
	// 		},
	// 		Location: to.Ptr("lonlc"),
	// 		ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}"),
	// 		Name: to.Ptr("imnjvmnlsmalufopyw"),
	// 		Type: to.Ptr("hjztnpxxisrllusazxy"),
	// 		SystemData: &armpurestorageblock.SystemData{
	// 			CreatedBy: to.Ptr("ruoitchmuomrbscg"),
	// 			CreatedByType: to.Ptr(armpurestorageblock.CreatedByTypeUser),
	// 			CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-10-04T05:29:25.341Z"); return t}()),
	// 			LastModifiedBy: to.Ptr("thfyhokbrldzmghuylqbwpbublj"),
	// 			LastModifiedByType: to.Ptr(armpurestorageblock.CreatedByTypeUser),
	// 			LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-10-04T05:29:25.345Z"); return t}()),
	// 		},
	// 	},
	// }
}

func (*StoragePoolsClient) Get 

func (client *StoragePoolsClient) Get(ctx context.Context, resourceGroupName string, storagePoolName string, options *StoragePoolsClientGetOptions) (StoragePoolsClientGetResponse, error)

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

Generated from API version 2024-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • storagePoolName - Name of the storage pool
  • options - StoragePoolsClientGetOptions contains the optional parameters for the StoragePoolsClient.Get method.
Example

Generated from example definition: 2024-11-01/StoragePools_Get_MaximumSet_Gen.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/purestorageblock/armpurestorageblock"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armpurestorageblock.NewClientFactory("BC47D6CC-AA80-4374-86F8-19D94EC70666", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewStoragePoolsClient().Get(ctx, "rgpurestorage", "storagePoolname", 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 = armpurestorageblock.StoragePoolsClientGetResponse{
	// 	StoragePool: &armpurestorageblock.StoragePool{
	// 		Properties: &armpurestorageblock.StoragePoolProperties{
	// 			StoragePoolInternalID: to.Ptr("zcvzukcmphctpzrebsgtcr"),
	// 			AvailabilityZone: to.Ptr("vknyl"),
	// 			VnetInjection: &armpurestorageblock.VnetInjection{
	// 				SubnetID: to.Ptr("tnlctolrxdvnkjiphlrdxq"),
	// 				VnetID: to.Ptr("zbumtytyqwewjcyckwqchiypshv"),
	// 			},
	// 			DataRetentionPeriod: to.Ptr[int64](23),
	// 			ProvisionedBandwidthMbPerSec: to.Ptr[int64](17),
	// 			ProvisionedIops: to.Ptr[int64](3),
	// 			Avs: &armpurestorageblock.AzureVmwareService{
	// 				AvsEnabled: to.Ptr(true),
	// 				ClusterResourceID: to.Ptr("zekrdsarbkwcbvpzhmuwoazogziwms"),
	// 			},
	// 			ProvisioningState: to.Ptr(armpurestorageblock.ProvisioningStateSucceeded),
	// 			ReservationResourceID: to.Ptr("xiowoxnbtcotutcmmrofvgdi"),
	// 		},
	// 		Identity: &armpurestorageblock.ManagedServiceIdentity{
	// 			PrincipalID: to.Ptr("550e8400-e29b-41d4-a716-446655440000"),
	// 			TenantID: to.Ptr("550e8400-e29b-41d4-a716-446655440000"),
	// 			Type: to.Ptr(armpurestorageblock.ManagedServiceIdentityTypeNone),
	// 			UserAssignedIdentities: map[string]*armpurestorageblock.UserAssignedIdentity{
	// 				"key4211": &armpurestorageblock.UserAssignedIdentity{
	// 					PrincipalID: to.Ptr("550e8400-e29b-41d4-a716-446655440000"),
	// 					ClientID: to.Ptr("550e8400-e29b-41d4-a716-446655440000"),
	// 				},
	// 			},
	// 		},
	// 		Tags: map[string]*string{
	// 			"key7593": to.Ptr("vsyiygyurvwlfaezpuqu"),
	// 		},
	// 		Location: to.Ptr("lonlc"),
	// 		ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}"),
	// 		Name: to.Ptr("imnjvmnlsmalufopyw"),
	// 		Type: to.Ptr("hjztnpxxisrllusazxy"),
	// 		SystemData: &armpurestorageblock.SystemData{
	// 			CreatedBy: to.Ptr("ruoitchmuomrbscg"),
	// 			CreatedByType: to.Ptr(armpurestorageblock.CreatedByTypeUser),
	// 			CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-10-04T05:29:25.341Z"); return t}()),
	// 			LastModifiedBy: to.Ptr("thfyhokbrldzmghuylqbwpbublj"),
	// 			LastModifiedByType: to.Ptr(armpurestorageblock.CreatedByTypeUser),
	// 			LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-10-04T05:29:25.345Z"); return t}()),
	// 		},
	// 	},
	// }
}

func (*StoragePoolsClient) GetAvsConnection 

func (client *StoragePoolsClient) GetAvsConnection(ctx context.Context, resourceGroupName string, storagePoolName string, options *StoragePoolsClientGetAvsConnectionOptions) (StoragePoolsClientGetAvsConnectionResponse, error)

GetAvsConnection - Returns current information about an on-going connection to an AVS instance If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • storagePoolName - Name of the storage pool
  • options - StoragePoolsClientGetAvsConnectionOptions contains the optional parameters for the StoragePoolsClient.GetAvsConnection method.
Example

Generated from example definition: 2024-11-01/StoragePools_GetAvsConnection_MaximumSet_Gen.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/purestorageblock/armpurestorageblock"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armpurestorageblock.NewClientFactory("BC47D6CC-AA80-4374-86F8-19D94EC70666", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewStoragePoolsClient().GetAvsConnection(ctx, "rgpurestorage", "storagePoolname", 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 = armpurestorageblock.StoragePoolsClientGetAvsConnectionResponse{
	// 	AvsConnection: &armpurestorageblock.AvsConnection{
	// 		ServiceInitializationCompleted: to.Ptr(true),
	// 		ServiceInitializationHandleEnc: to.Ptr("kvidtocmjciflvtwql"),
	// 		ServiceInitializationHandle: &armpurestorageblock.ServiceInitializationHandle{
	// 			ClusterResourceID: to.Ptr("aqgnpie"),
	// 			ServiceAccountUsername: to.Ptr("xcu"),
	// 		},
	// 	},
	// }
}

func (*StoragePoolsClient) GetAvsStatus 

func (client *StoragePoolsClient) GetAvsStatus(ctx context.Context, resourceGroupName string, storagePoolName string, options *StoragePoolsClientGetAvsStatusOptions) (StoragePoolsClientGetAvsStatusResponse, error)

GetAvsStatus - Returns the status of the storage pool connection to AVS If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • storagePoolName - Name of the storage pool
  • options - StoragePoolsClientGetAvsStatusOptions contains the optional parameters for the StoragePoolsClient.GetAvsStatus method.
Example

Generated from example definition: 2024-11-01/StoragePools_GetAvsStatus_MaximumSet_Gen.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/purestorageblock/armpurestorageblock"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armpurestorageblock.NewClientFactory("BC47D6CC-AA80-4374-86F8-19D94EC70666", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewStoragePoolsClient().GetAvsStatus(ctx, "rgpurestorage", "storagePoolname", 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 = armpurestorageblock.StoragePoolsClientGetAvsStatusResponse{
	// 	AvsStatus: &armpurestorageblock.AvsStatus{
	// 		AvsEnabled: to.Ptr(true),
	// 		CurrentConnectionStatus: to.Ptr("vfirgp"),
	// 		ClusterResourceID: to.Ptr("zxkvzrdjzwpk"),
	// 	},
	// }
}

func (*StoragePoolsClient) GetHealthStatus 

func (client *StoragePoolsClient) GetHealthStatus(ctx context.Context, resourceGroupName string, storagePoolName string, options *StoragePoolsClientGetHealthStatusOptions) (StoragePoolsClientGetHealthStatusResponse, error)

GetHealthStatus - Retrieve health metrics of a storage pool If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • storagePoolName - Name of the storage pool
  • options - StoragePoolsClientGetHealthStatusOptions contains the optional parameters for the StoragePoolsClient.GetHealthStatus method.
Example

Generated from example definition: 2024-11-01/StoragePools_GetHealthStatus_MaximumSet_Gen.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/purestorageblock/armpurestorageblock"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armpurestorageblock.NewClientFactory("BC47D6CC-AA80-4374-86F8-19D94EC70666", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewStoragePoolsClient().GetHealthStatus(ctx, "rgpurestorage", "storagePoolname", 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 = armpurestorageblock.StoragePoolsClientGetHealthStatusResponse{
	// 	StoragePoolHealthInfo: &armpurestorageblock.StoragePoolHealthInfo{
	// 		Health: &armpurestorageblock.HealthDetails{
	// 			UsedCapacityPercentage: to.Ptr[float64](21),
	// 			BandwidthUsage: &armpurestorageblock.BandwidthUsage{
	// 				Current: to.Ptr[int64](15),
	// 				Provisioned: to.Ptr[int64](23),
	// 				Max: to.Ptr[int64](21),
	// 			},
	// 			IopsUsage: &armpurestorageblock.IopsUsage{
	// 				Current: to.Ptr[int64](5),
	// 				Provisioned: to.Ptr[int64](19),
	// 				Max: to.Ptr[int64](15),
	// 			},
	// 			Space: &armpurestorageblock.Space{
	// 				TotalUsed: to.Ptr[int64](28),
	// 				Unique: to.Ptr[int64](4),
	// 				Snapshots: to.Ptr[int64](5),
	// 				Shared: to.Ptr[int64](9),
	// 			},
	// 			DataReductionRatio: to.Ptr[float64](28),
	// 			EstimatedMaxCapacity: to.Ptr[int64](1),
	// 		},
	// 		Alerts: []*armpurestorageblock.Alert{
	// 			{
	// 				Level: to.Ptr(armpurestorageblock.AlertLevelInfo),
	// 				Message: to.Ptr("uasvakccxihgmdz"),
	// 			},
	// 		},
	// 	},
	// }
}

func (*StoragePoolsClient) NewListByResourceGroupPager 

func (client *StoragePoolsClient) NewListByResourceGroupPager(resourceGroupName string, options *StoragePoolsClientListByResourceGroupOptions) *runtime.Pager[StoragePoolsClientListByResourceGroupResponse]

NewListByResourceGroupPager - List storage pools by resource group

Generated from API version 2024-11-01

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

Generated from example definition: 2024-11-01/StoragePools_ListByResourceGroup_MaximumSet_Gen.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/purestorageblock/armpurestorageblock"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armpurestorageblock.NewClientFactory("BC47D6CC-AA80-4374-86F8-19D94EC70666", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewStoragePoolsClient().NewListByResourceGroupPager("rgpurestorage", 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 = armpurestorageblock.StoragePoolsClientListByResourceGroupResponse{
		// 	StoragePoolListResult: armpurestorageblock.StoragePoolListResult{
		// 		Value: []*armpurestorageblock.StoragePool{
		// 			{
		// 				Properties: &armpurestorageblock.StoragePoolProperties{
		// 					StoragePoolInternalID: to.Ptr("zcvzukcmphctpzrebsgtcr"),
		// 					AvailabilityZone: to.Ptr("vknyl"),
		// 					VnetInjection: &armpurestorageblock.VnetInjection{
		// 						SubnetID: to.Ptr("tnlctolrxdvnkjiphlrdxq"),
		// 						VnetID: to.Ptr("zbumtytyqwewjcyckwqchiypshv"),
		// 					},
		// 					DataRetentionPeriod: to.Ptr[int64](23),
		// 					ProvisionedBandwidthMbPerSec: to.Ptr[int64](17),
		// 					ProvisionedIops: to.Ptr[int64](3),
		// 					Avs: &armpurestorageblock.AzureVmwareService{
		// 						AvsEnabled: to.Ptr(true),
		// 						ClusterResourceID: to.Ptr("zekrdsarbkwcbvpzhmuwoazogziwms"),
		// 					},
		// 					ProvisioningState: to.Ptr(armpurestorageblock.ProvisioningStateSucceeded),
		// 					ReservationResourceID: to.Ptr("xiowoxnbtcotutcmmrofvgdi"),
		// 				},
		// 				Identity: &armpurestorageblock.ManagedServiceIdentity{
		// 					PrincipalID: to.Ptr("550e8400-e29b-41d4-a716-446655440000"),
		// 					TenantID: to.Ptr("550e8400-e29b-41d4-a716-446655440000"),
		// 					Type: to.Ptr(armpurestorageblock.ManagedServiceIdentityTypeNone),
		// 					UserAssignedIdentities: map[string]*armpurestorageblock.UserAssignedIdentity{
		// 						"key4211": &armpurestorageblock.UserAssignedIdentity{
		// 							PrincipalID: to.Ptr("550e8400-e29b-41d4-a716-446655440000"),
		// 							ClientID: to.Ptr("550e8400-e29b-41d4-a716-446655440000"),
		// 						},
		// 					},
		// 				},
		// 				Tags: map[string]*string{
		// 					"key7593": to.Ptr("vsyiygyurvwlfaezpuqu"),
		// 				},
		// 				Location: to.Ptr("lonlc"),
		// 				ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}"),
		// 				Name: to.Ptr("imnjvmnlsmalufopyw"),
		// 				Type: to.Ptr("hjztnpxxisrllusazxy"),
		// 				SystemData: &armpurestorageblock.SystemData{
		// 					CreatedBy: to.Ptr("ruoitchmuomrbscg"),
		// 					CreatedByType: to.Ptr(armpurestorageblock.CreatedByTypeUser),
		// 					CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-10-04T05:29:25.341Z"); return t}()),
		// 					LastModifiedBy: to.Ptr("thfyhokbrldzmghuylqbwpbublj"),
		// 					LastModifiedByType: to.Ptr(armpurestorageblock.CreatedByTypeUser),
		// 					LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-10-04T05:29:25.345Z"); return t}()),
		// 				},
		// 			},
		// 		},
		// 		NextLink: to.Ptr("https://microsoft.com/ahd"),
		// 	},
		// }
	}
}

func (*StoragePoolsClient) NewListBySubscriptionPager 

func (client *StoragePoolsClient) NewListBySubscriptionPager(options *StoragePoolsClientListBySubscriptionOptions) *runtime.Pager[StoragePoolsClientListBySubscriptionResponse]

NewListBySubscriptionPager - List storage pools by Azure subscription ID

Generated from API version 2024-11-01

  • options - StoragePoolsClientListBySubscriptionOptions contains the optional parameters for the StoragePoolsClient.NewListBySubscriptionPager method.
Example

Generated from example definition: 2024-11-01/StoragePools_ListBySubscription_MaximumSet_Gen.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/purestorageblock/armpurestorageblock"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armpurestorageblock.NewClientFactory("BC47D6CC-AA80-4374-86F8-19D94EC70666", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewStoragePoolsClient().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 = armpurestorageblock.StoragePoolsClientListBySubscriptionResponse{
		// 	StoragePoolListResult: armpurestorageblock.StoragePoolListResult{
		// 		Value: []*armpurestorageblock.StoragePool{
		// 			{
		// 				Properties: &armpurestorageblock.StoragePoolProperties{
		// 					StoragePoolInternalID: to.Ptr("zcvzukcmphctpzrebsgtcr"),
		// 					AvailabilityZone: to.Ptr("vknyl"),
		// 					VnetInjection: &armpurestorageblock.VnetInjection{
		// 						SubnetID: to.Ptr("tnlctolrxdvnkjiphlrdxq"),
		// 						VnetID: to.Ptr("zbumtytyqwewjcyckwqchiypshv"),
		// 					},
		// 					DataRetentionPeriod: to.Ptr[int64](23),
		// 					ProvisionedBandwidthMbPerSec: to.Ptr[int64](17),
		// 					ProvisionedIops: to.Ptr[int64](3),
		// 					Avs: &armpurestorageblock.AzureVmwareService{
		// 						AvsEnabled: to.Ptr(true),
		// 						ClusterResourceID: to.Ptr("zekrdsarbkwcbvpzhmuwoazogziwms"),
		// 					},
		// 					ProvisioningState: to.Ptr(armpurestorageblock.ProvisioningStateSucceeded),
		// 					ReservationResourceID: to.Ptr("xiowoxnbtcotutcmmrofvgdi"),
		// 				},
		// 				Identity: &armpurestorageblock.ManagedServiceIdentity{
		// 					PrincipalID: to.Ptr("550e8400-e29b-41d4-a716-446655440000"),
		// 					TenantID: to.Ptr("550e8400-e29b-41d4-a716-446655440000"),
		// 					Type: to.Ptr(armpurestorageblock.ManagedServiceIdentityTypeNone),
		// 					UserAssignedIdentities: map[string]*armpurestorageblock.UserAssignedIdentity{
		// 						"key4211": &armpurestorageblock.UserAssignedIdentity{
		// 							PrincipalID: to.Ptr("550e8400-e29b-41d4-a716-446655440000"),
		// 							ClientID: to.Ptr("550e8400-e29b-41d4-a716-446655440000"),
		// 						},
		// 					},
		// 				},
		// 				Tags: map[string]*string{
		// 					"key7593": to.Ptr("vsyiygyurvwlfaezpuqu"),
		// 				},
		// 				Location: to.Ptr("lonlc"),
		// 				ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}"),
		// 				Name: to.Ptr("imnjvmnlsmalufopyw"),
		// 				Type: to.Ptr("hjztnpxxisrllusazxy"),
		// 				SystemData: &armpurestorageblock.SystemData{
		// 					CreatedBy: to.Ptr("ruoitchmuomrbscg"),
		// 					CreatedByType: to.Ptr(armpurestorageblock.CreatedByTypeUser),
		// 					CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-10-04T05:29:25.341Z"); return t}()),
		// 					LastModifiedBy: to.Ptr("thfyhokbrldzmghuylqbwpbublj"),
		// 					LastModifiedByType: to.Ptr(armpurestorageblock.CreatedByTypeUser),
		// 					LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-10-04T05:29:25.345Z"); return t}()),
		// 				},
		// 			},
		// 		},
		// 		NextLink: to.Ptr("https://microsoft.com/ahd"),
		// 	},
		// }
	}
}

type StoragePoolsClientBeginCreateOptions 

type StoragePoolsClientBeginCreateOptions struct {
	// Resumes the long-running operation from the provided token.
	ResumeToken string
}

StoragePoolsClientBeginCreateOptions contains the optional parameters for the StoragePoolsClient.BeginCreate method.

type StoragePoolsClientBeginDeleteOptions 

type StoragePoolsClientBeginDeleteOptions struct {
	// Resumes the long-running operation from the provided token.
	ResumeToken string
}

StoragePoolsClientBeginDeleteOptions contains the optional parameters for the StoragePoolsClient.BeginDelete method.

type StoragePoolsClientBeginDisableAvsConnectionOptions 

type StoragePoolsClientBeginDisableAvsConnectionOptions struct {
	// Resumes the long-running operation from the provided token.
	ResumeToken string
}

StoragePoolsClientBeginDisableAvsConnectionOptions contains the optional parameters for the StoragePoolsClient.BeginDisableAvsConnection method.

type StoragePoolsClientBeginEnableAvsConnectionOptions 

type StoragePoolsClientBeginEnableAvsConnectionOptions struct {
	// Resumes the long-running operation from the provided token.
	ResumeToken string
}

StoragePoolsClientBeginEnableAvsConnectionOptions contains the optional parameters for the StoragePoolsClient.BeginEnableAvsConnection method.

type StoragePoolsClientBeginFinalizeAvsConnectionOptions 

type StoragePoolsClientBeginFinalizeAvsConnectionOptions struct {
	// Resumes the long-running operation from the provided token.
	ResumeToken string
}

StoragePoolsClientBeginFinalizeAvsConnectionOptions contains the optional parameters for the StoragePoolsClient.BeginFinalizeAvsConnection method.

type StoragePoolsClientBeginRepairAvsConnectionOptions 

type StoragePoolsClientBeginRepairAvsConnectionOptions struct {
	// Resumes the long-running operation from the provided token.
	ResumeToken string
}

StoragePoolsClientBeginRepairAvsConnectionOptions contains the optional parameters for the StoragePoolsClient.BeginRepairAvsConnection method.

type StoragePoolsClientBeginUpdateOptions 

type StoragePoolsClientBeginUpdateOptions struct {
	// Resumes the long-running operation from the provided token.
	ResumeToken string
}

StoragePoolsClientBeginUpdateOptions contains the optional parameters for the StoragePoolsClient.BeginUpdate method.

type StoragePoolsClientCreateResponse 

type StoragePoolsClientCreateResponse struct {
	// Storage pool resource
	StoragePool
}

StoragePoolsClientCreateResponse contains the response from method StoragePoolsClient.BeginCreate.

type StoragePoolsClientDeleteResponse 

type StoragePoolsClientDeleteResponse struct {
}

StoragePoolsClientDeleteResponse contains the response from method StoragePoolsClient.BeginDelete.

type StoragePoolsClientDisableAvsConnectionResponse 

type StoragePoolsClientDisableAvsConnectionResponse struct {
}

StoragePoolsClientDisableAvsConnectionResponse contains the response from method StoragePoolsClient.BeginDisableAvsConnection.

type StoragePoolsClientEnableAvsConnectionResponse 

type StoragePoolsClientEnableAvsConnectionResponse struct {
}

StoragePoolsClientEnableAvsConnectionResponse contains the response from method StoragePoolsClient.BeginEnableAvsConnection.

type StoragePoolsClientFinalizeAvsConnectionResponse 

type StoragePoolsClientFinalizeAvsConnectionResponse struct {
}

StoragePoolsClientFinalizeAvsConnectionResponse contains the response from method StoragePoolsClient.BeginFinalizeAvsConnection.

type StoragePoolsClientGetAvsConnectionOptions 

type StoragePoolsClientGetAvsConnectionOptions struct {
}

StoragePoolsClientGetAvsConnectionOptions contains the optional parameters for the StoragePoolsClient.GetAvsConnection method.

type StoragePoolsClientGetAvsConnectionResponse 

type StoragePoolsClientGetAvsConnectionResponse struct {
	// Transient information about an on-going connection to an AVS instance
	AvsConnection
}

StoragePoolsClientGetAvsConnectionResponse contains the response from method StoragePoolsClient.GetAvsConnection.

type StoragePoolsClientGetAvsStatusOptions 

type StoragePoolsClientGetAvsStatusOptions struct {
}

StoragePoolsClientGetAvsStatusOptions contains the optional parameters for the StoragePoolsClient.GetAvsStatus method.

type StoragePoolsClientGetAvsStatusResponse 

type StoragePoolsClientGetAvsStatusResponse struct {
	// Status of storage pool / AVS connection
	AvsStatus
}

StoragePoolsClientGetAvsStatusResponse contains the response from method StoragePoolsClient.GetAvsStatus.

type StoragePoolsClientGetHealthStatusOptions 

type StoragePoolsClientGetHealthStatusOptions struct {
}

StoragePoolsClientGetHealthStatusOptions contains the optional parameters for the StoragePoolsClient.GetHealthStatus method.

type StoragePoolsClientGetHealthStatusResponse 

type StoragePoolsClientGetHealthStatusResponse struct {
	// Health information for a storage pool
	StoragePoolHealthInfo
}

StoragePoolsClientGetHealthStatusResponse contains the response from method StoragePoolsClient.GetHealthStatus.

type StoragePoolsClientGetOptions 

type StoragePoolsClientGetOptions struct {
}

StoragePoolsClientGetOptions contains the optional parameters for the StoragePoolsClient.Get method.

type StoragePoolsClientGetResponse 

type StoragePoolsClientGetResponse struct {
	// Storage pool resource
	StoragePool
}

StoragePoolsClientGetResponse contains the response from method StoragePoolsClient.Get.

type StoragePoolsClientListByResourceGroupOptions 

type StoragePoolsClientListByResourceGroupOptions struct {
}

StoragePoolsClientListByResourceGroupOptions contains the optional parameters for the StoragePoolsClient.NewListByResourceGroupPager method.

type StoragePoolsClientListByResourceGroupResponse 

type StoragePoolsClientListByResourceGroupResponse struct {
	// The response of a StoragePool list operation.
	StoragePoolListResult
}

StoragePoolsClientListByResourceGroupResponse contains the response from method StoragePoolsClient.NewListByResourceGroupPager.

type StoragePoolsClientListBySubscriptionOptions 

type StoragePoolsClientListBySubscriptionOptions struct {
}

StoragePoolsClientListBySubscriptionOptions contains the optional parameters for the StoragePoolsClient.NewListBySubscriptionPager method.

type StoragePoolsClientListBySubscriptionResponse 

type StoragePoolsClientListBySubscriptionResponse struct {
	// The response of a StoragePool list operation.
	StoragePoolListResult
}

StoragePoolsClientListBySubscriptionResponse contains the response from method StoragePoolsClient.NewListBySubscriptionPager.

type StoragePoolsClientRepairAvsConnectionResponse 

type StoragePoolsClientRepairAvsConnectionResponse struct {
}

StoragePoolsClientRepairAvsConnectionResponse contains the response from method StoragePoolsClient.BeginRepairAvsConnection.

type StoragePoolsClientUpdateResponse 

type StoragePoolsClientUpdateResponse struct {
	// Storage pool resource
	StoragePool
}

StoragePoolsClientUpdateResponse contains the response from method StoragePoolsClient.BeginUpdate.

type SystemData 

type SystemData 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 timestamp of resource last modification (UTC)
	LastModifiedAt *time.Time

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

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

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

func (SystemData) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type SystemData.

func (*SystemData) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SystemData.

type UsageSeverity 

type UsageSeverity string

UsageSeverity - Severity levels for billing usage properties 

const (
	// UsageSeverityALERT - Indicates an alert condition
	UsageSeverityALERT UsageSeverity = "alert"
	// UsageSeverityINFORMATION - Provides informational details
	UsageSeverityINFORMATION UsageSeverity = "information"
	// UsageSeverityNONE - Indicates no severity
	UsageSeverityNONE UsageSeverity = "none"
	// UsageSeverityWARNING - Indicates a warning condition
	UsageSeverityWARNING UsageSeverity = "warning"
)

func PossibleUsageSeverityValues 

func PossibleUsageSeverityValues() []UsageSeverity

PossibleUsageSeverityValues returns the possible values for the UsageSeverity const type.

type UserAssignedIdentity 

type UserAssignedIdentity struct {
	// READ-ONLY; The client ID of the assigned identity.
	ClientID *string

	// READ-ONLY; The principal ID of the assigned identity.
	PrincipalID *string
}

UserAssignedIdentity - User assigned identity properties

func (UserAssignedIdentity) MarshalJSON 

func (u UserAssignedIdentity) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type UserAssignedIdentity.

func (*UserAssignedIdentity) UnmarshalJSON 

func (u *UserAssignedIdentity) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type UserAssignedIdentity.

type UserDetails 

type UserDetails struct {
	// REQUIRED; Email address
	EmailAddress *string

	// REQUIRED; First name
	FirstName *string

	// REQUIRED; Last name
	LastName *string

	// Company details
	CompanyDetails *CompanyDetails

	// Phone number
	PhoneNumber *string

	// Principal name
	Upn *string
}

UserDetails - User details

func (UserDetails) MarshalJSON 

func (u UserDetails) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type UserDetails.

func (*UserDetails) UnmarshalJSON 

func (u *UserDetails) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type UserDetails.

type VMType 

type VMType string

VMType - AVS VM storage types 

const (
	// VMTypeVVol - VM using vVols as underlying storage
	VMTypeVVol VMType = "vvol"
)

func PossibleVMTypeValues 

func PossibleVMTypeValues() []VMType

PossibleVMTypeValues returns the possible values for the VMType const type.

type VnetInjection 

type VnetInjection struct {
	// REQUIRED; Azure resource ID of the Virtual Network subnet where the storage pool will be connected
	SubnetID *string

	// REQUIRED; Azure resource ID of the Virtual Network in which the subnet is located
	VnetID *string
}

VnetInjection - Network in which the storage pool will be made available

func (VnetInjection) MarshalJSON 

func (v VnetInjection) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type VnetInjection.

func (*VnetInjection) UnmarshalJSON 

func (v *VnetInjection) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type VnetInjection.

type VolumeContainerType 

type VolumeContainerType string

VolumeContainerType - Specify which control plane handles the lifecycle of the volume container 

const (
	// VolumeContainerTypeAVS - AVS/VMware
	VolumeContainerTypeAVS VolumeContainerType = "avs"
)

func PossibleVolumeContainerTypeValues 

func PossibleVolumeContainerTypeValues() []VolumeContainerType

PossibleVolumeContainerTypeValues returns the possible values for the VolumeContainerType const type.

type VolumeLimits 

type VolumeLimits struct {
	// REQUIRED; Provisioned size limits for a volume, in bytes
	ProvisionedSize *RangeLimits
}

VolumeLimits - Limits used for volumes

func (VolumeLimits) MarshalJSON 

func (v VolumeLimits) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type VolumeLimits.

func (*VolumeLimits) UnmarshalJSON 

func (v *VolumeLimits) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type VolumeLimits.

type VolumeProperties 

type VolumeProperties struct {
	// REQUIRED; Volume's soft-deletion state
	SoftDeletion *SoftDeletion

	// READ-ONLY; AVS-specific volume information
	Avs *AvsDiskDetails

	// READ-ONLY; Volume creation date, as an RFC 3339 timestamp
	CreatedTimestamp *string

	// READ-ONLY; Human-readable name of the volume
	DisplayName *string

	// READ-ONLY; Currently provisioned size of the volume, in bytes
	ProvisionedSize *int64

	// READ-ONLY; Provisioning state of the resource
	ProvisioningState *ResourceProvisioningState

	// READ-ONLY; Storage space usage
	Space *Space

	// READ-ONLY; Pure Storage's internal ID for the storage pool containing the volume
	StoragePoolInternalID *string

	// READ-ONLY; Azure Resource ID of the storage pool containing this volume
	StoragePoolResourceID *string

	// READ-ONLY; Pure Storage's internal ID for the volume
	VolumeInternalID *string

	// READ-ONLY; Specify which control plane handles the lifecycle of the volume
	VolumeType *VolumeType
}

VolumeProperties - Volume properties

func (VolumeProperties) MarshalJSON 

func (v VolumeProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type VolumeProperties.

func (*VolumeProperties) UnmarshalJSON 

func (v *VolumeProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type VolumeProperties.

type VolumeType 

type VolumeType string

VolumeType - Specify which control plane handles the lifecycle of the volume 

const (
	// VolumeTypeAVS - AVS/VMware
	VolumeTypeAVS VolumeType = "avs"
)

func PossibleVolumeTypeValues 

func PossibleVolumeTypeValues() []VolumeType

PossibleVolumeTypeValues returns the possible values for the VolumeType const type.

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.