armnetapp

package module
v0.1.0 Latest Latest
Warning

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

 Go to latest Published: Dec 16, 2021 License: MIT Imports: 15 Imported by: 7

README

Azure NetApp Files Module for Go

PkgGoDev

The armnetapp module provides operations for working with Azure NetApp Files.

Source code

Getting started

Prerequisites

Install the package

This project uses Go modules for versioning and dependency management.

Install the Azure NetApp Files module:

go get github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/netapp/armnetapp

Authorization

When creating a client, you will need to provide a credential for authenticating with Azure NetApp Files. 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.

Clients

Azure NetApp Files modules consist of one or more clients. A client groups a set of related APIs, providing access to its functionality within the specified subscription. Create one or more clients to access the APIs you require using your credential.

client := armnetapp.NewBackupsClient(<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{
    Host: arm.AzureChina,
}
client := armnetapp.NewBackupsClient(<subscription ID>, cred, &options)

Provide Feedback

If you encounter bugs or have suggestions, please open an issue and assign the NetApp Files 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 AccountBackupsBeginDeleteOptions 

type AccountBackupsBeginDeleteOptions struct {
}

AccountBackupsBeginDeleteOptions contains the optional parameters for the AccountBackups.BeginDelete method.

type AccountBackupsClient 

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

AccountBackupsClient contains the methods for the AccountBackups group. Don't use this type directly, use NewAccountBackupsClient() instead.

func NewAccountBackupsClient 

func NewAccountBackupsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) *AccountBackupsClient

NewAccountBackupsClient creates a new instance of AccountBackupsClient with the specified values.

func (*AccountBackupsClient) BeginDelete 

func (client *AccountBackupsClient) BeginDelete(ctx context.Context, resourceGroupName string, accountName string, backupName string, options *AccountBackupsBeginDeleteOptions) (AccountBackupsDeletePollerResponse, error)

BeginDelete - Delete the specified Backup for a Netapp Account If the operation fails it returns a generic error.

Example

x-ms-original-file: specification/netapp/resource-manager/Microsoft.NetApp/stable/2021-08-01/examples/Backups_Account_Delete.json 

package main

import (
	"context"
	"log"

	"time"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/netapp/armnetapp"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client := armnetapp.NewAccountBackupsClient("<subscription-id>", cred, nil)
	poller, err := client.BeginDelete(ctx,
		"<resource-group-name>",
		"<account-name>",
		"<backup-name>",
		nil)
	if err != nil {
		log.Fatal(err)
	}
	_, err = poller.PollUntilDone(ctx, 30*time.Second)
	if err != nil {
		log.Fatal(err)
	}
}

Output:

func (*AccountBackupsClient) Get 

func (client *AccountBackupsClient) Get(ctx context.Context, resourceGroupName string, accountName string, backupName string, options *AccountBackupsGetOptions) (AccountBackupsGetResponse, error)

Get - Gets the specified backup for a Netapp Account If the operation fails it returns a generic error.

Example

x-ms-original-file: specification/netapp/resource-manager/Microsoft.NetApp/stable/2021-08-01/examples/Backups_Account_Get.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/netapp/armnetapp"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client := armnetapp.NewAccountBackupsClient("<subscription-id>", cred, nil)
	res, err := client.Get(ctx,
		"<resource-group-name>",
		"<account-name>",
		"<backup-name>",
		nil)
	if err != nil {
		log.Fatal(err)
	}
	log.Printf("Backup.ID: %s\n", *res.ID)
}

Output:

func (*AccountBackupsClient) List 

func (client *AccountBackupsClient) List(ctx context.Context, resourceGroupName string, accountName string, options *AccountBackupsListOptions) (AccountBackupsListResponse, error)

List - List all Backups for a Netapp Account If the operation fails it returns a generic error.

Example

x-ms-original-file: specification/netapp/resource-manager/Microsoft.NetApp/stable/2021-08-01/examples/Backups_Account_List.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/netapp/armnetapp"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client := armnetapp.NewAccountBackupsClient("<subscription-id>", cred, nil)
	_, err = client.List(ctx,
		"<resource-group-name>",
		"<account-name>",
		nil)
	if err != nil {
		log.Fatal(err)
	}
}

Output:

type AccountBackupsDeletePoller 

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

AccountBackupsDeletePoller provides polling facilities until the operation reaches a terminal state.

func (*AccountBackupsDeletePoller) Done 

func (p *AccountBackupsDeletePoller) Done() bool

Done returns true if the LRO has reached a terminal state.

func (*AccountBackupsDeletePoller) FinalResponse 

func (p *AccountBackupsDeletePoller) FinalResponse(ctx context.Context) (AccountBackupsDeleteResponse, error)

FinalResponse performs a final GET to the service and returns the final response for the polling operation. If there is an error performing the final GET then an error is returned. If the final GET succeeded then the final AccountBackupsDeleteResponse will be returned.

func (*AccountBackupsDeletePoller) Poll 

func (p *AccountBackupsDeletePoller) Poll(ctx context.Context) (*http.Response, error)

Poll fetches the latest state of the LRO. It returns an HTTP response or error. If the LRO has completed successfully, the poller's state is updated and the HTTP response is returned. If the LRO has completed with failure or was cancelled, the poller's state is updated and the error is returned. If the LRO has not reached a terminal state, the poller's state is updated and the latest HTTP response is returned. If Poll fails, the poller's state is unmodified and the error is returned. Calling Poll on an LRO that has reached a terminal state will return the final HTTP response or error.

func (*AccountBackupsDeletePoller) ResumeToken 

func (p *AccountBackupsDeletePoller) ResumeToken() (string, error)

ResumeToken returns a value representing the poller that can be used to resume the LRO at a later time. ResumeTokens are unique per service operation.

type AccountBackupsDeletePollerResponse 

type AccountBackupsDeletePollerResponse struct {
	// Poller contains an initialized poller.
	Poller *AccountBackupsDeletePoller

	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

AccountBackupsDeletePollerResponse contains the response from method AccountBackups.Delete.

func (AccountBackupsDeletePollerResponse) PollUntilDone 

func (l AccountBackupsDeletePollerResponse) PollUntilDone(ctx context.Context, freq time.Duration) (AccountBackupsDeleteResponse, error)

PollUntilDone will poll the service endpoint until a terminal state is reached or an error is received. freq: the time to wait between intervals in absence of a Retry-After header. Allowed minimum is one second. A good starting value is 30 seconds. Note that some resources might benefit from a different value.

func (*AccountBackupsDeletePollerResponse) Resume 

func (l *AccountBackupsDeletePollerResponse) Resume(ctx context.Context, client *AccountBackupsClient, token string) error

Resume rehydrates a AccountBackupsDeletePollerResponse from the provided client and resume token.

type AccountBackupsDeleteResponse 

type AccountBackupsDeleteResponse struct {
	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

AccountBackupsDeleteResponse contains the response from method AccountBackups.Delete.

type AccountBackupsGetOptions 

type AccountBackupsGetOptions struct {
}

AccountBackupsGetOptions contains the optional parameters for the AccountBackups.Get method.

type AccountBackupsGetResponse 

type AccountBackupsGetResponse struct {
	AccountBackupsGetResult
	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

AccountBackupsGetResponse contains the response from method AccountBackups.Get.

type AccountBackupsGetResult 

type AccountBackupsGetResult struct {
	Backup
}

AccountBackupsGetResult contains the result from method AccountBackups.Get.

type AccountBackupsListOptions 

type AccountBackupsListOptions struct {
}

AccountBackupsListOptions contains the optional parameters for the AccountBackups.List method.

type AccountBackupsListResponse 

type AccountBackupsListResponse struct {
	AccountBackupsListResult
	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

AccountBackupsListResponse contains the response from method AccountBackups.List.

type AccountBackupsListResult 

type AccountBackupsListResult struct {
	BackupsList
}

AccountBackupsListResult contains the result from method AccountBackups.List.

type AccountEncryption 

type AccountEncryption struct {
	// Encryption Key Source. Possible values are: 'Microsoft.NetApp'.
	KeySource *string `json:"keySource,omitempty"`
}

AccountEncryption - Encryption settings

type AccountProperties 

type AccountProperties struct {
	// Active Directories
	ActiveDirectories []*ActiveDirectory `json:"activeDirectories,omitempty"`

	// Encryption settings
	Encryption *AccountEncryption `json:"encryption,omitempty"`

	// READ-ONLY; Azure lifecycle management
	ProvisioningState *string `json:"provisioningState,omitempty" azure:"ro"`
}

AccountProperties - NetApp account properties

func (AccountProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type AccountProperties.

type AccountsBeginCreateOrUpdateOptions 

type AccountsBeginCreateOrUpdateOptions struct {
}

AccountsBeginCreateOrUpdateOptions contains the optional parameters for the Accounts.BeginCreateOrUpdate method.

type AccountsBeginDeleteOptions 

type AccountsBeginDeleteOptions struct {
}

AccountsBeginDeleteOptions contains the optional parameters for the Accounts.BeginDelete method.

type AccountsBeginUpdateOptions 

type AccountsBeginUpdateOptions struct {
}

AccountsBeginUpdateOptions contains the optional parameters for the Accounts.BeginUpdate method.

type AccountsClient 

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

AccountsClient contains the methods for the Accounts group. Don't use this type directly, use NewAccountsClient() instead.

func NewAccountsClient 

func NewAccountsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) *AccountsClient

NewAccountsClient creates a new instance of AccountsClient with the specified values.

func (*AccountsClient) BeginCreateOrUpdate 

func (client *AccountsClient) BeginCreateOrUpdate(ctx context.Context, resourceGroupName string, accountName string, body NetAppAccount, options *AccountsBeginCreateOrUpdateOptions) (AccountsCreateOrUpdatePollerResponse, error)

BeginCreateOrUpdate - Create or update the specified NetApp account within the resource group If the operation fails it returns a generic error.

Example

x-ms-original-file: specification/netapp/resource-manager/Microsoft.NetApp/stable/2021-08-01/examples/Accounts_CreateOrUpdate.json 

package main

import (
	"context"
	"log"

	"time"

	"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/netapp/armnetapp"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client := armnetapp.NewAccountsClient("<subscription-id>", cred, nil)
	poller, err := client.BeginCreateOrUpdate(ctx,
		"<resource-group-name>",
		"<account-name>",
		armnetapp.NetAppAccount{
			Location: to.StringPtr("<location>"),
			Properties: &armnetapp.AccountProperties{
				ActiveDirectories: []*armnetapp.ActiveDirectory{
					{
						AesEncryption:      to.BoolPtr(true),
						DNS:                to.StringPtr("<dns>"),
						Domain:             to.StringPtr("<domain>"),
						LdapOverTLS:        to.BoolPtr(false),
						LdapSigning:        to.BoolPtr(false),
						OrganizationalUnit: to.StringPtr("<organizational-unit>"),
						Password:           to.StringPtr("<password>"),
						Site:               to.StringPtr("<site>"),
						SmbServerName:      to.StringPtr("<smb-server-name>"),
						Username:           to.StringPtr("<username>"),
					}},
			},
		},
		nil)
	if err != nil {
		log.Fatal(err)
	}
	res, err := poller.PollUntilDone(ctx, 30*time.Second)
	if err != nil {
		log.Fatal(err)
	}
	log.Printf("NetAppAccount.ID: %s\n", *res.ID)
}

Output:

func (*AccountsClient) BeginDelete 

func (client *AccountsClient) BeginDelete(ctx context.Context, resourceGroupName string, accountName string, options *AccountsBeginDeleteOptions) (AccountsDeletePollerResponse, error)

BeginDelete - Delete the specified NetApp account If the operation fails it returns a generic error.

Example

x-ms-original-file: specification/netapp/resource-manager/Microsoft.NetApp/stable/2021-08-01/examples/Accounts_Delete.json 

package main

import (
	"context"
	"log"

	"time"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/netapp/armnetapp"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client := armnetapp.NewAccountsClient("<subscription-id>", cred, nil)
	poller, err := client.BeginDelete(ctx,
		"<resource-group-name>",
		"<account-name>",
		nil)
	if err != nil {
		log.Fatal(err)
	}
	_, err = poller.PollUntilDone(ctx, 30*time.Second)
	if err != nil {
		log.Fatal(err)
	}
}

Output:

func (*AccountsClient) BeginUpdate 

func (client *AccountsClient) BeginUpdate(ctx context.Context, resourceGroupName string, accountName string, body NetAppAccountPatch, options *AccountsBeginUpdateOptions) (AccountsUpdatePollerResponse, error)

BeginUpdate - Patch the specified NetApp account If the operation fails it returns the *CloudError error type.

Example

x-ms-original-file: specification/netapp/resource-manager/Microsoft.NetApp/stable/2021-08-01/examples/Accounts_Update.json 

package main

import (
	"context"
	"log"

	"time"

	"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/netapp/armnetapp"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client := armnetapp.NewAccountsClient("<subscription-id>", cred, nil)
	poller, err := client.BeginUpdate(ctx,
		"<resource-group-name>",
		"<account-name>",
		armnetapp.NetAppAccountPatch{
			Tags: map[string]*string{
				"Tag1": to.StringPtr("Value1"),
			},
		},
		nil)
	if err != nil {
		log.Fatal(err)
	}
	res, err := poller.PollUntilDone(ctx, 30*time.Second)
	if err != nil {
		log.Fatal(err)
	}
	log.Printf("NetAppAccount.ID: %s\n", *res.ID)
}

Output:

func (*AccountsClient) Get 

func (client *AccountsClient) Get(ctx context.Context, resourceGroupName string, accountName string, options *AccountsGetOptions) (AccountsGetResponse, error)

Get - Get the NetApp account If the operation fails it returns a generic error.

Example

x-ms-original-file: specification/netapp/resource-manager/Microsoft.NetApp/stable/2021-08-01/examples/Accounts_Get.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/netapp/armnetapp"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client := armnetapp.NewAccountsClient("<subscription-id>", cred, nil)
	res, err := client.Get(ctx,
		"<resource-group-name>",
		"<account-name>",
		nil)
	if err != nil {
		log.Fatal(err)
	}
	log.Printf("NetAppAccount.ID: %s\n", *res.ID)
}

Output:

func (*AccountsClient) List 

func (client *AccountsClient) List(resourceGroupName string, options *AccountsListOptions) *AccountsListPager

List - List and describe all NetApp accounts in the resource group. If the operation fails it returns a generic error.

Example

x-ms-original-file: specification/netapp/resource-manager/Microsoft.NetApp/stable/2021-08-01/examples/Accounts_List.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/netapp/armnetapp"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client := armnetapp.NewAccountsClient("<subscription-id>", cred, nil)
	pager := client.List("<resource-group-name>",
		nil)
	for pager.NextPage(ctx) {
		if err := pager.Err(); err != nil {
			log.Fatalf("failed to advance page: %v", err)
		}
		for _, v := range pager.PageResponse().Value {
			log.Printf("NetAppAccount.ID: %s\n", *v.ID)
		}
	}
}

Output:

func (*AccountsClient) ListBySubscription 

func (client *AccountsClient) ListBySubscription(options *AccountsListBySubscriptionOptions) *AccountsListBySubscriptionPager

ListBySubscription - List and describe all NetApp accounts in the subscription. If the operation fails it returns a generic error.

Example

x-ms-original-file: specification/netapp/resource-manager/Microsoft.NetApp/stable/2021-08-01/examples/Accounts_List.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/netapp/armnetapp"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client := armnetapp.NewAccountsClient("<subscription-id>", cred, nil)
	pager := client.ListBySubscription(nil)
	for pager.NextPage(ctx) {
		if err := pager.Err(); err != nil {
			log.Fatalf("failed to advance page: %v", err)
		}
		for _, v := range pager.PageResponse().Value {
			log.Printf("NetAppAccount.ID: %s\n", *v.ID)
		}
	}
}

Output:

type AccountsCreateOrUpdatePoller 

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

AccountsCreateOrUpdatePoller provides polling facilities until the operation reaches a terminal state.

func (*AccountsCreateOrUpdatePoller) Done 

func (p *AccountsCreateOrUpdatePoller) Done() bool

Done returns true if the LRO has reached a terminal state.

func (*AccountsCreateOrUpdatePoller) FinalResponse 

func (p *AccountsCreateOrUpdatePoller) FinalResponse(ctx context.Context) (AccountsCreateOrUpdateResponse, error)

FinalResponse performs a final GET to the service and returns the final response for the polling operation. If there is an error performing the final GET then an error is returned. If the final GET succeeded then the final AccountsCreateOrUpdateResponse will be returned.

func (*AccountsCreateOrUpdatePoller) Poll 

func (p *AccountsCreateOrUpdatePoller) Poll(ctx context.Context) (*http.Response, error)

Poll fetches the latest state of the LRO. It returns an HTTP response or error. If the LRO has completed successfully, the poller's state is updated and the HTTP response is returned. If the LRO has completed with failure or was cancelled, the poller's state is updated and the error is returned. If the LRO has not reached a terminal state, the poller's state is updated and the latest HTTP response is returned. If Poll fails, the poller's state is unmodified and the error is returned. Calling Poll on an LRO that has reached a terminal state will return the final HTTP response or error.

func (*AccountsCreateOrUpdatePoller) ResumeToken 

func (p *AccountsCreateOrUpdatePoller) ResumeToken() (string, error)

ResumeToken returns a value representing the poller that can be used to resume the LRO at a later time. ResumeTokens are unique per service operation.

type AccountsCreateOrUpdatePollerResponse 

type AccountsCreateOrUpdatePollerResponse struct {
	// Poller contains an initialized poller.
	Poller *AccountsCreateOrUpdatePoller

	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

AccountsCreateOrUpdatePollerResponse contains the response from method Accounts.CreateOrUpdate.

func (AccountsCreateOrUpdatePollerResponse) PollUntilDone 

func (l AccountsCreateOrUpdatePollerResponse) PollUntilDone(ctx context.Context, freq time.Duration) (AccountsCreateOrUpdateResponse, error)

PollUntilDone will poll the service endpoint until a terminal state is reached or an error is received. freq: the time to wait between intervals in absence of a Retry-After header. Allowed minimum is one second. A good starting value is 30 seconds. Note that some resources might benefit from a different value.

func (*AccountsCreateOrUpdatePollerResponse) Resume 

func (l *AccountsCreateOrUpdatePollerResponse) Resume(ctx context.Context, client *AccountsClient, token string) error

Resume rehydrates a AccountsCreateOrUpdatePollerResponse from the provided client and resume token.

type AccountsCreateOrUpdateResponse 

type AccountsCreateOrUpdateResponse struct {
	AccountsCreateOrUpdateResult
	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

AccountsCreateOrUpdateResponse contains the response from method Accounts.CreateOrUpdate.

type AccountsCreateOrUpdateResult 

type AccountsCreateOrUpdateResult struct {
	NetAppAccount
}

AccountsCreateOrUpdateResult contains the result from method Accounts.CreateOrUpdate.

type AccountsDeletePoller 

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

AccountsDeletePoller provides polling facilities until the operation reaches a terminal state.

func (*AccountsDeletePoller) Done 

func (p *AccountsDeletePoller) Done() bool

Done returns true if the LRO has reached a terminal state.

func (*AccountsDeletePoller) FinalResponse 

func (p *AccountsDeletePoller) FinalResponse(ctx context.Context) (AccountsDeleteResponse, error)

FinalResponse performs a final GET to the service and returns the final response for the polling operation. If there is an error performing the final GET then an error is returned. If the final GET succeeded then the final AccountsDeleteResponse will be returned.

func (*AccountsDeletePoller) Poll 

func (p *AccountsDeletePoller) Poll(ctx context.Context) (*http.Response, error)

Poll fetches the latest state of the LRO. It returns an HTTP response or error. If the LRO has completed successfully, the poller's state is updated and the HTTP response is returned. If the LRO has completed with failure or was cancelled, the poller's state is updated and the error is returned. If the LRO has not reached a terminal state, the poller's state is updated and the latest HTTP response is returned. If Poll fails, the poller's state is unmodified and the error is returned. Calling Poll on an LRO that has reached a terminal state will return the final HTTP response or error.

func (*AccountsDeletePoller) ResumeToken 

func (p *AccountsDeletePoller) ResumeToken() (string, error)

ResumeToken returns a value representing the poller that can be used to resume the LRO at a later time. ResumeTokens are unique per service operation.

type AccountsDeletePollerResponse 

type AccountsDeletePollerResponse struct {
	// Poller contains an initialized poller.
	Poller *AccountsDeletePoller

	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

AccountsDeletePollerResponse contains the response from method Accounts.Delete.

func (AccountsDeletePollerResponse) PollUntilDone 

func (l AccountsDeletePollerResponse) PollUntilDone(ctx context.Context, freq time.Duration) (AccountsDeleteResponse, error)

PollUntilDone will poll the service endpoint until a terminal state is reached or an error is received. freq: the time to wait between intervals in absence of a Retry-After header. Allowed minimum is one second. A good starting value is 30 seconds. Note that some resources might benefit from a different value.

func (*AccountsDeletePollerResponse) Resume 

func (l *AccountsDeletePollerResponse) Resume(ctx context.Context, client *AccountsClient, token string) error

Resume rehydrates a AccountsDeletePollerResponse from the provided client and resume token.

type AccountsDeleteResponse 

type AccountsDeleteResponse struct {
	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

AccountsDeleteResponse contains the response from method Accounts.Delete.

type AccountsGetOptions 

type AccountsGetOptions struct {
}

AccountsGetOptions contains the optional parameters for the Accounts.Get method.

type AccountsGetResponse 

type AccountsGetResponse struct {
	AccountsGetResult
	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

AccountsGetResponse contains the response from method Accounts.Get.

type AccountsGetResult 

type AccountsGetResult struct {
	NetAppAccount
}

AccountsGetResult contains the result from method Accounts.Get.

type AccountsListBySubscriptionOptions 

type AccountsListBySubscriptionOptions struct {
}

AccountsListBySubscriptionOptions contains the optional parameters for the Accounts.ListBySubscription method.

type AccountsListBySubscriptionPager 

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

AccountsListBySubscriptionPager provides operations for iterating over paged responses.

func (*AccountsListBySubscriptionPager) Err 

func (p *AccountsListBySubscriptionPager) Err() error

Err returns the last error encountered while paging.

func (*AccountsListBySubscriptionPager) NextPage 

func (p *AccountsListBySubscriptionPager) NextPage(ctx context.Context) bool

NextPage returns true if the pager advanced to the next page. Returns false if there are no more pages or an error occurred.

func (*AccountsListBySubscriptionPager) PageResponse 

func (p *AccountsListBySubscriptionPager) PageResponse() AccountsListBySubscriptionResponse

PageResponse returns the current AccountsListBySubscriptionResponse page.

type AccountsListBySubscriptionResponse 

type AccountsListBySubscriptionResponse struct {
	AccountsListBySubscriptionResult
	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

AccountsListBySubscriptionResponse contains the response from method Accounts.ListBySubscription.

type AccountsListBySubscriptionResult 

type AccountsListBySubscriptionResult struct {
	NetAppAccountList
}

AccountsListBySubscriptionResult contains the result from method Accounts.ListBySubscription.

type AccountsListOptions 

type AccountsListOptions struct {
}

AccountsListOptions contains the optional parameters for the Accounts.List method.

type AccountsListPager 

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

AccountsListPager provides operations for iterating over paged responses.

func (*AccountsListPager) Err 

func (p *AccountsListPager) Err() error

Err returns the last error encountered while paging.

func (*AccountsListPager) NextPage 

func (p *AccountsListPager) NextPage(ctx context.Context) bool

NextPage returns true if the pager advanced to the next page. Returns false if there are no more pages or an error occurred.

func (*AccountsListPager) PageResponse 

func (p *AccountsListPager) PageResponse() AccountsListResponse

PageResponse returns the current AccountsListResponse page.

type AccountsListResponse 

type AccountsListResponse struct {
	AccountsListResult
	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

AccountsListResponse contains the response from method Accounts.List.

type AccountsListResult 

type AccountsListResult struct {
	NetAppAccountList
}

AccountsListResult contains the result from method Accounts.List.

type AccountsUpdatePoller 

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

AccountsUpdatePoller provides polling facilities until the operation reaches a terminal state.

func (*AccountsUpdatePoller) Done 

func (p *AccountsUpdatePoller) Done() bool

Done returns true if the LRO has reached a terminal state.

func (*AccountsUpdatePoller) FinalResponse 

func (p *AccountsUpdatePoller) FinalResponse(ctx context.Context) (AccountsUpdateResponse, error)

FinalResponse performs a final GET to the service and returns the final response for the polling operation. If there is an error performing the final GET then an error is returned. If the final GET succeeded then the final AccountsUpdateResponse will be returned.

func (*AccountsUpdatePoller) Poll 

func (p *AccountsUpdatePoller) Poll(ctx context.Context) (*http.Response, error)

Poll fetches the latest state of the LRO. It returns an HTTP response or error. If the LRO has completed successfully, the poller's state is updated and the HTTP response is returned. If the LRO has completed with failure or was cancelled, the poller's state is updated and the error is returned. If the LRO has not reached a terminal state, the poller's state is updated and the latest HTTP response is returned. If Poll fails, the poller's state is unmodified and the error is returned. Calling Poll on an LRO that has reached a terminal state will return the final HTTP response or error.

func (*AccountsUpdatePoller) ResumeToken 

func (p *AccountsUpdatePoller) ResumeToken() (string, error)

ResumeToken returns a value representing the poller that can be used to resume the LRO at a later time. ResumeTokens are unique per service operation.

type AccountsUpdatePollerResponse 

type AccountsUpdatePollerResponse struct {
	// Poller contains an initialized poller.
	Poller *AccountsUpdatePoller

	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

AccountsUpdatePollerResponse contains the response from method Accounts.Update.

func (AccountsUpdatePollerResponse) PollUntilDone 

func (l AccountsUpdatePollerResponse) PollUntilDone(ctx context.Context, freq time.Duration) (AccountsUpdateResponse, error)

PollUntilDone will poll the service endpoint until a terminal state is reached or an error is received. freq: the time to wait between intervals in absence of a Retry-After header. Allowed minimum is one second. A good starting value is 30 seconds. Note that some resources might benefit from a different value.

func (*AccountsUpdatePollerResponse) Resume 

func (l *AccountsUpdatePollerResponse) Resume(ctx context.Context, client *AccountsClient, token string) error

Resume rehydrates a AccountsUpdatePollerResponse from the provided client and resume token.

type AccountsUpdateResponse 

type AccountsUpdateResponse struct {
	AccountsUpdateResult
	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

AccountsUpdateResponse contains the response from method Accounts.Update.

type AccountsUpdateResult 

type AccountsUpdateResult struct {
	NetAppAccount
}

AccountsUpdateResult contains the result from method Accounts.Update.

type ActiveDirectory 

type ActiveDirectory struct {
	// Id of the Active Directory
	ActiveDirectoryID *string `json:"activeDirectoryId,omitempty"`

	// Name of the active directory machine. This optional parameter is used only while creating kerberos volume
	AdName *string `json:"adName,omitempty"`

	// Users to be added to the Built-in Administrators active directory group. A list of unique usernames without domain specifier
	Administrators []*string `json:"administrators,omitempty"`

	// If enabled, AES encryption will be enabled for SMB communication.
	AesEncryption *bool `json:"aesEncryption,omitempty"`

	// If enabled, NFS client local users can also (in addition to LDAP users) access the NFS volumes.
	AllowLocalNfsUsersWithLdap *bool `json:"allowLocalNfsUsersWithLdap,omitempty"`

	// Users to be added to the Built-in Backup Operator active directory group. A list of unique usernames without domain specifier
	BackupOperators []*string `json:"backupOperators,omitempty"`

	// Comma separated list of DNS server IP addresses (IPv4 only) for the Active Directory domain
	DNS *string `json:"dns,omitempty"`

	// Name of the Active Directory domain
	Domain *string `json:"domain,omitempty"`

	// If enabled, Traffic between the SMB server to Domain Controller (DC) will be encrypted.
	EncryptDCConnections *bool `json:"encryptDCConnections,omitempty"`

	// kdc server IP addresses for the active directory machine. This optional parameter is used only while creating kerberos volume.
	KdcIP *string `json:"kdcIP,omitempty"`

	// Specifies whether or not the LDAP traffic needs to be secured via TLS.
	LdapOverTLS *bool `json:"ldapOverTLS,omitempty"`

	// Specifies whether or not the LDAP traffic needs to be signed.
	LdapSigning *bool `json:"ldapSigning,omitempty"`

	// The Organizational Unit (OU) within the Windows Active Directory
	OrganizationalUnit *string `json:"organizationalUnit,omitempty"`

	// Plain text password of Active Directory domain administrator, value is masked in the response
	Password *string `json:"password,omitempty"`

	// Domain Users in the Active directory to be given SeSecurityPrivilege privilege (Needed for SMB Continuously available shares for SQL). A list of unique
	// usernames without domain specifier
	SecurityOperators []*string `json:"securityOperators,omitempty"`

	// When LDAP over SSL/TLS is enabled, the LDAP client is required to have base64 encoded Active Directory Certificate Service's self-signed root CA certificate,
	// this optional parameter is used only for
	// dual protocol with LDAP user-mapping volumes.
	ServerRootCACertificate *string `json:"serverRootCACertificate,omitempty"`

	// The Active Directory site the service will limit Domain Controller discovery to
	Site *string `json:"site,omitempty"`

	// NetBIOS name of the SMB server. This name will be registered as a computer account in the AD and used to mount volumes
	SmbServerName *string `json:"smbServerName,omitempty"`

	// Username of Active Directory domain administrator
	Username *string `json:"username,omitempty"`

	// READ-ONLY; Status of the Active Directory
	Status *ActiveDirectoryStatus `json:"status,omitempty" azure:"ro"`

	// READ-ONLY; Any details in regards to the Status of the Active Directory
	StatusDetails *string `json:"statusDetails,omitempty" azure:"ro"`
}

ActiveDirectory - Active Directory

func (ActiveDirectory) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ActiveDirectory.

type ActiveDirectoryStatus 

type ActiveDirectoryStatus string

ActiveDirectoryStatus - Status of the Active Directory 

const (
	// ActiveDirectoryStatusCreated - Active Directory created but not in use
	ActiveDirectoryStatusCreated ActiveDirectoryStatus = "Created"
	// ActiveDirectoryStatusDeleted - Active Directory Deleted
	ActiveDirectoryStatusDeleted ActiveDirectoryStatus = "Deleted"
	// ActiveDirectoryStatusError - Error with the Active Directory
	ActiveDirectoryStatusError ActiveDirectoryStatus = "Error"
	// ActiveDirectoryStatusInUse - Active Directory in use by SMB Volume
	ActiveDirectoryStatusInUse ActiveDirectoryStatus = "InUse"
	// ActiveDirectoryStatusUpdating - Active Directory Updating
	ActiveDirectoryStatusUpdating ActiveDirectoryStatus = "Updating"
)

func PossibleActiveDirectoryStatusValues 

func PossibleActiveDirectoryStatusValues() []ActiveDirectoryStatus

PossibleActiveDirectoryStatusValues returns the possible values for the ActiveDirectoryStatus const type.

func (ActiveDirectoryStatus) ToPtr 

func (c ActiveDirectoryStatus) ToPtr() *ActiveDirectoryStatus

ToPtr returns a *ActiveDirectoryStatus pointing to the current value.

type ApplicationType 

type ApplicationType string

ApplicationType - Application Type 

const (
	ApplicationTypeSAPHANA ApplicationType = "SAP-HANA"
)

func PossibleApplicationTypeValues 

func PossibleApplicationTypeValues() []ApplicationType

PossibleApplicationTypeValues returns the possible values for the ApplicationType const type.

func (ApplicationType) ToPtr 

func (c ApplicationType) ToPtr() *ApplicationType

ToPtr returns a *ApplicationType pointing to the current value.

type AuthorizeRequest 

type AuthorizeRequest struct {
	// Resource id of the remote volume
	RemoteVolumeResourceID *string `json:"remoteVolumeResourceId,omitempty"`
}

AuthorizeRequest - Authorize request

type AvsDataStore 

type AvsDataStore string

AvsDataStore - Specifies whether the volume is enabled for Azure VMware Solution (AVS) datastore purpose 

const (
	// AvsDataStoreDisabled - avsDataStore is disabled
	AvsDataStoreDisabled AvsDataStore = "Disabled"
	// AvsDataStoreEnabled - avsDataStore is enabled
	AvsDataStoreEnabled AvsDataStore = "Enabled"
)

func PossibleAvsDataStoreValues 

func PossibleAvsDataStoreValues() []AvsDataStore

PossibleAvsDataStoreValues returns the possible values for the AvsDataStore const type.

func (AvsDataStore) ToPtr 

func (c AvsDataStore) ToPtr() *AvsDataStore

ToPtr returns a *AvsDataStore pointing to the current value.

type Backup 

type Backup struct {
	// REQUIRED; Resource location
	Location *string `json:"location,omitempty"`

	// REQUIRED; Backup Properties
	Properties *BackupProperties `json:"properties,omitempty"`

	// READ-ONLY; Resource Id
	ID *string `json:"id,omitempty" azure:"ro"`

	// READ-ONLY; Resource name
	Name *string `json:"name,omitempty" azure:"ro"`

	// READ-ONLY; Resource type
	Type *string `json:"type,omitempty" azure:"ro"`
}

Backup of a Volume

type BackupPatch 

type BackupPatch struct {
	// Backup Properties
	Properties *BackupProperties `json:"properties,omitempty"`

	// Resource tags
	Tags map[string]*string `json:"tags,omitempty"`
}

BackupPatch - Backup patch

func (BackupPatch) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type BackupPatch.

type BackupPoliciesBeginCreateOptions 

type BackupPoliciesBeginCreateOptions struct {
}

BackupPoliciesBeginCreateOptions contains the optional parameters for the BackupPolicies.BeginCreate method.

type BackupPoliciesBeginDeleteOptions 

type BackupPoliciesBeginDeleteOptions struct {
}

BackupPoliciesBeginDeleteOptions contains the optional parameters for the BackupPolicies.BeginDelete method.

type BackupPoliciesBeginUpdateOptions 

type BackupPoliciesBeginUpdateOptions struct {
}

BackupPoliciesBeginUpdateOptions contains the optional parameters for the BackupPolicies.BeginUpdate method.

type BackupPoliciesClient 

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

BackupPoliciesClient contains the methods for the BackupPolicies group. Don't use this type directly, use NewBackupPoliciesClient() instead.

func NewBackupPoliciesClient 

func NewBackupPoliciesClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) *BackupPoliciesClient

NewBackupPoliciesClient creates a new instance of BackupPoliciesClient with the specified values.

func (*BackupPoliciesClient) BeginCreate 

func (client *BackupPoliciesClient) BeginCreate(ctx context.Context, resourceGroupName string, accountName string, backupPolicyName string, body BackupPolicy, options *BackupPoliciesBeginCreateOptions) (BackupPoliciesCreatePollerResponse, error)

BeginCreate - Create a backup policy for Netapp Account If the operation fails it returns a generic error.

Example

x-ms-original-file: specification/netapp/resource-manager/Microsoft.NetApp/stable/2021-08-01/examples/BackupPolicies_Create.json 

package main

import (
	"context"
	"log"

	"time"

	"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/netapp/armnetapp"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client := armnetapp.NewBackupPoliciesClient("<subscription-id>", cred, nil)
	poller, err := client.BeginCreate(ctx,
		"<resource-group-name>",
		"<account-name>",
		"<backup-policy-name>",
		armnetapp.BackupPolicy{
			Location: to.StringPtr("<location>"),
			Properties: &armnetapp.BackupPolicyProperties{
				DailyBackupsToKeep:   to.Int32Ptr(10),
				Enabled:              to.BoolPtr(true),
				MonthlyBackupsToKeep: to.Int32Ptr(10),
				WeeklyBackupsToKeep:  to.Int32Ptr(10),
			},
		},
		nil)
	if err != nil {
		log.Fatal(err)
	}
	res, err := poller.PollUntilDone(ctx, 30*time.Second)
	if err != nil {
		log.Fatal(err)
	}
	log.Printf("BackupPolicy.ID: %s\n", *res.ID)
}

Output:

func (*BackupPoliciesClient) BeginDelete 

func (client *BackupPoliciesClient) BeginDelete(ctx context.Context, resourceGroupName string, accountName string, backupPolicyName string, options *BackupPoliciesBeginDeleteOptions) (BackupPoliciesDeletePollerResponse, error)

BeginDelete - Delete backup policy If the operation fails it returns a generic error.

Example

x-ms-original-file: specification/netapp/resource-manager/Microsoft.NetApp/stable/2021-08-01/examples/BackupPolicies_Delete.json 

package main

import (
	"context"
	"log"

	"time"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/netapp/armnetapp"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client := armnetapp.NewBackupPoliciesClient("<subscription-id>", cred, nil)
	poller, err := client.BeginDelete(ctx,
		"<resource-group-name>",
		"<account-name>",
		"<backup-policy-name>",
		nil)
	if err != nil {
		log.Fatal(err)
	}
	_, err = poller.PollUntilDone(ctx, 30*time.Second)
	if err != nil {
		log.Fatal(err)
	}
}

Output:

func (*BackupPoliciesClient) BeginUpdate 

func (client *BackupPoliciesClient) BeginUpdate(ctx context.Context, resourceGroupName string, accountName string, backupPolicyName string, body BackupPolicyPatch, options *BackupPoliciesBeginUpdateOptions) (BackupPoliciesUpdatePollerResponse, error)

BeginUpdate - Patch a backup policy for Netapp Account If the operation fails it returns a generic error.

Example

x-ms-original-file: specification/netapp/resource-manager/Microsoft.NetApp/stable/2021-08-01/examples/BackupPolicies_Update.json 

package main

import (
	"context"
	"log"

	"time"

	"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/netapp/armnetapp"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client := armnetapp.NewBackupPoliciesClient("<subscription-id>", cred, nil)
	poller, err := client.BeginUpdate(ctx,
		"<resource-group-name>",
		"<account-name>",
		"<backup-policy-name>",
		armnetapp.BackupPolicyPatch{
			Location: to.StringPtr("<location>"),
			Properties: &armnetapp.BackupPolicyProperties{
				DailyBackupsToKeep:   to.Int32Ptr(5),
				Enabled:              to.BoolPtr(false),
				MonthlyBackupsToKeep: to.Int32Ptr(10),
				WeeklyBackupsToKeep:  to.Int32Ptr(10),
			},
		},
		nil)
	if err != nil {
		log.Fatal(err)
	}
	res, err := poller.PollUntilDone(ctx, 30*time.Second)
	if err != nil {
		log.Fatal(err)
	}
	log.Printf("BackupPolicy.ID: %s\n", *res.ID)
}

Output:

func (*BackupPoliciesClient) Get 

func (client *BackupPoliciesClient) Get(ctx context.Context, resourceGroupName string, accountName string, backupPolicyName string, options *BackupPoliciesGetOptions) (BackupPoliciesGetResponse, error)

Get - Get a particular backup Policy If the operation fails it returns a generic error.

Example

x-ms-original-file: specification/netapp/resource-manager/Microsoft.NetApp/stable/2021-08-01/examples/BackupPolicies_Get.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/netapp/armnetapp"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client := armnetapp.NewBackupPoliciesClient("<subscription-id>", cred, nil)
	res, err := client.Get(ctx,
		"<resource-group-name>",
		"<account-name>",
		"<backup-policy-name>",
		nil)
	if err != nil {
		log.Fatal(err)
	}
	log.Printf("BackupPolicy.ID: %s\n", *res.ID)
}

Output:

func (*BackupPoliciesClient) List 

func (client *BackupPoliciesClient) List(ctx context.Context, resourceGroupName string, accountName string, options *BackupPoliciesListOptions) (BackupPoliciesListResponse, error)

List - List backup policies for Netapp Account If the operation fails it returns a generic error.

Example

x-ms-original-file: specification/netapp/resource-manager/Microsoft.NetApp/stable/2021-08-01/examples/BackupPolicies_List.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/netapp/armnetapp"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client := armnetapp.NewBackupPoliciesClient("<subscription-id>", cred, nil)
	_, err = client.List(ctx,
		"<resource-group-name>",
		"<account-name>",
		nil)
	if err != nil {
		log.Fatal(err)
	}
}

Output:

type BackupPoliciesCreatePoller 

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

BackupPoliciesCreatePoller provides polling facilities until the operation reaches a terminal state.

func (*BackupPoliciesCreatePoller) Done 

func (p *BackupPoliciesCreatePoller) Done() bool

Done returns true if the LRO has reached a terminal state.

func (*BackupPoliciesCreatePoller) FinalResponse 

func (p *BackupPoliciesCreatePoller) FinalResponse(ctx context.Context) (BackupPoliciesCreateResponse, error)

FinalResponse performs a final GET to the service and returns the final response for the polling operation. If there is an error performing the final GET then an error is returned. If the final GET succeeded then the final BackupPoliciesCreateResponse will be returned.

func (*BackupPoliciesCreatePoller) Poll 

func (p *BackupPoliciesCreatePoller) Poll(ctx context.Context) (*http.Response, error)

Poll fetches the latest state of the LRO. It returns an HTTP response or error. If the LRO has completed successfully, the poller's state is updated and the HTTP response is returned. If the LRO has completed with failure or was cancelled, the poller's state is updated and the error is returned. If the LRO has not reached a terminal state, the poller's state is updated and the latest HTTP response is returned. If Poll fails, the poller's state is unmodified and the error is returned. Calling Poll on an LRO that has reached a terminal state will return the final HTTP response or error.

func (*BackupPoliciesCreatePoller) ResumeToken 

func (p *BackupPoliciesCreatePoller) ResumeToken() (string, error)

ResumeToken returns a value representing the poller that can be used to resume the LRO at a later time. ResumeTokens are unique per service operation.

type BackupPoliciesCreatePollerResponse 

type BackupPoliciesCreatePollerResponse struct {
	// Poller contains an initialized poller.
	Poller *BackupPoliciesCreatePoller

	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

BackupPoliciesCreatePollerResponse contains the response from method BackupPolicies.Create.

func (BackupPoliciesCreatePollerResponse) PollUntilDone 

func (l BackupPoliciesCreatePollerResponse) PollUntilDone(ctx context.Context, freq time.Duration) (BackupPoliciesCreateResponse, error)

PollUntilDone will poll the service endpoint until a terminal state is reached or an error is received. freq: the time to wait between intervals in absence of a Retry-After header. Allowed minimum is one second. A good starting value is 30 seconds. Note that some resources might benefit from a different value.

func (*BackupPoliciesCreatePollerResponse) Resume 

func (l *BackupPoliciesCreatePollerResponse) Resume(ctx context.Context, client *BackupPoliciesClient, token string) error

Resume rehydrates a BackupPoliciesCreatePollerResponse from the provided client and resume token.

type BackupPoliciesCreateResponse 

type BackupPoliciesCreateResponse struct {
	BackupPoliciesCreateResult
	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

BackupPoliciesCreateResponse contains the response from method BackupPolicies.Create.

type BackupPoliciesCreateResult 

type BackupPoliciesCreateResult struct {
	BackupPolicy
}

BackupPoliciesCreateResult contains the result from method BackupPolicies.Create.

type BackupPoliciesDeletePoller 

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

BackupPoliciesDeletePoller provides polling facilities until the operation reaches a terminal state.

func (*BackupPoliciesDeletePoller) Done 

func (p *BackupPoliciesDeletePoller) Done() bool

Done returns true if the LRO has reached a terminal state.

func (*BackupPoliciesDeletePoller) FinalResponse 

func (p *BackupPoliciesDeletePoller) FinalResponse(ctx context.Context) (BackupPoliciesDeleteResponse, error)

FinalResponse performs a final GET to the service and returns the final response for the polling operation. If there is an error performing the final GET then an error is returned. If the final GET succeeded then the final BackupPoliciesDeleteResponse will be returned.

func (*BackupPoliciesDeletePoller) Poll 

func (p *BackupPoliciesDeletePoller) Poll(ctx context.Context) (*http.Response, error)

Poll fetches the latest state of the LRO. It returns an HTTP response or error. If the LRO has completed successfully, the poller's state is updated and the HTTP response is returned. If the LRO has completed with failure or was cancelled, the poller's state is updated and the error is returned. If the LRO has not reached a terminal state, the poller's state is updated and the latest HTTP response is returned. If Poll fails, the poller's state is unmodified and the error is returned. Calling Poll on an LRO that has reached a terminal state will return the final HTTP response or error.

func (*BackupPoliciesDeletePoller) ResumeToken 

func (p *BackupPoliciesDeletePoller) ResumeToken() (string, error)

ResumeToken returns a value representing the poller that can be used to resume the LRO at a later time. ResumeTokens are unique per service operation.

type BackupPoliciesDeletePollerResponse 

type BackupPoliciesDeletePollerResponse struct {
	// Poller contains an initialized poller.
	Poller *BackupPoliciesDeletePoller

	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

BackupPoliciesDeletePollerResponse contains the response from method BackupPolicies.Delete.

func (BackupPoliciesDeletePollerResponse) PollUntilDone 

func (l BackupPoliciesDeletePollerResponse) PollUntilDone(ctx context.Context, freq time.Duration) (BackupPoliciesDeleteResponse, error)

PollUntilDone will poll the service endpoint until a terminal state is reached or an error is received. freq: the time to wait between intervals in absence of a Retry-After header. Allowed minimum is one second. A good starting value is 30 seconds. Note that some resources might benefit from a different value.

func (*BackupPoliciesDeletePollerResponse) Resume 

func (l *BackupPoliciesDeletePollerResponse) Resume(ctx context.Context, client *BackupPoliciesClient, token string) error

Resume rehydrates a BackupPoliciesDeletePollerResponse from the provided client and resume token.

type BackupPoliciesDeleteResponse 

type BackupPoliciesDeleteResponse struct {
	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

BackupPoliciesDeleteResponse contains the response from method BackupPolicies.Delete.

type BackupPoliciesGetOptions 

type BackupPoliciesGetOptions struct {
}

BackupPoliciesGetOptions contains the optional parameters for the BackupPolicies.Get method.

type BackupPoliciesGetResponse 

type BackupPoliciesGetResponse struct {
	BackupPoliciesGetResult
	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

BackupPoliciesGetResponse contains the response from method BackupPolicies.Get.

type BackupPoliciesGetResult 

type BackupPoliciesGetResult struct {
	BackupPolicy
}

BackupPoliciesGetResult contains the result from method BackupPolicies.Get.

type BackupPoliciesList 

type BackupPoliciesList struct {
	// A list of backup policies
	Value []*BackupPolicy `json:"value,omitempty"`
}

BackupPoliciesList - List of Backup Policies

func (BackupPoliciesList) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type BackupPoliciesList.

type BackupPoliciesListOptions 

type BackupPoliciesListOptions struct {
}

BackupPoliciesListOptions contains the optional parameters for the BackupPolicies.List method.

type BackupPoliciesListResponse 

type BackupPoliciesListResponse struct {
	BackupPoliciesListResult
	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

BackupPoliciesListResponse contains the response from method BackupPolicies.List.

type BackupPoliciesListResult 

type BackupPoliciesListResult struct {
	BackupPoliciesList
}

BackupPoliciesListResult contains the result from method BackupPolicies.List.

type BackupPoliciesUpdatePoller 

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

BackupPoliciesUpdatePoller provides polling facilities until the operation reaches a terminal state.

func (*BackupPoliciesUpdatePoller) Done 

func (p *BackupPoliciesUpdatePoller) Done() bool

Done returns true if the LRO has reached a terminal state.

func (*BackupPoliciesUpdatePoller) FinalResponse 

func (p *BackupPoliciesUpdatePoller) FinalResponse(ctx context.Context) (BackupPoliciesUpdateResponse, error)

FinalResponse performs a final GET to the service and returns the final response for the polling operation. If there is an error performing the final GET then an error is returned. If the final GET succeeded then the final BackupPoliciesUpdateResponse will be returned.

func (*BackupPoliciesUpdatePoller) Poll 

func (p *BackupPoliciesUpdatePoller) Poll(ctx context.Context) (*http.Response, error)

Poll fetches the latest state of the LRO. It returns an HTTP response or error. If the LRO has completed successfully, the poller's state is updated and the HTTP response is returned. If the LRO has completed with failure or was cancelled, the poller's state is updated and the error is returned. If the LRO has not reached a terminal state, the poller's state is updated and the latest HTTP response is returned. If Poll fails, the poller's state is unmodified and the error is returned. Calling Poll on an LRO that has reached a terminal state will return the final HTTP response or error.

func (*BackupPoliciesUpdatePoller) ResumeToken 

func (p *BackupPoliciesUpdatePoller) ResumeToken() (string, error)

ResumeToken returns a value representing the poller that can be used to resume the LRO at a later time. ResumeTokens are unique per service operation.

type BackupPoliciesUpdatePollerResponse 

type BackupPoliciesUpdatePollerResponse struct {
	// Poller contains an initialized poller.
	Poller *BackupPoliciesUpdatePoller

	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

BackupPoliciesUpdatePollerResponse contains the response from method BackupPolicies.Update.

func (BackupPoliciesUpdatePollerResponse) PollUntilDone 

func (l BackupPoliciesUpdatePollerResponse) PollUntilDone(ctx context.Context, freq time.Duration) (BackupPoliciesUpdateResponse, error)

PollUntilDone will poll the service endpoint until a terminal state is reached or an error is received. freq: the time to wait between intervals in absence of a Retry-After header. Allowed minimum is one second. A good starting value is 30 seconds. Note that some resources might benefit from a different value.

func (*BackupPoliciesUpdatePollerResponse) Resume 

func (l *BackupPoliciesUpdatePollerResponse) Resume(ctx context.Context, client *BackupPoliciesClient, token string) error

Resume rehydrates a BackupPoliciesUpdatePollerResponse from the provided client and resume token.

type BackupPoliciesUpdateResponse 

type BackupPoliciesUpdateResponse struct {
	BackupPoliciesUpdateResult
	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

BackupPoliciesUpdateResponse contains the response from method BackupPolicies.Update.

type BackupPoliciesUpdateResult 

type BackupPoliciesUpdateResult struct {
	BackupPolicy
}

BackupPoliciesUpdateResult contains the result from method BackupPolicies.Update.

type BackupPolicy 

type BackupPolicy struct {
	// REQUIRED; Resource location
	Location *string `json:"location,omitempty"`

	// REQUIRED; Backup policy Properties
	Properties *BackupPolicyProperties `json:"properties,omitempty"`

	// Resource tags
	Tags map[string]*string `json:"tags,omitempty"`

	// READ-ONLY; A unique read-only string that changes whenever the resource is updated.
	Etag *string `json:"etag,omitempty" azure:"ro"`

	// READ-ONLY; Resource Id
	ID *string `json:"id,omitempty" azure:"ro"`

	// READ-ONLY; Resource name
	Name *string `json:"name,omitempty" azure:"ro"`

	// READ-ONLY; Resource type
	Type *string `json:"type,omitempty" azure:"ro"`
}

BackupPolicy - Backup policy information

func (BackupPolicy) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type BackupPolicy.

type BackupPolicyDetails 

type BackupPolicyDetails struct {
	// Resource location
	Location *string `json:"location,omitempty"`

	// Backup policy Properties
	Properties *BackupPolicyProperties `json:"properties,omitempty"`

	// Resource tags
	Tags map[string]*string `json:"tags,omitempty"`

	// READ-ONLY; Resource Id
	ID *string `json:"id,omitempty" azure:"ro"`

	// READ-ONLY; Resource name
	Name *string `json:"name,omitempty" azure:"ro"`

	// READ-ONLY; Resource type
	Type *string `json:"type,omitempty" azure:"ro"`
}

BackupPolicyDetails - Backup policy properties

func (BackupPolicyDetails) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type BackupPolicyDetails.

type BackupPolicyPatch 

type BackupPolicyPatch struct {
	// Resource location
	Location *string `json:"location,omitempty"`

	// Backup policy Properties
	Properties *BackupPolicyProperties `json:"properties,omitempty"`

	// Resource tags
	Tags map[string]*string `json:"tags,omitempty"`

	// READ-ONLY; Resource Id
	ID *string `json:"id,omitempty" azure:"ro"`

	// READ-ONLY; Resource name
	Name *string `json:"name,omitempty" azure:"ro"`

	// READ-ONLY; Resource type
	Type *string `json:"type,omitempty" azure:"ro"`
}

BackupPolicyPatch - Backup policy Details for create and update

func (BackupPolicyPatch) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type BackupPolicyPatch.

type BackupPolicyProperties 

type BackupPolicyProperties struct {
	// Daily backups count to keep
	DailyBackupsToKeep *int32 `json:"dailyBackupsToKeep,omitempty"`

	// The property to decide policy is enabled or not
	Enabled *bool `json:"enabled,omitempty"`

	// Monthly backups count to keep
	MonthlyBackupsToKeep *int32 `json:"monthlyBackupsToKeep,omitempty"`

	// Weekly backups count to keep
	WeeklyBackupsToKeep *int32 `json:"weeklyBackupsToKeep,omitempty"`

	// READ-ONLY; Backup Policy Resource ID
	BackupPolicyID *string `json:"backupPolicyId,omitempty" azure:"ro"`

	// READ-ONLY; Azure lifecycle management
	ProvisioningState *string `json:"provisioningState,omitempty" azure:"ro"`

	// READ-ONLY; A list of volumes assigned to this policy
	VolumeBackups []*VolumeBackups `json:"volumeBackups,omitempty" azure:"ro"`

	// READ-ONLY; Volumes using current backup policy
	VolumesAssigned *int32 `json:"volumesAssigned,omitempty" azure:"ro"`
}

BackupPolicyProperties - Backup policy properties

func (BackupPolicyProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type BackupPolicyProperties.

type BackupProperties 

type BackupProperties struct {
	// Label for backup
	Label *string `json:"label,omitempty"`

	// Manual backup an already existing snapshot. This will always be false for scheduled backups and true/false for manual backups
	UseExistingSnapshot *bool `json:"useExistingSnapshot,omitempty"`

	// READ-ONLY; UUID v4 used to identify the Backup
	BackupID *string `json:"backupId,omitempty" azure:"ro"`

	// READ-ONLY; Type of backup Manual or Scheduled
	BackupType *BackupType `json:"backupType,omitempty" azure:"ro"`

	// READ-ONLY; The creation date of the backup
	CreationDate *time.Time `json:"creationDate,omitempty" azure:"ro"`

	// READ-ONLY; Failure reason
	FailureReason *string `json:"failureReason,omitempty" azure:"ro"`

	// READ-ONLY; Azure lifecycle management
	ProvisioningState *string `json:"provisioningState,omitempty" azure:"ro"`

	// READ-ONLY; Size of backup
	Size *int64 `json:"size,omitempty" azure:"ro"`

	// READ-ONLY; Volume name
	VolumeName *string `json:"volumeName,omitempty" azure:"ro"`
}

BackupProperties - Backup properties

func (BackupProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type BackupProperties.

func (*BackupProperties) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type BackupProperties.

type BackupStatus 

type BackupStatus struct {
	// READ-ONLY; Displays error message if the backup is in an error state
	ErrorMessage *string `json:"errorMessage,omitempty" azure:"ro"`

	// READ-ONLY; Backup health status
	Healthy *bool `json:"healthy,omitempty" azure:"ro"`

	// READ-ONLY; Displays the last transfer size
	LastTransferSize *int64 `json:"lastTransferSize,omitempty" azure:"ro"`

	// READ-ONLY; Displays the last transfer type
	LastTransferType *string `json:"lastTransferType,omitempty" azure:"ro"`

	// READ-ONLY; The status of the backup
	MirrorState *MirrorState `json:"mirrorState,omitempty" azure:"ro"`

	// READ-ONLY; Status of the backup mirror relationship
	RelationshipStatus *RelationshipStatus `json:"relationshipStatus,omitempty" azure:"ro"`

	// READ-ONLY; Displays the total bytes transferred
	TotalTransferBytes *int64 `json:"totalTransferBytes,omitempty" azure:"ro"`

	// READ-ONLY; Reason for the unhealthy backup relationship
	UnhealthyReason *string `json:"unhealthyReason,omitempty" azure:"ro"`
}

BackupStatus - Backup status

type BackupType 

type BackupType string

BackupType - Type of backup Manual or Scheduled 

const (
	// BackupTypeManual - Manual backup
	BackupTypeManual BackupType = "Manual"
	// BackupTypeScheduled - Scheduled backup
	BackupTypeScheduled BackupType = "Scheduled"
)

func PossibleBackupTypeValues 

func PossibleBackupTypeValues() []BackupType

PossibleBackupTypeValues returns the possible values for the BackupType const type.

func (BackupType) ToPtr 

func (c BackupType) ToPtr() *BackupType

ToPtr returns a *BackupType pointing to the current value.

type BackupsBeginCreateOptions 

type BackupsBeginCreateOptions struct {
}

BackupsBeginCreateOptions contains the optional parameters for the Backups.BeginCreate method.

type BackupsBeginDeleteOptions 

type BackupsBeginDeleteOptions struct {
}

BackupsBeginDeleteOptions contains the optional parameters for the Backups.BeginDelete method.

type BackupsBeginUpdateOptions 

type BackupsBeginUpdateOptions struct {
	// Backup object supplied in the body of the operation.
	Body *BackupPatch
}

BackupsBeginUpdateOptions contains the optional parameters for the Backups.BeginUpdate method.

type BackupsClient 

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

BackupsClient contains the methods for the Backups group. Don't use this type directly, use NewBackupsClient() instead.

func NewBackupsClient 

func NewBackupsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) *BackupsClient

NewBackupsClient creates a new instance of BackupsClient with the specified values.

func (*BackupsClient) BeginCreate 

func (client *BackupsClient) BeginCreate(ctx context.Context, resourceGroupName string, accountName string, poolName string, volumeName string, backupName string, body Backup, options *BackupsBeginCreateOptions) (BackupsCreatePollerResponse, error)

BeginCreate - Create a backup for the volume If the operation fails it returns a generic error.

Example

x-ms-original-file: specification/netapp/resource-manager/Microsoft.NetApp/stable/2021-08-01/examples/Backups_Create.json 

package main

import (
	"context"
	"log"

	"time"

	"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/netapp/armnetapp"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client := armnetapp.NewBackupsClient("<subscription-id>", cred, nil)
	poller, err := client.BeginCreate(ctx,
		"<resource-group-name>",
		"<account-name>",
		"<pool-name>",
		"<volume-name>",
		"<backup-name>",
		armnetapp.Backup{
			Location: to.StringPtr("<location>"),
			Properties: &armnetapp.BackupProperties{
				Label: to.StringPtr("<label>"),
			},
		},
		nil)
	if err != nil {
		log.Fatal(err)
	}
	res, err := poller.PollUntilDone(ctx, 30*time.Second)
	if err != nil {
		log.Fatal(err)
	}
	log.Printf("Backup.ID: %s\n", *res.ID)
}

Output:

func (*BackupsClient) BeginDelete 

func (client *BackupsClient) BeginDelete(ctx context.Context, resourceGroupName string, accountName string, poolName string, volumeName string, backupName string, options *BackupsBeginDeleteOptions) (BackupsDeletePollerResponse, error)

BeginDelete - Delete a backup of the volume If the operation fails it returns a generic error.

Example

x-ms-original-file: specification/netapp/resource-manager/Microsoft.NetApp/stable/2021-08-01/examples/Backups_Delete.json 

package main

import (
	"context"
	"log"

	"time"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/netapp/armnetapp"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client := armnetapp.NewBackupsClient("<subscription-id>", cred, nil)
	poller, err := client.BeginDelete(ctx,
		"<resource-group-name>",
		"<account-name>",
		"<pool-name>",
		"<volume-name>",
		"<backup-name>",
		nil)
	if err != nil {
		log.Fatal(err)
	}
	_, err = poller.PollUntilDone(ctx, 30*time.Second)
	if err != nil {
		log.Fatal(err)
	}
}

Output:

func (*BackupsClient) BeginUpdate 

func (client *BackupsClient) BeginUpdate(ctx context.Context, resourceGroupName string, accountName string, poolName string, volumeName string, backupName string, options *BackupsBeginUpdateOptions) (BackupsUpdatePollerResponse, error)

BeginUpdate - Patch a backup for the volume If the operation fails it returns a generic error.

Example

x-ms-original-file: specification/netapp/resource-manager/Microsoft.NetApp/stable/2021-08-01/examples/Backups_Update.json 

package main

import (
	"context"
	"log"

	"time"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/netapp/armnetapp"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client := armnetapp.NewBackupsClient("<subscription-id>", cred, nil)
	poller, err := client.BeginUpdate(ctx,
		"<resource-group-name>",
		"<account-name>",
		"<pool-name>",
		"<volume-name>",
		"<backup-name>",
		&armnetapp.BackupsBeginUpdateOptions{Body: &armnetapp.BackupPatch{}})
	if err != nil {
		log.Fatal(err)
	}
	res, err := poller.PollUntilDone(ctx, 30*time.Second)
	if err != nil {
		log.Fatal(err)
	}
	log.Printf("Backup.ID: %s\n", *res.ID)
}

Output:

func (*BackupsClient) Get 

func (client *BackupsClient) Get(ctx context.Context, resourceGroupName string, accountName string, poolName string, volumeName string, backupName string, options *BackupsGetOptions) (BackupsGetResponse, error)

Get - Gets the specified backup of the volume If the operation fails it returns a generic error.

Example

x-ms-original-file: specification/netapp/resource-manager/Microsoft.NetApp/stable/2021-08-01/examples/Backups_Get.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/netapp/armnetapp"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client := armnetapp.NewBackupsClient("<subscription-id>", cred, nil)
	res, err := client.Get(ctx,
		"<resource-group-name>",
		"<account-name>",
		"<pool-name>",
		"<volume-name>",
		"<backup-name>",
		nil)
	if err != nil {
		log.Fatal(err)
	}
	log.Printf("Backup.ID: %s\n", *res.ID)
}

Output:

func (*BackupsClient) GetStatus 

func (client *BackupsClient) GetStatus(ctx context.Context, resourceGroupName string, accountName string, poolName string, volumeName string, options *BackupsGetStatusOptions) (BackupsGetStatusResponse, error)

GetStatus - Get the status of the backup for a volume If the operation fails it returns a generic error.

Example

x-ms-original-file: specification/netapp/resource-manager/Microsoft.NetApp/stable/2021-08-01/examples/Volumes_BackupStatus.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/netapp/armnetapp"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client := armnetapp.NewBackupsClient("<subscription-id>", cred, nil)
	_, err = client.GetStatus(ctx,
		"<resource-group-name>",
		"<account-name>",
		"<pool-name>",
		"<volume-name>",
		nil)
	if err != nil {
		log.Fatal(err)
	}
}

Output:

func (*BackupsClient) GetVolumeRestoreStatus 

func (client *BackupsClient) GetVolumeRestoreStatus(ctx context.Context, resourceGroupName string, accountName string, poolName string, volumeName string, options *BackupsGetVolumeRestoreStatusOptions) (BackupsGetVolumeRestoreStatusResponse, error)

GetVolumeRestoreStatus - Get the status of the restore for a volume If the operation fails it returns a generic error.

Example

x-ms-original-file: specification/netapp/resource-manager/Microsoft.NetApp/stable/2021-08-01/examples/Volumes_RestoreStatus.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/netapp/armnetapp"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client := armnetapp.NewBackupsClient("<subscription-id>", cred, nil)
	_, err = client.GetVolumeRestoreStatus(ctx,
		"<resource-group-name>",
		"<account-name>",
		"<pool-name>",
		"<volume-name>",
		nil)
	if err != nil {
		log.Fatal(err)
	}
}

Output:

func (*BackupsClient) List 

func (client *BackupsClient) List(ctx context.Context, resourceGroupName string, accountName string, poolName string, volumeName string, options *BackupsListOptions) (BackupsListResponse, error)

List - List all backups for a volume If the operation fails it returns a generic error.

Example

x-ms-original-file: specification/netapp/resource-manager/Microsoft.NetApp/stable/2021-08-01/examples/Backups_List.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/netapp/armnetapp"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client := armnetapp.NewBackupsClient("<subscription-id>", cred, nil)
	_, err = client.List(ctx,
		"<resource-group-name>",
		"<account-name>",
		"<pool-name>",
		"<volume-name>",
		nil)
	if err != nil {
		log.Fatal(err)
	}
}

Output:

type BackupsCreatePoller 

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

BackupsCreatePoller provides polling facilities until the operation reaches a terminal state.

func (*BackupsCreatePoller) Done 

func (p *BackupsCreatePoller) Done() bool

Done returns true if the LRO has reached a terminal state.

func (*BackupsCreatePoller) FinalResponse 

func (p *BackupsCreatePoller) FinalResponse(ctx context.Context) (BackupsCreateResponse, error)

FinalResponse performs a final GET to the service and returns the final response for the polling operation. If there is an error performing the final GET then an error is returned. If the final GET succeeded then the final BackupsCreateResponse will be returned.

func (*BackupsCreatePoller) Poll 

func (p *BackupsCreatePoller) Poll(ctx context.Context) (*http.Response, error)

Poll fetches the latest state of the LRO. It returns an HTTP response or error. If the LRO has completed successfully, the poller's state is updated and the HTTP response is returned. If the LRO has completed with failure or was cancelled, the poller's state is updated and the error is returned. If the LRO has not reached a terminal state, the poller's state is updated and the latest HTTP response is returned. If Poll fails, the poller's state is unmodified and the error is returned. Calling Poll on an LRO that has reached a terminal state will return the final HTTP response or error.

func (*BackupsCreatePoller) ResumeToken 

func (p *BackupsCreatePoller) ResumeToken() (string, error)

ResumeToken returns a value representing the poller that can be used to resume the LRO at a later time. ResumeTokens are unique per service operation.

type BackupsCreatePollerResponse 

type BackupsCreatePollerResponse struct {
	// Poller contains an initialized poller.
	Poller *BackupsCreatePoller

	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

BackupsCreatePollerResponse contains the response from method Backups.Create.

func (BackupsCreatePollerResponse) PollUntilDone 

func (l BackupsCreatePollerResponse) PollUntilDone(ctx context.Context, freq time.Duration) (BackupsCreateResponse, error)

PollUntilDone will poll the service endpoint until a terminal state is reached or an error is received. freq: the time to wait between intervals in absence of a Retry-After header. Allowed minimum is one second. A good starting value is 30 seconds. Note that some resources might benefit from a different value.

func (*BackupsCreatePollerResponse) Resume 

func (l *BackupsCreatePollerResponse) Resume(ctx context.Context, client *BackupsClient, token string) error

Resume rehydrates a BackupsCreatePollerResponse from the provided client and resume token.

type BackupsCreateResponse 

type BackupsCreateResponse struct {
	BackupsCreateResult
	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

BackupsCreateResponse contains the response from method Backups.Create.

type BackupsCreateResult 

type BackupsCreateResult struct {
	Backup
}

BackupsCreateResult contains the result from method Backups.Create.

type BackupsDeletePoller 

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

BackupsDeletePoller provides polling facilities until the operation reaches a terminal state.

func (*BackupsDeletePoller) Done 

func (p *BackupsDeletePoller) Done() bool

Done returns true if the LRO has reached a terminal state.

func (*BackupsDeletePoller) FinalResponse 

func (p *BackupsDeletePoller) FinalResponse(ctx context.Context) (BackupsDeleteResponse, error)

FinalResponse performs a final GET to the service and returns the final response for the polling operation. If there is an error performing the final GET then an error is returned. If the final GET succeeded then the final BackupsDeleteResponse will be returned.

func (*BackupsDeletePoller) Poll 

func (p *BackupsDeletePoller) Poll(ctx context.Context) (*http.Response, error)

Poll fetches the latest state of the LRO. It returns an HTTP response or error. If the LRO has completed successfully, the poller's state is updated and the HTTP response is returned. If the LRO has completed with failure or was cancelled, the poller's state is updated and the error is returned. If the LRO has not reached a terminal state, the poller's state is updated and the latest HTTP response is returned. If Poll fails, the poller's state is unmodified and the error is returned. Calling Poll on an LRO that has reached a terminal state will return the final HTTP response or error.

func (*BackupsDeletePoller) ResumeToken 

func (p *BackupsDeletePoller) ResumeToken() (string, error)

ResumeToken returns a value representing the poller that can be used to resume the LRO at a later time. ResumeTokens are unique per service operation.

type BackupsDeletePollerResponse 

type BackupsDeletePollerResponse struct {
	// Poller contains an initialized poller.
	Poller *BackupsDeletePoller

	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

BackupsDeletePollerResponse contains the response from method Backups.Delete.

func (BackupsDeletePollerResponse) PollUntilDone 

func (l BackupsDeletePollerResponse) PollUntilDone(ctx context.Context, freq time.Duration) (BackupsDeleteResponse, error)

PollUntilDone will poll the service endpoint until a terminal state is reached or an error is received. freq: the time to wait between intervals in absence of a Retry-After header. Allowed minimum is one second. A good starting value is 30 seconds. Note that some resources might benefit from a different value.

func (*BackupsDeletePollerResponse) Resume 

func (l *BackupsDeletePollerResponse) Resume(ctx context.Context, client *BackupsClient, token string) error

Resume rehydrates a BackupsDeletePollerResponse from the provided client and resume token.

type BackupsDeleteResponse 

type BackupsDeleteResponse struct {
	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

BackupsDeleteResponse contains the response from method Backups.Delete.

type BackupsGetOptions 

type BackupsGetOptions struct {
}

BackupsGetOptions contains the optional parameters for the Backups.Get method.

type BackupsGetResponse 

type BackupsGetResponse struct {
	BackupsGetResult
	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

BackupsGetResponse contains the response from method Backups.Get.

type BackupsGetResult 

type BackupsGetResult struct {
	Backup
}

BackupsGetResult contains the result from method Backups.Get.

type BackupsGetStatusOptions 

type BackupsGetStatusOptions struct {
}

BackupsGetStatusOptions contains the optional parameters for the Backups.GetStatus method.

type BackupsGetStatusResponse 

type BackupsGetStatusResponse struct {
	BackupsGetStatusResult
	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

BackupsGetStatusResponse contains the response from method Backups.GetStatus.

type BackupsGetStatusResult 

type BackupsGetStatusResult struct {
	BackupStatus
}

BackupsGetStatusResult contains the result from method Backups.GetStatus.

type BackupsGetVolumeRestoreStatusOptions 

type BackupsGetVolumeRestoreStatusOptions struct {
}

BackupsGetVolumeRestoreStatusOptions contains the optional parameters for the Backups.GetVolumeRestoreStatus method.

type BackupsGetVolumeRestoreStatusResponse 

type BackupsGetVolumeRestoreStatusResponse struct {
	BackupsGetVolumeRestoreStatusResult
	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

BackupsGetVolumeRestoreStatusResponse contains the response from method Backups.GetVolumeRestoreStatus.

type BackupsGetVolumeRestoreStatusResult 

type BackupsGetVolumeRestoreStatusResult struct {
	RestoreStatus
}

BackupsGetVolumeRestoreStatusResult contains the result from method Backups.GetVolumeRestoreStatus.

type BackupsList 

type BackupsList struct {
	// A list of Backups
	Value []*Backup `json:"value,omitempty"`
}

BackupsList - List of Backups

func (BackupsList) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type BackupsList.

type BackupsListOptions 

type BackupsListOptions struct {
}

BackupsListOptions contains the optional parameters for the Backups.List method.

type BackupsListResponse 

type BackupsListResponse struct {
	BackupsListResult
	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

BackupsListResponse contains the response from method Backups.List.

type BackupsListResult 

type BackupsListResult struct {
	BackupsList
}

BackupsListResult contains the result from method Backups.List.

type BackupsUpdatePoller 

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

BackupsUpdatePoller provides polling facilities until the operation reaches a terminal state.

func (*BackupsUpdatePoller) Done 

func (p *BackupsUpdatePoller) Done() bool

Done returns true if the LRO has reached a terminal state.

func (*BackupsUpdatePoller) FinalResponse 

func (p *BackupsUpdatePoller) FinalResponse(ctx context.Context) (BackupsUpdateResponse, error)

FinalResponse performs a final GET to the service and returns the final response for the polling operation. If there is an error performing the final GET then an error is returned. If the final GET succeeded then the final BackupsUpdateResponse will be returned.

func (*BackupsUpdatePoller) Poll 

func (p *BackupsUpdatePoller) Poll(ctx context.Context) (*http.Response, error)

Poll fetches the latest state of the LRO. It returns an HTTP response or error. If the LRO has completed successfully, the poller's state is updated and the HTTP response is returned. If the LRO has completed with failure or was cancelled, the poller's state is updated and the error is returned. If the LRO has not reached a terminal state, the poller's state is updated and the latest HTTP response is returned. If Poll fails, the poller's state is unmodified and the error is returned. Calling Poll on an LRO that has reached a terminal state will return the final HTTP response or error.

func (*BackupsUpdatePoller) ResumeToken 

func (p *BackupsUpdatePoller) ResumeToken() (string, error)

ResumeToken returns a value representing the poller that can be used to resume the LRO at a later time. ResumeTokens are unique per service operation.

type BackupsUpdatePollerResponse 

type BackupsUpdatePollerResponse struct {
	// Poller contains an initialized poller.
	Poller *BackupsUpdatePoller

	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

BackupsUpdatePollerResponse contains the response from method Backups.Update.

func (BackupsUpdatePollerResponse) PollUntilDone 

func (l BackupsUpdatePollerResponse) PollUntilDone(ctx context.Context, freq time.Duration) (BackupsUpdateResponse, error)

PollUntilDone will poll the service endpoint until a terminal state is reached or an error is received. freq: the time to wait between intervals in absence of a Retry-After header. Allowed minimum is one second. A good starting value is 30 seconds. Note that some resources might benefit from a different value.

func (*BackupsUpdatePollerResponse) Resume 

func (l *BackupsUpdatePollerResponse) Resume(ctx context.Context, client *BackupsClient, token string) error

Resume rehydrates a BackupsUpdatePollerResponse from the provided client and resume token.

type BackupsUpdateResponse 

type BackupsUpdateResponse struct {
	BackupsUpdateResult
	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

BackupsUpdateResponse contains the response from method Backups.Update.

type BackupsUpdateResult 

type BackupsUpdateResult struct {
	Backup
}

BackupsUpdateResult contains the result from method Backups.Update.

type BreakReplicationRequest 

type BreakReplicationRequest struct {
	// If replication is in status transferring and you want to force break the replication, set to true
	ForceBreakReplication *bool `json:"forceBreakReplication,omitempty"`
}

BreakReplicationRequest - Break replication request

type CapacityPool 

type CapacityPool struct {
	// REQUIRED; Resource location
	Location *string `json:"location,omitempty"`

	// REQUIRED; Capacity pool properties
	Properties *PoolProperties `json:"properties,omitempty"`

	// Resource tags
	Tags map[string]*string `json:"tags,omitempty"`

	// READ-ONLY; A unique read-only string that changes whenever the resource is updated.
	Etag *string `json:"etag,omitempty" azure:"ro"`

	// READ-ONLY; Resource Id
	ID *string `json:"id,omitempty" azure:"ro"`

	// READ-ONLY; Resource name
	Name *string `json:"name,omitempty" azure:"ro"`

	// READ-ONLY; Resource type
	Type *string `json:"type,omitempty" azure:"ro"`
}

CapacityPool - Capacity pool resource

func (CapacityPool) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type CapacityPool.

type CapacityPoolList 

type CapacityPoolList struct {
	// URL to get the next set of results.
	NextLink *string `json:"nextLink,omitempty"`

	// List of Capacity pools
	Value []*CapacityPool `json:"value,omitempty"`
}

CapacityPoolList - List of capacity pool resources

func (CapacityPoolList) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type CapacityPoolList.

type CapacityPoolPatch 

type CapacityPoolPatch struct {
	// Resource location
	Location *string `json:"location,omitempty"`

	// Capacity pool properties
	Properties *PoolPatchProperties `json:"properties,omitempty"`

	// Resource tags
	Tags map[string]*string `json:"tags,omitempty"`

	// READ-ONLY; Resource Id
	ID *string `json:"id,omitempty" azure:"ro"`

	// READ-ONLY; Resource name
	Name *string `json:"name,omitempty" azure:"ro"`

	// READ-ONLY; Resource type
	Type *string `json:"type,omitempty" azure:"ro"`
}

CapacityPoolPatch - Capacity pool patch resource

func (CapacityPoolPatch) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type CapacityPoolPatch.

type CheckAvailabilityResponse 

type CheckAvailabilityResponse struct {
	// true indicates name is valid and available. false indicates the name is invalid, unavailable, or both.
	IsAvailable *bool `json:"isAvailable,omitempty"`

	// If reason == invalid, provide the user with the reason why the given name is invalid, and provide the resource naming requirements so that the user can
	// select a valid name. If reason == AlreadyExists,
	// explain that resource name is already in use, and direct them to select a different name.
	Message *string `json:"message,omitempty"`

	// Invalid indicates the name provided does not match Azure App Service naming requirements. AlreadyExists indicates that the name is already in use and
	// is therefore unavailable.
	Reason *InAvailabilityReasonType `json:"reason,omitempty"`
}

CheckAvailabilityResponse - Information regarding availability of a resource.

type CheckNameResourceTypes 

type CheckNameResourceTypes string

CheckNameResourceTypes - Resource type used for verification. 

const (
	CheckNameResourceTypesMicrosoftNetAppNetAppAccounts                              CheckNameResourceTypes = "Microsoft.NetApp/netAppAccounts"
	CheckNameResourceTypesMicrosoftNetAppNetAppAccountsCapacityPools                 CheckNameResourceTypes = "Microsoft.NetApp/netAppAccounts/capacityPools"
	CheckNameResourceTypesMicrosoftNetAppNetAppAccountsCapacityPoolsVolumes          CheckNameResourceTypes = "Microsoft.NetApp/netAppAccounts/capacityPools/volumes"
	CheckNameResourceTypesMicrosoftNetAppNetAppAccountsCapacityPoolsVolumesSnapshots CheckNameResourceTypes = "Microsoft.NetApp/netAppAccounts/capacityPools/volumes/snapshots"
)

func PossibleCheckNameResourceTypesValues 

func PossibleCheckNameResourceTypesValues() []CheckNameResourceTypes

PossibleCheckNameResourceTypesValues returns the possible values for the CheckNameResourceTypes const type.

func (CheckNameResourceTypes) ToPtr 

func (c CheckNameResourceTypes) ToPtr() *CheckNameResourceTypes

ToPtr returns a *CheckNameResourceTypes pointing to the current value.

type CheckQuotaNameResourceTypes 

type CheckQuotaNameResourceTypes string

CheckQuotaNameResourceTypes - Resource type used for verification. 

const (
	CheckQuotaNameResourceTypesMicrosoftNetAppNetAppAccounts                              CheckQuotaNameResourceTypes = "Microsoft.NetApp/netAppAccounts"
	CheckQuotaNameResourceTypesMicrosoftNetAppNetAppAccountsCapacityPools                 CheckQuotaNameResourceTypes = "Microsoft.NetApp/netAppAccounts/capacityPools"
	CheckQuotaNameResourceTypesMicrosoftNetAppNetAppAccountsCapacityPoolsVolumes          CheckQuotaNameResourceTypes = "Microsoft.NetApp/netAppAccounts/capacityPools/volumes"
	CheckQuotaNameResourceTypesMicrosoftNetAppNetAppAccountsCapacityPoolsVolumesSnapshots CheckQuotaNameResourceTypes = "Microsoft.NetApp/netAppAccounts/capacityPools/volumes/snapshots"
)

func PossibleCheckQuotaNameResourceTypesValues 

func PossibleCheckQuotaNameResourceTypesValues() []CheckQuotaNameResourceTypes

PossibleCheckQuotaNameResourceTypesValues returns the possible values for the CheckQuotaNameResourceTypes const type.

func (CheckQuotaNameResourceTypes) ToPtr 

func (c CheckQuotaNameResourceTypes) ToPtr() *CheckQuotaNameResourceTypes

ToPtr returns a *CheckQuotaNameResourceTypes pointing to the current value.

type ChownMode 

type ChownMode string

ChownMode - This parameter specifies who is authorized to change the ownership of a file. restricted - Only root user can change the ownership of the file. unrestricted - Non-root users can change ownership of files that they own. 

const (
	ChownModeRestricted   ChownMode = "Restricted"
	ChownModeUnrestricted ChownMode = "Unrestricted"
)

func PossibleChownModeValues 

func PossibleChownModeValues() []ChownMode

PossibleChownModeValues returns the possible values for the ChownMode const type.

func (ChownMode) ToPtr 

func (c ChownMode) ToPtr() *ChownMode

ToPtr returns a *ChownMode pointing to the current value.

type CloudError 

type CloudError struct {

	// Cloud error body.
	InnerError *CloudErrorBody `json:"error,omitempty"`
	// contains filtered or unexported fields
}

CloudError - An error response from the service. Implements the error and azcore.HTTPResponse interfaces.

func (CloudError) Error 

func (e CloudError) Error() string

Error implements the error interface for type CloudError. The contents of the error text are not contractual and subject to change.

type CloudErrorBody 

type CloudErrorBody struct {
	// An identifier for the error. Codes are invariant and are intended to be consumed programmatically.
	Code *string `json:"code,omitempty"`

	// A message describing the error, intended to be suitable for display in a user interface.
	Message *string `json:"message,omitempty"`
}

CloudErrorBody - An error response from the service.

type CreatedByType 

type CreatedByType string

CreatedByType - The type of identity that created the resource. 

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

func PossibleCreatedByTypeValues 

func PossibleCreatedByTypeValues() []CreatedByType

PossibleCreatedByTypeValues returns the possible values for the CreatedByType const type.

func (CreatedByType) ToPtr 

func (c CreatedByType) ToPtr() *CreatedByType

ToPtr returns a *CreatedByType pointing to the current value.

type DailySchedule 

type DailySchedule struct {
	// Indicates which hour in UTC timezone a snapshot should be taken
	Hour *int32 `json:"hour,omitempty"`

	// Indicates which minute snapshot should be taken
	Minute *int32 `json:"minute,omitempty"`

	// Daily snapshot count to keep
	SnapshotsToKeep *int32 `json:"snapshotsToKeep,omitempty"`

	// Resource size in bytes, current storage usage for the volume in bytes
	UsedBytes *int64 `json:"usedBytes,omitempty"`
}

DailySchedule - Daily Schedule properties

type Dimension 

type Dimension struct {
	// Display name of dimension.
	DisplayName *string `json:"displayName,omitempty"`

	// Display name of dimension.
	Name *string `json:"name,omitempty"`
}

Dimension of blobs, possibly be blob type or access tier.

type EncryptionType 

type EncryptionType string

EncryptionType - Encryption type of the capacity pool, set encryption type for data at rest for this pool and all volumes in it. This value can only be set when creating new pool. 

const (
	// EncryptionTypeDouble - EncryptionType Double, volumes will use double encryption at rest
	EncryptionTypeDouble EncryptionType = "Double"
	// EncryptionTypeSingle - EncryptionType Single, volumes will use single encryption at rest
	EncryptionTypeSingle EncryptionType = "Single"
)

func PossibleEncryptionTypeValues 

func PossibleEncryptionTypeValues() []EncryptionType

PossibleEncryptionTypeValues returns the possible values for the EncryptionType const type.

func (EncryptionType) ToPtr 

func (c EncryptionType) ToPtr() *EncryptionType

ToPtr returns a *EncryptionType pointing to the current value.

type EndpointType 

type EndpointType string

EndpointType - Indicates whether the local volume is the source or destination for the Volume Replication 

const (
	EndpointTypeDst EndpointType = "dst"
	EndpointTypeSrc EndpointType = "src"
)

func PossibleEndpointTypeValues 

func PossibleEndpointTypeValues() []EndpointType

PossibleEndpointTypeValues returns the possible values for the EndpointType const type.

func (EndpointType) ToPtr 

func (c EndpointType) ToPtr() *EndpointType

ToPtr returns a *EndpointType pointing to the current value.

type ExportPolicyRule 

type ExportPolicyRule struct {
	// Client ingress specification as comma separated string with IPv4 CIDRs, IPv4 host addresses and host names
	AllowedClients *string `json:"allowedClients,omitempty"`

	// This parameter specifies who is authorized to change the ownership of a file. restricted - Only root user can change the ownership of the file. unrestricted
	// - Non-root users can change ownership of
	// files that they own.
	ChownMode *ChownMode `json:"chownMode,omitempty"`

	// Allows CIFS protocol
	Cifs *bool `json:"cifs,omitempty"`

	// Has root access to volume
	HasRootAccess *bool `json:"hasRootAccess,omitempty"`

	// Kerberos5i Read only access. To be use with swagger version 2020-05-01 or later
	Kerberos5IReadOnly *bool `json:"kerberos5iReadOnly,omitempty"`

	// Kerberos5i Read and write access. To be use with swagger version 2020-05-01 or later
	Kerberos5IReadWrite *bool `json:"kerberos5iReadWrite,omitempty"`

	// Kerberos5p Read only access. To be use with swagger version 2020-05-01 or later
	Kerberos5PReadOnly *bool `json:"kerberos5pReadOnly,omitempty"`

	// Kerberos5p Read and write access. To be use with swagger version 2020-05-01 or later
	Kerberos5PReadWrite *bool `json:"kerberos5pReadWrite,omitempty"`

	// Kerberos5 Read only access. To be use with swagger version 2020-05-01 or later
	Kerberos5ReadOnly *bool `json:"kerberos5ReadOnly,omitempty"`

	// Kerberos5 Read and write access. To be use with swagger version 2020-05-01 or later
	Kerberos5ReadWrite *bool `json:"kerberos5ReadWrite,omitempty"`

	// Allows NFSv3 protocol. Enable only for NFSv3 type volumes
	Nfsv3 *bool `json:"nfsv3,omitempty"`

	// Allows NFSv4.1 protocol. Enable only for NFSv4.1 type volumes
	Nfsv41 *bool `json:"nfsv41,omitempty"`

	// Order index
	RuleIndex *int32 `json:"ruleIndex,omitempty"`

	// Read only access
	UnixReadOnly *bool `json:"unixReadOnly,omitempty"`

	// Read and write access
	UnixReadWrite *bool `json:"unixReadWrite,omitempty"`
}

ExportPolicyRule - Volume Export Policy Rule

type FilePathAvailabilityRequest 

type FilePathAvailabilityRequest struct {
	// REQUIRED; File path to verify.
	Name *string `json:"name,omitempty"`

	// REQUIRED; The Azure Resource URI for a delegated subnet. Must have the delegation Microsoft.NetApp/volumes
	SubnetID *string `json:"subnetId,omitempty"`
}

FilePathAvailabilityRequest - File path availability request content - availability is based on the name and the subnetId.

type HourlySchedule 

type HourlySchedule struct {
	// Indicates which minute snapshot should be taken
	Minute *int32 `json:"minute,omitempty"`

	// Hourly snapshot count to keep
	SnapshotsToKeep *int32 `json:"snapshotsToKeep,omitempty"`

	// Resource size in bytes, current storage usage for the volume in bytes
	UsedBytes *int64 `json:"usedBytes,omitempty"`
}

HourlySchedule - Hourly Schedule properties

type InAvailabilityReasonType 

type InAvailabilityReasonType string

InAvailabilityReasonType - Invalid indicates the name provided does not match Azure App Service naming requirements. AlreadyExists indicates that the name is already in use and is therefore unavailable. 

const (
	InAvailabilityReasonTypeAlreadyExists InAvailabilityReasonType = "AlreadyExists"
	InAvailabilityReasonTypeInvalid       InAvailabilityReasonType = "Invalid"
)

func PossibleInAvailabilityReasonTypeValues 

func PossibleInAvailabilityReasonTypeValues() []InAvailabilityReasonType

PossibleInAvailabilityReasonTypeValues returns the possible values for the InAvailabilityReasonType const type.

func (InAvailabilityReasonType) ToPtr 

func (c InAvailabilityReasonType) ToPtr() *InAvailabilityReasonType

ToPtr returns a *InAvailabilityReasonType pointing to the current value.

type LogSpecification 

type LogSpecification struct {
	// Display name of log specification.
	DisplayName *string `json:"displayName,omitempty"`

	// Name of log specification.
	Name *string `json:"name,omitempty"`
}

LogSpecification - Log Definition of a single resource metric.

type MetricAggregationType 

type MetricAggregationType string
const (
	MetricAggregationTypeAverage MetricAggregationType = "Average"
)

func PossibleMetricAggregationTypeValues 

func PossibleMetricAggregationTypeValues() []MetricAggregationType

PossibleMetricAggregationTypeValues returns the possible values for the MetricAggregationType const type.

func (MetricAggregationType) ToPtr 

func (c MetricAggregationType) ToPtr() *MetricAggregationType

ToPtr returns a *MetricAggregationType pointing to the current value.

type MetricSpecification 

type MetricSpecification struct {
	// Aggregation type could be Average.
	AggregationType *string `json:"aggregationType,omitempty"`

	// The category this metric specification belong to, could be Capacity.
	Category *string `json:"category,omitempty"`

	// Dimensions of blobs, including blob type and access tier.
	Dimensions []*Dimension `json:"dimensions,omitempty"`

	// Display description of metric specification.
	DisplayDescription *string `json:"displayDescription,omitempty"`

	// Display name of metric specification.
	DisplayName *string `json:"displayName,omitempty"`

	// Whether or not the service is using regional MDM accounts.
	EnableRegionalMdmAccount *bool `json:"enableRegionalMdmAccount,omitempty"`

	// The property to decide fill gap with zero or not.
	FillGapWithZero *bool `json:"fillGapWithZero,omitempty"`

	// The internal metric name.
	InternalMetricName *string `json:"internalMetricName,omitempty"`

	// Whether the metric is internal.
	IsInternal *bool `json:"isInternal,omitempty"`

	// Name of metric specification.
	Name *string `json:"name,omitempty"`

	// Account Resource Id.
	ResourceIDDimensionNameOverride *string `json:"resourceIdDimensionNameOverride,omitempty"`

	// The source MDM account.
	SourceMdmAccount *string `json:"sourceMdmAccount,omitempty"`

	// The source MDM namespace.
	SourceMdmNamespace *string `json:"sourceMdmNamespace,omitempty"`

	// Support metric aggregation type.
	SupportedAggregationTypes []*MetricAggregationType `json:"supportedAggregationTypes,omitempty"`

	// The supported time grain types for the metrics.
	SupportedTimeGrainTypes []*string `json:"supportedTimeGrainTypes,omitempty"`

	// Unit could be Bytes or Count.
	Unit *string `json:"unit,omitempty"`
}

MetricSpecification - Metric specification of operation.

func (MetricSpecification) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type MetricSpecification.

type MirrorState 

type MirrorState string

MirrorState - The status of the replication 

const (
	MirrorStateBroken        MirrorState = "Broken"
	MirrorStateMirrored      MirrorState = "Mirrored"
	MirrorStateUninitialized MirrorState = "Uninitialized"
)

func PossibleMirrorStateValues 

func PossibleMirrorStateValues() []MirrorState

PossibleMirrorStateValues returns the possible values for the MirrorState const type.

func (MirrorState) ToPtr 

func (c MirrorState) ToPtr() *MirrorState

ToPtr returns a *MirrorState pointing to the current value.

type MonthlySchedule 

type MonthlySchedule struct {
	// Indicates which days of the month snapshot should be taken. A comma delimited string.
	DaysOfMonth *string `json:"daysOfMonth,omitempty"`

	// Indicates which hour in UTC timezone a snapshot should be taken
	Hour *int32 `json:"hour,omitempty"`

	// Indicates which minute snapshot should be taken
	Minute *int32 `json:"minute,omitempty"`

	// Monthly snapshot count to keep
	SnapshotsToKeep *int32 `json:"snapshotsToKeep,omitempty"`

	// Resource size in bytes, current storage usage for the volume in bytes
	UsedBytes *int64 `json:"usedBytes,omitempty"`
}

MonthlySchedule - Monthly Schedule properties

type MountTarget 

type MountTarget struct {
	// REQUIRED; Resource location
	Location *string `json:"location,omitempty"`

	// REQUIRED; Mount Target Properties
	Properties *MountTargetProperties `json:"properties,omitempty"`

	// Resource tags
	Tags map[string]*string `json:"tags,omitempty"`

	// READ-ONLY; Resource Id
	ID *string `json:"id,omitempty" azure:"ro"`

	// READ-ONLY; Resource name
	Name *string `json:"name,omitempty" azure:"ro"`

	// READ-ONLY; Resource type
	Type *string `json:"type,omitempty" azure:"ro"`
}

MountTarget - Mount Target

func (MountTarget) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type MountTarget.

type MountTargetProperties 

type MountTargetProperties struct {
	// REQUIRED; UUID v4 used to identify the MountTarget
	FileSystemID *string `json:"fileSystemId,omitempty"`

	// The SMB server's Fully Qualified Domain Name, FQDN
	SmbServerFqdn *string `json:"smbServerFqdn,omitempty"`

	// READ-ONLY; The mount target's IPv4 address
	IPAddress *string `json:"ipAddress,omitempty" azure:"ro"`

	// READ-ONLY; UUID v4 used to identify the MountTarget
	MountTargetID *string `json:"mountTargetId,omitempty" azure:"ro"`
}

MountTargetProperties - Mount target properties

type NetAppAccount 

type NetAppAccount struct {
	// REQUIRED; Resource location
	Location *string `json:"location,omitempty"`

	// NetApp Account properties
	Properties *AccountProperties `json:"properties,omitempty"`

	// Resource tags
	Tags map[string]*string `json:"tags,omitempty"`

	// READ-ONLY; A unique read-only string that changes whenever the resource is updated.
	Etag *string `json:"etag,omitempty" azure:"ro"`

	// READ-ONLY; Resource Id
	ID *string `json:"id,omitempty" azure:"ro"`

	// READ-ONLY; Resource name
	Name *string `json:"name,omitempty" azure:"ro"`

	// READ-ONLY; The system meta data relating to this resource.
	SystemData *SystemData `json:"systemData,omitempty" azure:"ro"`

	// READ-ONLY; Resource type
	Type *string `json:"type,omitempty" azure:"ro"`
}

NetAppAccount - NetApp account resource

func (NetAppAccount) MarshalJSON 

func (n NetAppAccount) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type NetAppAccount.

type NetAppAccountList 

type NetAppAccountList struct {
	// URL to get the next set of results.
	NextLink *string `json:"nextLink,omitempty"`

	// Multiple NetApp accounts
	Value []*NetAppAccount `json:"value,omitempty"`
}

NetAppAccountList - List of NetApp account resources

func (NetAppAccountList) MarshalJSON 

func (n NetAppAccountList) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type NetAppAccountList.

type NetAppAccountPatch 

type NetAppAccountPatch struct {
	// Resource location
	Location *string `json:"location,omitempty"`

	// NetApp Account properties
	Properties *AccountProperties `json:"properties,omitempty"`

	// Resource tags
	Tags map[string]*string `json:"tags,omitempty"`

	// READ-ONLY; Resource Id
	ID *string `json:"id,omitempty" azure:"ro"`

	// READ-ONLY; Resource name
	Name *string `json:"name,omitempty" azure:"ro"`

	// READ-ONLY; Resource type
	Type *string `json:"type,omitempty" azure:"ro"`
}

NetAppAccountPatch - NetApp account patch resource

func (NetAppAccountPatch) MarshalJSON 

func (n NetAppAccountPatch) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type NetAppAccountPatch.

type NetAppResourceCheckFilePathAvailabilityOptions 

type NetAppResourceCheckFilePathAvailabilityOptions struct {
}

NetAppResourceCheckFilePathAvailabilityOptions contains the optional parameters for the NetAppResource.CheckFilePathAvailability method.

type NetAppResourceCheckFilePathAvailabilityResponse 

type NetAppResourceCheckFilePathAvailabilityResponse struct {
	NetAppResourceCheckFilePathAvailabilityResult
	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

NetAppResourceCheckFilePathAvailabilityResponse contains the response from method NetAppResource.CheckFilePathAvailability.

type NetAppResourceCheckFilePathAvailabilityResult 

type NetAppResourceCheckFilePathAvailabilityResult struct {
	CheckAvailabilityResponse
}

NetAppResourceCheckFilePathAvailabilityResult contains the result from method NetAppResource.CheckFilePathAvailability.

type NetAppResourceCheckNameAvailabilityOptions 

type NetAppResourceCheckNameAvailabilityOptions struct {
}

NetAppResourceCheckNameAvailabilityOptions contains the optional parameters for the NetAppResource.CheckNameAvailability method.

type NetAppResourceCheckNameAvailabilityResponse 

type NetAppResourceCheckNameAvailabilityResponse struct {
	NetAppResourceCheckNameAvailabilityResult
	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

NetAppResourceCheckNameAvailabilityResponse contains the response from method NetAppResource.CheckNameAvailability.

type NetAppResourceCheckNameAvailabilityResult 

type NetAppResourceCheckNameAvailabilityResult struct {
	CheckAvailabilityResponse
}

NetAppResourceCheckNameAvailabilityResult contains the result from method NetAppResource.CheckNameAvailability.

type NetAppResourceCheckQuotaAvailabilityOptions 

type NetAppResourceCheckQuotaAvailabilityOptions struct {
}

NetAppResourceCheckQuotaAvailabilityOptions contains the optional parameters for the NetAppResource.CheckQuotaAvailability method.

type NetAppResourceCheckQuotaAvailabilityResponse 

type NetAppResourceCheckQuotaAvailabilityResponse struct {
	NetAppResourceCheckQuotaAvailabilityResult
	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

NetAppResourceCheckQuotaAvailabilityResponse contains the response from method NetAppResource.CheckQuotaAvailability.

type NetAppResourceCheckQuotaAvailabilityResult 

type NetAppResourceCheckQuotaAvailabilityResult struct {
	CheckAvailabilityResponse
}

NetAppResourceCheckQuotaAvailabilityResult contains the result from method NetAppResource.CheckQuotaAvailability.

type NetAppResourceClient 

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

NetAppResourceClient contains the methods for the NetAppResource group. Don't use this type directly, use NewNetAppResourceClient() instead.

func NewNetAppResourceClient 

func NewNetAppResourceClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) *NetAppResourceClient

NewNetAppResourceClient creates a new instance of NetAppResourceClient with the specified values.

func (*NetAppResourceClient) CheckFilePathAvailability 

func (client *NetAppResourceClient) CheckFilePathAvailability(ctx context.Context, location string, body FilePathAvailabilityRequest, options *NetAppResourceCheckFilePathAvailabilityOptions) (NetAppResourceCheckFilePathAvailabilityResponse, error)

CheckFilePathAvailability - Check if a file path is available. If the operation fails it returns a generic error.

Example

x-ms-original-file: specification/netapp/resource-manager/Microsoft.NetApp/stable/2021-08-01/examples/CheckFilePathAvailability.json 

package main

import (
	"context"
	"log"

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

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client := armnetapp.NewNetAppResourceClient("<subscription-id>", cred, nil)
	_, err = client.CheckFilePathAvailability(ctx,
		"<location>",
		armnetapp.FilePathAvailabilityRequest{
			Name:     to.StringPtr("<name>"),
			SubnetID: to.StringPtr("<subnet-id>"),
		},
		nil)
	if err != nil {
		log.Fatal(err)
	}
}

Output:

func (*NetAppResourceClient) CheckNameAvailability 

func (client *NetAppResourceClient) CheckNameAvailability(ctx context.Context, location string, body ResourceNameAvailabilityRequest, options *NetAppResourceCheckNameAvailabilityOptions) (NetAppResourceCheckNameAvailabilityResponse, error)

CheckNameAvailability - Check if a resource name is available. If the operation fails it returns a generic error.

Example

x-ms-original-file: specification/netapp/resource-manager/Microsoft.NetApp/stable/2021-08-01/examples/CheckNameAvailability.json 

package main

import (
	"context"
	"log"

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

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client := armnetapp.NewNetAppResourceClient("<subscription-id>", cred, nil)
	_, err = client.CheckNameAvailability(ctx,
		"<location>",
		armnetapp.ResourceNameAvailabilityRequest{
			Name:          to.StringPtr("<name>"),
			Type:          armnetapp.CheckNameResourceTypesMicrosoftNetAppNetAppAccounts.ToPtr(),
			ResourceGroup: to.StringPtr("<resource-group>"),
		},
		nil)
	if err != nil {
		log.Fatal(err)
	}
}

Output:

func (*NetAppResourceClient) CheckQuotaAvailability 

func (client *NetAppResourceClient) CheckQuotaAvailability(ctx context.Context, location string, body QuotaAvailabilityRequest, options *NetAppResourceCheckQuotaAvailabilityOptions) (NetAppResourceCheckQuotaAvailabilityResponse, error)

CheckQuotaAvailability - Check if a quota is available. If the operation fails it returns a generic error.

Example

x-ms-original-file: specification/netapp/resource-manager/Microsoft.NetApp/stable/2021-08-01/examples/CheckQuotaAvailability.json 

package main

import (
	"context"
	"log"

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

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client := armnetapp.NewNetAppResourceClient("<subscription-id>", cred, nil)
	_, err = client.CheckQuotaAvailability(ctx,
		"<location>",
		armnetapp.QuotaAvailabilityRequest{
			Name:          to.StringPtr("<name>"),
			Type:          armnetapp.CheckQuotaNameResourceTypesMicrosoftNetAppNetAppAccounts.ToPtr(),
			ResourceGroup: to.StringPtr("<resource-group>"),
		},
		nil)
	if err != nil {
		log.Fatal(err)
	}
}

Output:

type NetAppResourceQuotaLimitsClient 

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

NetAppResourceQuotaLimitsClient contains the methods for the NetAppResourceQuotaLimits group. Don't use this type directly, use NewNetAppResourceQuotaLimitsClient() instead.

func NewNetAppResourceQuotaLimitsClient 

func NewNetAppResourceQuotaLimitsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) *NetAppResourceQuotaLimitsClient

NewNetAppResourceQuotaLimitsClient creates a new instance of NetAppResourceQuotaLimitsClient with the specified values.

func (*NetAppResourceQuotaLimitsClient) Get 

func (client *NetAppResourceQuotaLimitsClient) Get(ctx context.Context, location string, quotaLimitName string, options *NetAppResourceQuotaLimitsGetOptions) (NetAppResourceQuotaLimitsGetResponse, error)

Get - Get the default and current subscription quota limit If the operation fails it returns a generic error.

Example

x-ms-original-file: specification/netapp/resource-manager/Microsoft.NetApp/stable/2021-08-01/examples/QuotaLimits_Get.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/netapp/armnetapp"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client := armnetapp.NewNetAppResourceQuotaLimitsClient("<subscription-id>", cred, nil)
	res, err := client.Get(ctx,
		"<location>",
		"<quota-limit-name>",
		nil)
	if err != nil {
		log.Fatal(err)
	}
	log.Printf("SubscriptionQuotaItem.ID: %s\n", *res.ID)
}

Output:

func (*NetAppResourceQuotaLimitsClient) List 

func (client *NetAppResourceQuotaLimitsClient) List(ctx context.Context, location string, options *NetAppResourceQuotaLimitsListOptions) (NetAppResourceQuotaLimitsListResponse, error)

List - Get the default and current limits for quotas If the operation fails it returns a generic error.

Example

x-ms-original-file: specification/netapp/resource-manager/Microsoft.NetApp/stable/2021-08-01/examples/QuotaLimits_List.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/netapp/armnetapp"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client := armnetapp.NewNetAppResourceQuotaLimitsClient("<subscription-id>", cred, nil)
	_, err = client.List(ctx,
		"<location>",
		nil)
	if err != nil {
		log.Fatal(err)
	}
}

Output:

type NetAppResourceQuotaLimitsGetOptions 

type NetAppResourceQuotaLimitsGetOptions struct {
}

NetAppResourceQuotaLimitsGetOptions contains the optional parameters for the NetAppResourceQuotaLimits.Get method.

type NetAppResourceQuotaLimitsGetResponse 

type NetAppResourceQuotaLimitsGetResponse struct {
	NetAppResourceQuotaLimitsGetResult
	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

NetAppResourceQuotaLimitsGetResponse contains the response from method NetAppResourceQuotaLimits.Get.

type NetAppResourceQuotaLimitsGetResult 

type NetAppResourceQuotaLimitsGetResult struct {
	SubscriptionQuotaItem
}

NetAppResourceQuotaLimitsGetResult contains the result from method NetAppResourceQuotaLimits.Get.

type NetAppResourceQuotaLimitsListOptions 

type NetAppResourceQuotaLimitsListOptions struct {
}

NetAppResourceQuotaLimitsListOptions contains the optional parameters for the NetAppResourceQuotaLimits.List method.

type NetAppResourceQuotaLimitsListResponse 

type NetAppResourceQuotaLimitsListResponse struct {
	NetAppResourceQuotaLimitsListResult
	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

NetAppResourceQuotaLimitsListResponse contains the response from method NetAppResourceQuotaLimits.List.

type NetAppResourceQuotaLimitsListResult 

type NetAppResourceQuotaLimitsListResult struct {
	SubscriptionQuotaItemList
}

NetAppResourceQuotaLimitsListResult contains the result from method NetAppResourceQuotaLimits.List.

type NetworkFeatures 

type NetworkFeatures string

NetworkFeatures - Basic network, or Standard features available to the volume. 

const (
	// NetworkFeaturesBasic - Basic network feature.
	NetworkFeaturesBasic NetworkFeatures = "Basic"
	// NetworkFeaturesStandard - Standard network feature.
	NetworkFeaturesStandard NetworkFeatures = "Standard"
)

func PossibleNetworkFeaturesValues 

func PossibleNetworkFeaturesValues() []NetworkFeatures

PossibleNetworkFeaturesValues returns the possible values for the NetworkFeatures const type.

func (NetworkFeatures) ToPtr 

func (c NetworkFeatures) ToPtr() *NetworkFeatures

ToPtr returns a *NetworkFeatures pointing to the current value.

type Operation 

type Operation struct {
	// Display metadata associated with the operation.
	Display *OperationDisplay `json:"display,omitempty"`

	// Operation name: {provider}/{resource}/{operation}
	Name *string `json:"name,omitempty"`

	// The origin of operations.
	Origin *string `json:"origin,omitempty"`

	// Properties of operation, include metric specifications.
	Properties *OperationProperties `json:"properties,omitempty"`
}

Operation - Microsoft.NetApp REST API operation definition.

type OperationDisplay 

type OperationDisplay struct {
	// Operation description.
	Description *string `json:"description,omitempty"`

	// Type of operation: get, read, delete, etc.
	Operation *string `json:"operation,omitempty"`

	// Service provider: Microsoft NetApp.
	Provider *string `json:"provider,omitempty"`

	// Resource on which the operation is performed etc.
	Resource *string `json:"resource,omitempty"`
}

OperationDisplay - Display metadata associated with the operation.

type OperationListResult 

type OperationListResult struct {
	// List of Storage operations supported by the Storage resource provider.
	Value []*Operation `json:"value,omitempty"`
}

OperationListResult - Result of the request to list Cloud Volume operations. It contains a list of operations and a 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.

type OperationProperties 

type OperationProperties struct {
	// One property of operation, include metric specifications.
	ServiceSpecification *ServiceSpecification `json:"serviceSpecification,omitempty"`
}

OperationProperties - Properties of operation, include metric specifications.

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

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

func (*OperationsClient) List 

func (client *OperationsClient) List(ctx context.Context, options *OperationsListOptions) (OperationsListResponse, error)

List - Lists all of the available Microsoft.NetApp Rest API operations If the operation fails it returns a generic error.

type OperationsListOptions 

type OperationsListOptions struct {
}

OperationsListOptions contains the optional parameters for the Operations.List method.

type OperationsListResponse 

type OperationsListResponse struct {
	OperationsListResult
	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

OperationsListResponse contains the response from method Operations.List.

type OperationsListResult 

type OperationsListResult struct {
	OperationListResult
}

OperationsListResult contains the result from method Operations.List.

type PlacementKeyValuePairs 

type PlacementKeyValuePairs struct {
	// REQUIRED; Key for an application specific parameter for the placement of volumes in the volume group
	Key *string `json:"key,omitempty"`

	// REQUIRED; Value for an application specific parameter for the placement of volumes in the volume group
	Value *string `json:"value,omitempty"`
}

PlacementKeyValuePairs - Application specific parameters for the placement of volumes in the volume group

type PoolChangeRequest 

type PoolChangeRequest struct {
	// REQUIRED; Resource id of the pool to move volume to
	NewPoolResourceID *string `json:"newPoolResourceId,omitempty"`
}

PoolChangeRequest - Pool change request

type PoolPatchProperties 

type PoolPatchProperties struct {
	// The qos type of the pool
	QosType *QosType `json:"qosType,omitempty"`

	// Provisioned size of the pool (in bytes). Allowed values are in 4TiB chunks (value must be multiply of 4398046511104).
	Size *int64 `json:"size,omitempty"`
}

PoolPatchProperties - Patchable pool properties

type PoolProperties 

type PoolProperties struct {
	// REQUIRED; The service level of the file system
	ServiceLevel *ServiceLevel `json:"serviceLevel,omitempty"`

	// REQUIRED; Provisioned size of the pool (in bytes). Allowed values are in 4TiB chunks (value must be multiply of 4398046511104).
	Size *int64 `json:"size,omitempty"`

	// If enabled (true) the pool can contain cool Access enabled volumes.
	CoolAccess *bool `json:"coolAccess,omitempty"`

	// Encryption type of the capacity pool, set encryption type for data at rest for this pool and all volumes in it. This value can only be set when creating
	// new pool.
	EncryptionType *EncryptionType `json:"encryptionType,omitempty"`

	// The qos type of the pool
	QosType *QosType `json:"qosType,omitempty"`

	// READ-ONLY; UUID v4 used to identify the Pool
	PoolID *string `json:"poolId,omitempty" azure:"ro"`

	// READ-ONLY; Azure lifecycle management
	ProvisioningState *string `json:"provisioningState,omitempty" azure:"ro"`

	// READ-ONLY; Total throughput of pool in Mibps
	TotalThroughputMibps *float32 `json:"totalThroughputMibps,omitempty" azure:"ro"`

	// READ-ONLY; Utilized throughput of pool in Mibps
	UtilizedThroughputMibps *float32 `json:"utilizedThroughputMibps,omitempty" azure:"ro"`
}

PoolProperties - Pool properties

type PoolsBeginCreateOrUpdateOptions 

type PoolsBeginCreateOrUpdateOptions struct {
}

PoolsBeginCreateOrUpdateOptions contains the optional parameters for the Pools.BeginCreateOrUpdate method.

type PoolsBeginDeleteOptions 

type PoolsBeginDeleteOptions struct {
}

PoolsBeginDeleteOptions contains the optional parameters for the Pools.BeginDelete method.

type PoolsBeginUpdateOptions 

type PoolsBeginUpdateOptions struct {
}

PoolsBeginUpdateOptions contains the optional parameters for the Pools.BeginUpdate method.

type PoolsClient 

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

PoolsClient contains the methods for the Pools group. Don't use this type directly, use NewPoolsClient() instead.

func NewPoolsClient 

func NewPoolsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) *PoolsClient

NewPoolsClient creates a new instance of PoolsClient with the specified values.

func (*PoolsClient) BeginCreateOrUpdate 

func (client *PoolsClient) BeginCreateOrUpdate(ctx context.Context, resourceGroupName string, accountName string, poolName string, body CapacityPool, options *PoolsBeginCreateOrUpdateOptions) (PoolsCreateOrUpdatePollerResponse, error)

BeginCreateOrUpdate - Create or Update a capacity pool If the operation fails it returns a generic error.

Example

x-ms-original-file: specification/netapp/resource-manager/Microsoft.NetApp/stable/2021-08-01/examples/Pools_CreateOrUpdate.json 

package main

import (
	"context"
	"log"

	"time"

	"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/netapp/armnetapp"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client := armnetapp.NewPoolsClient("<subscription-id>", cred, nil)
	poller, err := client.BeginCreateOrUpdate(ctx,
		"<resource-group-name>",
		"<account-name>",
		"<pool-name>",
		armnetapp.CapacityPool{
			Location: to.StringPtr("<location>"),
			Properties: &armnetapp.PoolProperties{
				QosType:      armnetapp.QosTypeAuto.ToPtr(),
				ServiceLevel: armnetapp.ServiceLevelPremium.ToPtr(),
				Size:         to.Int64Ptr(4398046511104),
			},
		},
		nil)
	if err != nil {
		log.Fatal(err)
	}
	res, err := poller.PollUntilDone(ctx, 30*time.Second)
	if err != nil {
		log.Fatal(err)
	}
	log.Printf("CapacityPool.ID: %s\n", *res.ID)
}

Output:

func (*PoolsClient) BeginDelete 

func (client *PoolsClient) BeginDelete(ctx context.Context, resourceGroupName string, accountName string, poolName string, options *PoolsBeginDeleteOptions) (PoolsDeletePollerResponse, error)

BeginDelete - Delete the specified capacity pool If the operation fails it returns a generic error.

Example

x-ms-original-file: specification/netapp/resource-manager/Microsoft.NetApp/stable/2021-08-01/examples/Pools_Delete.json 

package main

import (
	"context"
	"log"

	"time"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/netapp/armnetapp"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client := armnetapp.NewPoolsClient("<subscription-id>", cred, nil)
	poller, err := client.BeginDelete(ctx,
		"<resource-group-name>",
		"<account-name>",
		"<pool-name>",
		nil)
	if err != nil {
		log.Fatal(err)
	}
	_, err = poller.PollUntilDone(ctx, 30*time.Second)
	if err != nil {
		log.Fatal(err)
	}
}

Output:

func (*PoolsClient) BeginUpdate 

func (client *PoolsClient) BeginUpdate(ctx context.Context, resourceGroupName string, accountName string, poolName string, body CapacityPoolPatch, options *PoolsBeginUpdateOptions) (PoolsUpdatePollerResponse, error)

BeginUpdate - Patch the specified capacity pool If the operation fails it returns a generic error.

Example

x-ms-original-file: specification/netapp/resource-manager/Microsoft.NetApp/stable/2021-08-01/examples/Pools_Update.json 

package main

import (
	"context"
	"log"

	"time"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/netapp/armnetapp"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client := armnetapp.NewPoolsClient("<subscription-id>", cred, nil)
	poller, err := client.BeginUpdate(ctx,
		"<resource-group-name>",
		"<account-name>",
		"<pool-name>",
		armnetapp.CapacityPoolPatch{},
		nil)
	if err != nil {
		log.Fatal(err)
	}
	res, err := poller.PollUntilDone(ctx, 30*time.Second)
	if err != nil {
		log.Fatal(err)
	}
	log.Printf("CapacityPool.ID: %s\n", *res.ID)
}

Output:

func (*PoolsClient) Get 

func (client *PoolsClient) Get(ctx context.Context, resourceGroupName string, accountName string, poolName string, options *PoolsGetOptions) (PoolsGetResponse, error)

Get - Get details of the specified capacity pool If the operation fails it returns a generic error.

Example

x-ms-original-file: specification/netapp/resource-manager/Microsoft.NetApp/stable/2021-08-01/examples/Pools_Get.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/netapp/armnetapp"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client := armnetapp.NewPoolsClient("<subscription-id>", cred, nil)
	res, err := client.Get(ctx,
		"<resource-group-name>",
		"<account-name>",
		"<pool-name>",
		nil)
	if err != nil {
		log.Fatal(err)
	}
	log.Printf("CapacityPool.ID: %s\n", *res.ID)
}

Output:

func (*PoolsClient) List 

func (client *PoolsClient) List(resourceGroupName string, accountName string, options *PoolsListOptions) *PoolsListPager

List - List all capacity pools in the NetApp Account If the operation fails it returns a generic error.

Example

x-ms-original-file: specification/netapp/resource-manager/Microsoft.NetApp/stable/2021-08-01/examples/Pools_List.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/netapp/armnetapp"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client := armnetapp.NewPoolsClient("<subscription-id>", cred, nil)
	pager := client.List("<resource-group-name>",
		"<account-name>",
		nil)
	for pager.NextPage(ctx) {
		if err := pager.Err(); err != nil {
			log.Fatalf("failed to advance page: %v", err)
		}
		for _, v := range pager.PageResponse().Value {
			log.Printf("CapacityPool.ID: %s\n", *v.ID)
		}
	}
}

Output:

type PoolsCreateOrUpdatePoller 

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

PoolsCreateOrUpdatePoller provides polling facilities until the operation reaches a terminal state.

func (*PoolsCreateOrUpdatePoller) Done 

func (p *PoolsCreateOrUpdatePoller) Done() bool

Done returns true if the LRO has reached a terminal state.

func (*PoolsCreateOrUpdatePoller) FinalResponse 

func (p *PoolsCreateOrUpdatePoller) FinalResponse(ctx context.Context) (PoolsCreateOrUpdateResponse, error)

FinalResponse performs a final GET to the service and returns the final response for the polling operation. If there is an error performing the final GET then an error is returned. If the final GET succeeded then the final PoolsCreateOrUpdateResponse will be returned.

func (*PoolsCreateOrUpdatePoller) Poll 

func (p *PoolsCreateOrUpdatePoller) Poll(ctx context.Context) (*http.Response, error)

Poll fetches the latest state of the LRO. It returns an HTTP response or error. If the LRO has completed successfully, the poller's state is updated and the HTTP response is returned. If the LRO has completed with failure or was cancelled, the poller's state is updated and the error is returned. If the LRO has not reached a terminal state, the poller's state is updated and the latest HTTP response is returned. If Poll fails, the poller's state is unmodified and the error is returned. Calling Poll on an LRO that has reached a terminal state will return the final HTTP response or error.

func (*PoolsCreateOrUpdatePoller) ResumeToken 

func (p *PoolsCreateOrUpdatePoller) ResumeToken() (string, error)

ResumeToken returns a value representing the poller that can be used to resume the LRO at a later time. ResumeTokens are unique per service operation.

type PoolsCreateOrUpdatePollerResponse 

type PoolsCreateOrUpdatePollerResponse struct {
	// Poller contains an initialized poller.
	Poller *PoolsCreateOrUpdatePoller

	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

PoolsCreateOrUpdatePollerResponse contains the response from method Pools.CreateOrUpdate.

func (PoolsCreateOrUpdatePollerResponse) PollUntilDone 

func (l PoolsCreateOrUpdatePollerResponse) PollUntilDone(ctx context.Context, freq time.Duration) (PoolsCreateOrUpdateResponse, error)

PollUntilDone will poll the service endpoint until a terminal state is reached or an error is received. freq: the time to wait between intervals in absence of a Retry-After header. Allowed minimum is one second. A good starting value is 30 seconds. Note that some resources might benefit from a different value.

func (*PoolsCreateOrUpdatePollerResponse) Resume 

func (l *PoolsCreateOrUpdatePollerResponse) Resume(ctx context.Context, client *PoolsClient, token string) error

Resume rehydrates a PoolsCreateOrUpdatePollerResponse from the provided client and resume token.

type PoolsCreateOrUpdateResponse 

type PoolsCreateOrUpdateResponse struct {
	PoolsCreateOrUpdateResult
	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

PoolsCreateOrUpdateResponse contains the response from method Pools.CreateOrUpdate.

type PoolsCreateOrUpdateResult 

type PoolsCreateOrUpdateResult struct {
	CapacityPool
}

PoolsCreateOrUpdateResult contains the result from method Pools.CreateOrUpdate.

type PoolsDeletePoller 

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

PoolsDeletePoller provides polling facilities until the operation reaches a terminal state.

func (*PoolsDeletePoller) Done 

func (p *PoolsDeletePoller) Done() bool

Done returns true if the LRO has reached a terminal state.

func (*PoolsDeletePoller) FinalResponse 

func (p *PoolsDeletePoller) FinalResponse(ctx context.Context) (PoolsDeleteResponse, error)

FinalResponse performs a final GET to the service and returns the final response for the polling operation. If there is an error performing the final GET then an error is returned. If the final GET succeeded then the final PoolsDeleteResponse will be returned.

func (*PoolsDeletePoller) Poll 

func (p *PoolsDeletePoller) Poll(ctx context.Context) (*http.Response, error)

Poll fetches the latest state of the LRO. It returns an HTTP response or error. If the LRO has completed successfully, the poller's state is updated and the HTTP response is returned. If the LRO has completed with failure or was cancelled, the poller's state is updated and the error is returned. If the LRO has not reached a terminal state, the poller's state is updated and the latest HTTP response is returned. If Poll fails, the poller's state is unmodified and the error is returned. Calling Poll on an LRO that has reached a terminal state will return the final HTTP response or error.

func (*PoolsDeletePoller) ResumeToken 

func (p *PoolsDeletePoller) ResumeToken() (string, error)

ResumeToken returns a value representing the poller that can be used to resume the LRO at a later time. ResumeTokens are unique per service operation.

type PoolsDeletePollerResponse 

type PoolsDeletePollerResponse struct {
	// Poller contains an initialized poller.
	Poller *PoolsDeletePoller

	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

PoolsDeletePollerResponse contains the response from method Pools.Delete.

func (PoolsDeletePollerResponse) PollUntilDone 

func (l PoolsDeletePollerResponse) PollUntilDone(ctx context.Context, freq time.Duration) (PoolsDeleteResponse, error)

PollUntilDone will poll the service endpoint until a terminal state is reached or an error is received. freq: the time to wait between intervals in absence of a Retry-After header. Allowed minimum is one second. A good starting value is 30 seconds. Note that some resources might benefit from a different value.

func (*PoolsDeletePollerResponse) Resume 

func (l *PoolsDeletePollerResponse) Resume(ctx context.Context, client *PoolsClient, token string) error

Resume rehydrates a PoolsDeletePollerResponse from the provided client and resume token.

type PoolsDeleteResponse 

type PoolsDeleteResponse struct {
	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

PoolsDeleteResponse contains the response from method Pools.Delete.

type PoolsGetOptions 

type PoolsGetOptions struct {
}

PoolsGetOptions contains the optional parameters for the Pools.Get method.

type PoolsGetResponse 

type PoolsGetResponse struct {
	PoolsGetResult
	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

PoolsGetResponse contains the response from method Pools.Get.

type PoolsGetResult 

type PoolsGetResult struct {
	CapacityPool
}

PoolsGetResult contains the result from method Pools.Get.

type PoolsListOptions 

type PoolsListOptions struct {
}

PoolsListOptions contains the optional parameters for the Pools.List method.

type PoolsListPager 

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

PoolsListPager provides operations for iterating over paged responses.

func (*PoolsListPager) Err 

func (p *PoolsListPager) Err() error

Err returns the last error encountered while paging.

func (*PoolsListPager) NextPage 

func (p *PoolsListPager) NextPage(ctx context.Context) bool

NextPage returns true if the pager advanced to the next page. Returns false if there are no more pages or an error occurred.

func (*PoolsListPager) PageResponse 

func (p *PoolsListPager) PageResponse() PoolsListResponse

PageResponse returns the current PoolsListResponse page.

type PoolsListResponse 

type PoolsListResponse struct {
	PoolsListResult
	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

PoolsListResponse contains the response from method Pools.List.

type PoolsListResult 

type PoolsListResult struct {
	CapacityPoolList
}

PoolsListResult contains the result from method Pools.List.

type PoolsUpdatePoller 

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

PoolsUpdatePoller provides polling facilities until the operation reaches a terminal state.

func (*PoolsUpdatePoller) Done 

func (p *PoolsUpdatePoller) Done() bool

Done returns true if the LRO has reached a terminal state.

func (*PoolsUpdatePoller) FinalResponse 

func (p *PoolsUpdatePoller) FinalResponse(ctx context.Context) (PoolsUpdateResponse, error)

FinalResponse performs a final GET to the service and returns the final response for the polling operation. If there is an error performing the final GET then an error is returned. If the final GET succeeded then the final PoolsUpdateResponse will be returned.

func (*PoolsUpdatePoller) Poll 

func (p *PoolsUpdatePoller) Poll(ctx context.Context) (*http.Response, error)

Poll fetches the latest state of the LRO. It returns an HTTP response or error. If the LRO has completed successfully, the poller's state is updated and the HTTP response is returned. If the LRO has completed with failure or was cancelled, the poller's state is updated and the error is returned. If the LRO has not reached a terminal state, the poller's state is updated and the latest HTTP response is returned. If Poll fails, the poller's state is unmodified and the error is returned. Calling Poll on an LRO that has reached a terminal state will return the final HTTP response or error.

func (*PoolsUpdatePoller) ResumeToken 

func (p *PoolsUpdatePoller) ResumeToken() (string, error)

ResumeToken returns a value representing the poller that can be used to resume the LRO at a later time. ResumeTokens are unique per service operation.

type PoolsUpdatePollerResponse 

type PoolsUpdatePollerResponse struct {
	// Poller contains an initialized poller.
	Poller *PoolsUpdatePoller

	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

PoolsUpdatePollerResponse contains the response from method Pools.Update.

func (PoolsUpdatePollerResponse) PollUntilDone 

func (l PoolsUpdatePollerResponse) PollUntilDone(ctx context.Context, freq time.Duration) (PoolsUpdateResponse, error)

PollUntilDone will poll the service endpoint until a terminal state is reached or an error is received. freq: the time to wait between intervals in absence of a Retry-After header. Allowed minimum is one second. A good starting value is 30 seconds. Note that some resources might benefit from a different value.

func (*PoolsUpdatePollerResponse) Resume 

func (l *PoolsUpdatePollerResponse) Resume(ctx context.Context, client *PoolsClient, token string) error

Resume rehydrates a PoolsUpdatePollerResponse from the provided client and resume token.

type PoolsUpdateResponse 

type PoolsUpdateResponse struct {
	PoolsUpdateResult
	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

PoolsUpdateResponse contains the response from method Pools.Update.

type PoolsUpdateResult 

type PoolsUpdateResult struct {
	CapacityPool
}

PoolsUpdateResult contains the result from method Pools.Update.

type ProxyResource 

type ProxyResource struct {
	Resource
}

ProxyResource - The resource model definition for a Azure Resource Manager proxy resource. It will not have tags and a location

type QosType 

type QosType string

QosType - The qos type of the pool 

const (
	// QosTypeAuto - qos type Auto
	QosTypeAuto QosType = "Auto"
	// QosTypeManual - qos type Manual
	QosTypeManual QosType = "Manual"
)

func PossibleQosTypeValues 

func PossibleQosTypeValues() []QosType

PossibleQosTypeValues returns the possible values for the QosType const type.

func (QosType) ToPtr 

func (c QosType) ToPtr() *QosType

ToPtr returns a *QosType pointing to the current value.

type QuotaAvailabilityRequest 

type QuotaAvailabilityRequest struct {
	// REQUIRED; Name of the resource to verify.
	Name *string `json:"name,omitempty"`

	// REQUIRED; Resource group name.
	ResourceGroup *string `json:"resourceGroup,omitempty"`

	// REQUIRED; Resource type used for verification.
	Type *CheckQuotaNameResourceTypes `json:"type,omitempty"`
}

QuotaAvailabilityRequest - Quota availability request content.

type RelationshipStatus 

type RelationshipStatus string

RelationshipStatus - Status of the mirror relationship 

const (
	RelationshipStatusIdle         RelationshipStatus = "Idle"
	RelationshipStatusTransferring RelationshipStatus = "Transferring"
)

func PossibleRelationshipStatusValues 

func PossibleRelationshipStatusValues() []RelationshipStatus

PossibleRelationshipStatusValues returns the possible values for the RelationshipStatus const type.

func (RelationshipStatus) ToPtr 

func (c RelationshipStatus) ToPtr() *RelationshipStatus

ToPtr returns a *RelationshipStatus pointing to the current value.

type ReplicationObject 

type ReplicationObject struct {
	// REQUIRED; The resource ID of the remote volume.
	RemoteVolumeResourceID *string `json:"remoteVolumeResourceId,omitempty"`

	// Indicates whether the local volume is the source or destination for the Volume Replication
	EndpointType *EndpointType `json:"endpointType,omitempty"`

	// The remote region for the other end of the Volume Replication.
	RemoteVolumeRegion *string `json:"remoteVolumeRegion,omitempty"`

	// Id
	ReplicationID *string `json:"replicationId,omitempty"`

	// Schedule
	ReplicationSchedule *ReplicationSchedule `json:"replicationSchedule,omitempty"`
}

ReplicationObject - Replication properties

type ReplicationSchedule 

type ReplicationSchedule string

ReplicationSchedule - Schedule 

const (
	ReplicationSchedule10Minutely ReplicationSchedule = "_10minutely"
	ReplicationScheduleDaily      ReplicationSchedule = "daily"
	ReplicationScheduleHourly     ReplicationSchedule = "hourly"
)

func PossibleReplicationScheduleValues 

func PossibleReplicationScheduleValues() []ReplicationSchedule

PossibleReplicationScheduleValues returns the possible values for the ReplicationSchedule const type.

func (ReplicationSchedule) ToPtr 

func (c ReplicationSchedule) ToPtr() *ReplicationSchedule

ToPtr returns a *ReplicationSchedule pointing to the current value.

type ReplicationStatus 

type ReplicationStatus struct {
	// Displays error message if the replication is in an error state
	ErrorMessage *string `json:"errorMessage,omitempty"`

	// Replication health check
	Healthy *bool `json:"healthy,omitempty"`

	// The status of the replication
	MirrorState *MirrorState `json:"mirrorState,omitempty"`

	// Status of the mirror relationship
	RelationshipStatus *RelationshipStatus `json:"relationshipStatus,omitempty"`

	// The progress of the replication
	TotalProgress *string `json:"totalProgress,omitempty"`
}

ReplicationStatus - Replication status

type Resource 

type Resource struct {
	// READ-ONLY; Fully qualified resource ID for the resource. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}
	ID *string `json:"id,omitempty" azure:"ro"`

	// READ-ONLY; The name of the resource
	Name *string `json:"name,omitempty" azure:"ro"`

	// READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"
	Type *string `json:"type,omitempty" azure:"ro"`
}

Resource - Common fields that are returned in the response for all Azure Resource Manager resources

type ResourceIdentity 

type ResourceIdentity struct {
	// Type of Identity. Supported values are: 'None', 'SystemAssigned'
	Type *string `json:"type,omitempty"`

	// READ-ONLY; Object id of the identity resource
	PrincipalID *string `json:"principalId,omitempty" azure:"ro"`

	// READ-ONLY; The tenant id of the resource
	TenantID *string `json:"tenantId,omitempty" azure:"ro"`
}

ResourceIdentity - Identity for the resource.

type ResourceNameAvailabilityRequest 

type ResourceNameAvailabilityRequest struct {
	// REQUIRED; Resource name to verify.
	Name *string `json:"name,omitempty"`

	// REQUIRED; Resource group name.
	ResourceGroup *string `json:"resourceGroup,omitempty"`

	// REQUIRED; Resource type used for verification.
	Type *CheckNameResourceTypes `json:"type,omitempty"`
}

ResourceNameAvailabilityRequest - Resource name availability request content.

type RestoreStatus 

type RestoreStatus struct {
	// READ-ONLY; Displays error message if the restore is in an error state
	ErrorMessage *string `json:"errorMessage,omitempty" azure:"ro"`

	// READ-ONLY; Restore health status
	Healthy *bool `json:"healthy,omitempty" azure:"ro"`

	// READ-ONLY; The status of the restore
	MirrorState *MirrorState `json:"mirrorState,omitempty" azure:"ro"`

	// READ-ONLY; Status of the restore SnapMirror relationship
	RelationshipStatus *RelationshipStatus `json:"relationshipStatus,omitempty" azure:"ro"`

	// READ-ONLY; Displays the total bytes transferred
	TotalTransferBytes *int64 `json:"totalTransferBytes,omitempty" azure:"ro"`

	// READ-ONLY; Reason for the unhealthy restore relationship
	UnhealthyReason *string `json:"unhealthyReason,omitempty" azure:"ro"`
}

RestoreStatus - Restore status

type SecurityStyle 

type SecurityStyle string

SecurityStyle - The security style of volume, default unix, defaults to ntfs for dual protocol or CIFS protocol 

const (
	SecurityStyleNtfs SecurityStyle = "ntfs"
	SecurityStyleUnix SecurityStyle = "unix"
)

func PossibleSecurityStyleValues 

func PossibleSecurityStyleValues() []SecurityStyle

PossibleSecurityStyleValues returns the possible values for the SecurityStyle const type.

func (SecurityStyle) ToPtr 

func (c SecurityStyle) ToPtr() *SecurityStyle

ToPtr returns a *SecurityStyle pointing to the current value.

type ServiceLevel 

type ServiceLevel string

ServiceLevel - The service level of the file system 

const (
	// ServiceLevelPremium - Premium service level
	ServiceLevelPremium ServiceLevel = "Premium"
	// ServiceLevelStandard - Standard service level
	ServiceLevelStandard ServiceLevel = "Standard"
	// ServiceLevelStandardZRS - Zone redundant storage service level
	ServiceLevelStandardZRS ServiceLevel = "StandardZRS"
	// ServiceLevelUltra - Ultra service level
	ServiceLevelUltra ServiceLevel = "Ultra"
)

func PossibleServiceLevelValues 

func PossibleServiceLevelValues() []ServiceLevel

PossibleServiceLevelValues returns the possible values for the ServiceLevel const type.

func (ServiceLevel) ToPtr 

func (c ServiceLevel) ToPtr() *ServiceLevel

ToPtr returns a *ServiceLevel pointing to the current value.

type ServiceSpecification 

type ServiceSpecification struct {
	// Log specification of operation.
	LogSpecifications []*LogSpecification `json:"logSpecifications,omitempty"`

	// Metric specifications of operation.
	MetricSpecifications []*MetricSpecification `json:"metricSpecifications,omitempty"`
}

ServiceSpecification - One property of operation, include metric specifications.

func (ServiceSpecification) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ServiceSpecification.

type Snapshot 

type Snapshot struct {
	// REQUIRED; Resource location
	Location *string `json:"location,omitempty"`

	// Snapshot Properties
	Properties *SnapshotProperties `json:"properties,omitempty"`

	// READ-ONLY; Resource Id
	ID *string `json:"id,omitempty" azure:"ro"`

	// READ-ONLY; Resource name
	Name *string `json:"name,omitempty" azure:"ro"`

	// READ-ONLY; Resource type
	Type *string `json:"type,omitempty" azure:"ro"`
}

Snapshot of a Volume

type SnapshotPoliciesBeginDeleteOptions 

type SnapshotPoliciesBeginDeleteOptions struct {
}

SnapshotPoliciesBeginDeleteOptions contains the optional parameters for the SnapshotPolicies.BeginDelete method.

type SnapshotPoliciesBeginUpdateOptions 

type SnapshotPoliciesBeginUpdateOptions struct {
}

SnapshotPoliciesBeginUpdateOptions contains the optional parameters for the SnapshotPolicies.BeginUpdate method.

type SnapshotPoliciesClient 

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

SnapshotPoliciesClient contains the methods for the SnapshotPolicies group. Don't use this type directly, use NewSnapshotPoliciesClient() instead.

func NewSnapshotPoliciesClient 

func NewSnapshotPoliciesClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) *SnapshotPoliciesClient

NewSnapshotPoliciesClient creates a new instance of SnapshotPoliciesClient with the specified values.

func (*SnapshotPoliciesClient) BeginDelete 

func (client *SnapshotPoliciesClient) BeginDelete(ctx context.Context, resourceGroupName string, accountName string, snapshotPolicyName string, options *SnapshotPoliciesBeginDeleteOptions) (SnapshotPoliciesDeletePollerResponse, error)

BeginDelete - Delete snapshot policy If the operation fails it returns a generic error.

Example

x-ms-original-file: specification/netapp/resource-manager/Microsoft.NetApp/stable/2021-08-01/examples/SnapshotPolicies_Delete.json 

package main

import (
	"context"
	"log"

	"time"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/netapp/armnetapp"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client := armnetapp.NewSnapshotPoliciesClient("<subscription-id>", cred, nil)
	poller, err := client.BeginDelete(ctx,
		"<resource-group-name>",
		"<account-name>",
		"<snapshot-policy-name>",
		nil)
	if err != nil {
		log.Fatal(err)
	}
	_, err = poller.PollUntilDone(ctx, 30*time.Second)
	if err != nil {
		log.Fatal(err)
	}
}

Output:

func (*SnapshotPoliciesClient) BeginUpdate 

func (client *SnapshotPoliciesClient) BeginUpdate(ctx context.Context, resourceGroupName string, accountName string, snapshotPolicyName string, body SnapshotPolicyPatch, options *SnapshotPoliciesBeginUpdateOptions) (SnapshotPoliciesUpdatePollerResponse, error)

BeginUpdate - Patch a snapshot policy If the operation fails it returns a generic error.

Example

x-ms-original-file: specification/netapp/resource-manager/Microsoft.NetApp/stable/2021-08-01/examples/SnapshotPolicies_Update.json 

package main

import (
	"context"
	"log"

	"time"

	"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/netapp/armnetapp"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client := armnetapp.NewSnapshotPoliciesClient("<subscription-id>", cred, nil)
	poller, err := client.BeginUpdate(ctx,
		"<resource-group-name>",
		"<account-name>",
		"<snapshot-policy-name>",
		armnetapp.SnapshotPolicyPatch{
			Location: to.StringPtr("<location>"),
			Properties: &armnetapp.SnapshotPolicyProperties{
				DailySchedule: &armnetapp.DailySchedule{
					Hour:            to.Int32Ptr(14),
					Minute:          to.Int32Ptr(30),
					SnapshotsToKeep: to.Int32Ptr(4),
				},
				Enabled: to.BoolPtr(true),
				HourlySchedule: &armnetapp.HourlySchedule{
					Minute:          to.Int32Ptr(50),
					SnapshotsToKeep: to.Int32Ptr(2),
				},
				MonthlySchedule: &armnetapp.MonthlySchedule{
					DaysOfMonth:     to.StringPtr("<days-of-month>"),
					Hour:            to.Int32Ptr(14),
					Minute:          to.Int32Ptr(15),
					SnapshotsToKeep: to.Int32Ptr(5),
				},
				WeeklySchedule: &armnetapp.WeeklySchedule{
					Day:             to.StringPtr("<day>"),
					Hour:            to.Int32Ptr(14),
					Minute:          to.Int32Ptr(45),
					SnapshotsToKeep: to.Int32Ptr(3),
				},
			},
		},
		nil)
	if err != nil {
		log.Fatal(err)
	}
	res, err := poller.PollUntilDone(ctx, 30*time.Second)
	if err != nil {
		log.Fatal(err)
	}
	log.Printf("SnapshotPolicy.ID: %s\n", *res.ID)
}

Output:

func (*SnapshotPoliciesClient) Create 

func (client *SnapshotPoliciesClient) Create(ctx context.Context, resourceGroupName string, accountName string, snapshotPolicyName string, body SnapshotPolicy, options *SnapshotPoliciesCreateOptions) (SnapshotPoliciesCreateResponse, error)

Create - Create a snapshot policy If the operation fails it returns a generic error.

Example

x-ms-original-file: specification/netapp/resource-manager/Microsoft.NetApp/stable/2021-08-01/examples/SnapshotPolicies_Create.json 

package main

import (
	"context"
	"log"

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

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client := armnetapp.NewSnapshotPoliciesClient("<subscription-id>", cred, nil)
	res, err := client.Create(ctx,
		"<resource-group-name>",
		"<account-name>",
		"<snapshot-policy-name>",
		armnetapp.SnapshotPolicy{
			Location: to.StringPtr("<location>"),
			Properties: &armnetapp.SnapshotPolicyProperties{
				DailySchedule: &armnetapp.DailySchedule{
					Hour:            to.Int32Ptr(14),
					Minute:          to.Int32Ptr(30),
					SnapshotsToKeep: to.Int32Ptr(4),
				},
				HourlySchedule: &armnetapp.HourlySchedule{
					Minute:          to.Int32Ptr(50),
					SnapshotsToKeep: to.Int32Ptr(2),
				},
				MonthlySchedule: &armnetapp.MonthlySchedule{
					DaysOfMonth:     to.StringPtr("<days-of-month>"),
					Hour:            to.Int32Ptr(14),
					Minute:          to.Int32Ptr(15),
					SnapshotsToKeep: to.Int32Ptr(5),
				},
				WeeklySchedule: &armnetapp.WeeklySchedule{
					Day:             to.StringPtr("<day>"),
					Hour:            to.Int32Ptr(14),
					Minute:          to.Int32Ptr(45),
					SnapshotsToKeep: to.Int32Ptr(3),
				},
			},
		},
		nil)
	if err != nil {
		log.Fatal(err)
	}
	log.Printf("SnapshotPolicy.ID: %s\n", *res.ID)
}

Output:

func (*SnapshotPoliciesClient) Get 

func (client *SnapshotPoliciesClient) Get(ctx context.Context, resourceGroupName string, accountName string, snapshotPolicyName string, options *SnapshotPoliciesGetOptions) (SnapshotPoliciesGetResponse, error)

Get - Get a snapshot Policy If the operation fails it returns a generic error.

Example

x-ms-original-file: specification/netapp/resource-manager/Microsoft.NetApp/stable/2021-08-01/examples/SnapshotPolicies_Get.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/netapp/armnetapp"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client := armnetapp.NewSnapshotPoliciesClient("<subscription-id>", cred, nil)
	res, err := client.Get(ctx,
		"<resource-group-name>",
		"<account-name>",
		"<snapshot-policy-name>",
		nil)
	if err != nil {
		log.Fatal(err)
	}
	log.Printf("SnapshotPolicy.ID: %s\n", *res.ID)
}

Output:

func (*SnapshotPoliciesClient) List 

func (client *SnapshotPoliciesClient) List(ctx context.Context, resourceGroupName string, accountName string, options *SnapshotPoliciesListOptions) (SnapshotPoliciesListResponse, error)

List - List snapshot policy If the operation fails it returns a generic error.

Example

x-ms-original-file: specification/netapp/resource-manager/Microsoft.NetApp/stable/2021-08-01/examples/SnapshotPolicies_List.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/netapp/armnetapp"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client := armnetapp.NewSnapshotPoliciesClient("<subscription-id>", cred, nil)
	_, err = client.List(ctx,
		"<resource-group-name>",
		"<account-name>",
		nil)
	if err != nil {
		log.Fatal(err)
	}
}

Output:

func (*SnapshotPoliciesClient) ListVolumes 

func (client *SnapshotPoliciesClient) ListVolumes(ctx context.Context, resourceGroupName string, accountName string, snapshotPolicyName string, options *SnapshotPoliciesListVolumesOptions) (SnapshotPoliciesListVolumesResponse, error)

ListVolumes - Get volumes associated with snapshot policy If the operation fails it returns a generic error.

Example

x-ms-original-file: specification/netapp/resource-manager/Microsoft.NetApp/stable/2021-08-01/examples/SnapshotPolicies_ListVolumes.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/netapp/armnetapp"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client := armnetapp.NewSnapshotPoliciesClient("<subscription-id>", cred, nil)
	_, err = client.ListVolumes(ctx,
		"<resource-group-name>",
		"<account-name>",
		"<snapshot-policy-name>",
		nil)
	if err != nil {
		log.Fatal(err)
	}
}

Output:

type SnapshotPoliciesCreateOptions 

type SnapshotPoliciesCreateOptions struct {
}

SnapshotPoliciesCreateOptions contains the optional parameters for the SnapshotPolicies.Create method.

type SnapshotPoliciesCreateResponse 

type SnapshotPoliciesCreateResponse struct {
	SnapshotPoliciesCreateResult
	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

SnapshotPoliciesCreateResponse contains the response from method SnapshotPolicies.Create.

type SnapshotPoliciesCreateResult 

type SnapshotPoliciesCreateResult struct {
	SnapshotPolicy
}

SnapshotPoliciesCreateResult contains the result from method SnapshotPolicies.Create.

type SnapshotPoliciesDeletePoller 

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

SnapshotPoliciesDeletePoller provides polling facilities until the operation reaches a terminal state.

func (*SnapshotPoliciesDeletePoller) Done 

func (p *SnapshotPoliciesDeletePoller) Done() bool

Done returns true if the LRO has reached a terminal state.

func (*SnapshotPoliciesDeletePoller) FinalResponse 

func (p *SnapshotPoliciesDeletePoller) FinalResponse(ctx context.Context) (SnapshotPoliciesDeleteResponse, error)

FinalResponse performs a final GET to the service and returns the final response for the polling operation. If there is an error performing the final GET then an error is returned. If the final GET succeeded then the final SnapshotPoliciesDeleteResponse will be returned.

func (*SnapshotPoliciesDeletePoller) Poll 

func (p *SnapshotPoliciesDeletePoller) Poll(ctx context.Context) (*http.Response, error)

Poll fetches the latest state of the LRO. It returns an HTTP response or error. If the LRO has completed successfully, the poller's state is updated and the HTTP response is returned. If the LRO has completed with failure or was cancelled, the poller's state is updated and the error is returned. If the LRO has not reached a terminal state, the poller's state is updated and the latest HTTP response is returned. If Poll fails, the poller's state is unmodified and the error is returned. Calling Poll on an LRO that has reached a terminal state will return the final HTTP response or error.

func (*SnapshotPoliciesDeletePoller) ResumeToken 

func (p *SnapshotPoliciesDeletePoller) ResumeToken() (string, error)

ResumeToken returns a value representing the poller that can be used to resume the LRO at a later time. ResumeTokens are unique per service operation.

type SnapshotPoliciesDeletePollerResponse 

type SnapshotPoliciesDeletePollerResponse struct {
	// Poller contains an initialized poller.
	Poller *SnapshotPoliciesDeletePoller

	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

SnapshotPoliciesDeletePollerResponse contains the response from method SnapshotPolicies.Delete.

func (SnapshotPoliciesDeletePollerResponse) PollUntilDone 

func (l SnapshotPoliciesDeletePollerResponse) PollUntilDone(ctx context.Context, freq time.Duration) (SnapshotPoliciesDeleteResponse, error)

PollUntilDone will poll the service endpoint until a terminal state is reached or an error is received. freq: the time to wait between intervals in absence of a Retry-After header. Allowed minimum is one second. A good starting value is 30 seconds. Note that some resources might benefit from a different value.

func (*SnapshotPoliciesDeletePollerResponse) Resume 

func (l *SnapshotPoliciesDeletePollerResponse) Resume(ctx context.Context, client *SnapshotPoliciesClient, token string) error

Resume rehydrates a SnapshotPoliciesDeletePollerResponse from the provided client and resume token.

type SnapshotPoliciesDeleteResponse 

type SnapshotPoliciesDeleteResponse struct {
	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

SnapshotPoliciesDeleteResponse contains the response from method SnapshotPolicies.Delete.

type SnapshotPoliciesGetOptions 

type SnapshotPoliciesGetOptions struct {
}

SnapshotPoliciesGetOptions contains the optional parameters for the SnapshotPolicies.Get method.

type SnapshotPoliciesGetResponse 

type SnapshotPoliciesGetResponse struct {
	SnapshotPoliciesGetResult
	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

SnapshotPoliciesGetResponse contains the response from method SnapshotPolicies.Get.

type SnapshotPoliciesGetResult 

type SnapshotPoliciesGetResult struct {
	SnapshotPolicy
}

SnapshotPoliciesGetResult contains the result from method SnapshotPolicies.Get.

type SnapshotPoliciesList 

type SnapshotPoliciesList struct {
	// A list of snapshot policies
	Value []*SnapshotPolicy `json:"value,omitempty"`
}

SnapshotPoliciesList - List of Snapshot Policies

func (SnapshotPoliciesList) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type SnapshotPoliciesList.

type SnapshotPoliciesListOptions 

type SnapshotPoliciesListOptions struct {
}

SnapshotPoliciesListOptions contains the optional parameters for the SnapshotPolicies.List method.

type SnapshotPoliciesListResponse 

type SnapshotPoliciesListResponse struct {
	SnapshotPoliciesListResult
	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

SnapshotPoliciesListResponse contains the response from method SnapshotPolicies.List.

type SnapshotPoliciesListResult 

type SnapshotPoliciesListResult struct {
	SnapshotPoliciesList
}

SnapshotPoliciesListResult contains the result from method SnapshotPolicies.List.

type SnapshotPoliciesListVolumesOptions 

type SnapshotPoliciesListVolumesOptions struct {
}

SnapshotPoliciesListVolumesOptions contains the optional parameters for the SnapshotPolicies.ListVolumes method.

type SnapshotPoliciesListVolumesResponse 

type SnapshotPoliciesListVolumesResponse struct {
	SnapshotPoliciesListVolumesResult
	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

SnapshotPoliciesListVolumesResponse contains the response from method SnapshotPolicies.ListVolumes.

type SnapshotPoliciesListVolumesResult 

type SnapshotPoliciesListVolumesResult struct {
	SnapshotPolicyVolumeList
}

SnapshotPoliciesListVolumesResult contains the result from method SnapshotPolicies.ListVolumes.

type SnapshotPoliciesUpdatePoller 

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

SnapshotPoliciesUpdatePoller provides polling facilities until the operation reaches a terminal state.

func (*SnapshotPoliciesUpdatePoller) Done 

func (p *SnapshotPoliciesUpdatePoller) Done() bool

Done returns true if the LRO has reached a terminal state.

func (*SnapshotPoliciesUpdatePoller) FinalResponse 

func (p *SnapshotPoliciesUpdatePoller) FinalResponse(ctx context.Context) (SnapshotPoliciesUpdateResponse, error)

FinalResponse performs a final GET to the service and returns the final response for the polling operation. If there is an error performing the final GET then an error is returned. If the final GET succeeded then the final SnapshotPoliciesUpdateResponse will be returned.

func (*SnapshotPoliciesUpdatePoller) Poll 

func (p *SnapshotPoliciesUpdatePoller) Poll(ctx context.Context) (*http.Response, error)

Poll fetches the latest state of the LRO. It returns an HTTP response or error. If the LRO has completed successfully, the poller's state is updated and the HTTP response is returned. If the LRO has completed with failure or was cancelled, the poller's state is updated and the error is returned. If the LRO has not reached a terminal state, the poller's state is updated and the latest HTTP response is returned. If Poll fails, the poller's state is unmodified and the error is returned. Calling Poll on an LRO that has reached a terminal state will return the final HTTP response or error.

func (*SnapshotPoliciesUpdatePoller) ResumeToken 

func (p *SnapshotPoliciesUpdatePoller) ResumeToken() (string, error)

ResumeToken returns a value representing the poller that can be used to resume the LRO at a later time. ResumeTokens are unique per service operation.

type SnapshotPoliciesUpdatePollerResponse 

type SnapshotPoliciesUpdatePollerResponse struct {
	// Poller contains an initialized poller.
	Poller *SnapshotPoliciesUpdatePoller

	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

SnapshotPoliciesUpdatePollerResponse contains the response from method SnapshotPolicies.Update.

func (SnapshotPoliciesUpdatePollerResponse) PollUntilDone 

func (l SnapshotPoliciesUpdatePollerResponse) PollUntilDone(ctx context.Context, freq time.Duration) (SnapshotPoliciesUpdateResponse, error)

PollUntilDone will poll the service endpoint until a terminal state is reached or an error is received. freq: the time to wait between intervals in absence of a Retry-After header. Allowed minimum is one second. A good starting value is 30 seconds. Note that some resources might benefit from a different value.

func (*SnapshotPoliciesUpdatePollerResponse) Resume 

func (l *SnapshotPoliciesUpdatePollerResponse) Resume(ctx context.Context, client *SnapshotPoliciesClient, token string) error

Resume rehydrates a SnapshotPoliciesUpdatePollerResponse from the provided client and resume token.

type SnapshotPoliciesUpdateResponse 

type SnapshotPoliciesUpdateResponse struct {
	SnapshotPoliciesUpdateResult
	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

SnapshotPoliciesUpdateResponse contains the response from method SnapshotPolicies.Update.

type SnapshotPoliciesUpdateResult 

type SnapshotPoliciesUpdateResult struct {
	SnapshotPolicy
}

SnapshotPoliciesUpdateResult contains the result from method SnapshotPolicies.Update.

type SnapshotPolicy 

type SnapshotPolicy struct {
	// REQUIRED; Resource location
	Location *string `json:"location,omitempty"`

	// REQUIRED; Snapshot policy Properties
	Properties *SnapshotPolicyProperties `json:"properties,omitempty"`

	// Resource tags
	Tags map[string]*string `json:"tags,omitempty"`

	// READ-ONLY; A unique read-only string that changes whenever the resource is updated.
	Etag *string `json:"etag,omitempty" azure:"ro"`

	// READ-ONLY; Resource Id
	ID *string `json:"id,omitempty" azure:"ro"`

	// READ-ONLY; Resource name
	Name *string `json:"name,omitempty" azure:"ro"`

	// READ-ONLY; Resource type
	Type *string `json:"type,omitempty" azure:"ro"`
}

SnapshotPolicy - Snapshot policy information

func (SnapshotPolicy) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type SnapshotPolicy.

type SnapshotPolicyDetails 

type SnapshotPolicyDetails struct {
	// Resource location
	Location *string `json:"location,omitempty"`

	// Snapshot policy Properties
	Properties *SnapshotPolicyProperties `json:"properties,omitempty"`

	// Resource tags
	Tags map[string]*string `json:"tags,omitempty"`

	// READ-ONLY; Resource Id
	ID *string `json:"id,omitempty" azure:"ro"`

	// READ-ONLY; Resource name
	Name *string `json:"name,omitempty" azure:"ro"`

	// READ-ONLY; Resource type
	Type *string `json:"type,omitempty" azure:"ro"`
}

SnapshotPolicyDetails - Snapshot policy properties

func (SnapshotPolicyDetails) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type SnapshotPolicyDetails.

type SnapshotPolicyPatch 

type SnapshotPolicyPatch struct {
	// Resource location
	Location *string `json:"location,omitempty"`

	// Snapshot Policy properties
	Properties *SnapshotPolicyProperties `json:"properties,omitempty"`

	// Resource tags
	Tags map[string]*string `json:"tags,omitempty"`

	// READ-ONLY; Resource Id
	ID *string `json:"id,omitempty" azure:"ro"`

	// READ-ONLY; Resource name
	Name *string `json:"name,omitempty" azure:"ro"`

	// READ-ONLY; Resource type
	Type *string `json:"type,omitempty" azure:"ro"`
}

SnapshotPolicyPatch - Snapshot policy Details for create and update

func (SnapshotPolicyPatch) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type SnapshotPolicyPatch.

type SnapshotPolicyProperties 

type SnapshotPolicyProperties struct {
	// Schedule for daily snapshots
	DailySchedule *DailySchedule `json:"dailySchedule,omitempty"`

	// The property to decide policy is enabled or not
	Enabled *bool `json:"enabled,omitempty"`

	// Schedule for hourly snapshots
	HourlySchedule *HourlySchedule `json:"hourlySchedule,omitempty"`

	// Schedule for monthly snapshots
	MonthlySchedule *MonthlySchedule `json:"monthlySchedule,omitempty"`

	// Schedule for weekly snapshots
	WeeklySchedule *WeeklySchedule `json:"weeklySchedule,omitempty"`

	// READ-ONLY; Azure lifecycle management
	ProvisioningState *string `json:"provisioningState,omitempty" azure:"ro"`
}

SnapshotPolicyProperties - Snapshot policy properties

type SnapshotPolicyVolumeList 

type SnapshotPolicyVolumeList struct {
	// List of volumes
	Value []*Volume `json:"value,omitempty"`
}

SnapshotPolicyVolumeList - Volumes associated with snapshot policy

func (SnapshotPolicyVolumeList) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type SnapshotPolicyVolumeList.

type SnapshotProperties 

type SnapshotProperties struct {
	// READ-ONLY; The creation date of the snapshot
	Created *time.Time `json:"created,omitempty" azure:"ro"`

	// READ-ONLY; Azure lifecycle management
	ProvisioningState *string `json:"provisioningState,omitempty" azure:"ro"`

	// READ-ONLY; UUID v4 used to identify the Snapshot
	SnapshotID *string `json:"snapshotId,omitempty" azure:"ro"`
}

SnapshotProperties - Snapshot properties

func (SnapshotProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type SnapshotProperties.

func (*SnapshotProperties) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SnapshotProperties.

type SnapshotsBeginCreateOptions 

type SnapshotsBeginCreateOptions struct {
}

SnapshotsBeginCreateOptions contains the optional parameters for the Snapshots.BeginCreate method.

type SnapshotsBeginDeleteOptions 

type SnapshotsBeginDeleteOptions struct {
}

SnapshotsBeginDeleteOptions contains the optional parameters for the Snapshots.BeginDelete method.

type SnapshotsBeginUpdateOptions 

type SnapshotsBeginUpdateOptions struct {
}

SnapshotsBeginUpdateOptions contains the optional parameters for the Snapshots.BeginUpdate method.

type SnapshotsClient 

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

SnapshotsClient contains the methods for the Snapshots group. Don't use this type directly, use NewSnapshotsClient() instead.

func NewSnapshotsClient 

func NewSnapshotsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) *SnapshotsClient

NewSnapshotsClient creates a new instance of SnapshotsClient with the specified values.

func (*SnapshotsClient) BeginCreate 

func (client *SnapshotsClient) BeginCreate(ctx context.Context, resourceGroupName string, accountName string, poolName string, volumeName string, snapshotName string, body Snapshot, options *SnapshotsBeginCreateOptions) (SnapshotsCreatePollerResponse, error)

BeginCreate - Create the specified snapshot within the given volume If the operation fails it returns a generic error.

Example

x-ms-original-file: specification/netapp/resource-manager/Microsoft.NetApp/stable/2021-08-01/examples/Snapshots_Create.json 

package main

import (
	"context"
	"log"

	"time"

	"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/netapp/armnetapp"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client := armnetapp.NewSnapshotsClient("<subscription-id>", cred, nil)
	poller, err := client.BeginCreate(ctx,
		"<resource-group-name>",
		"<account-name>",
		"<pool-name>",
		"<volume-name>",
		"<snapshot-name>",
		armnetapp.Snapshot{
			Location: to.StringPtr("<location>"),
		},
		nil)
	if err != nil {
		log.Fatal(err)
	}
	res, err := poller.PollUntilDone(ctx, 30*time.Second)
	if err != nil {
		log.Fatal(err)
	}
	log.Printf("Snapshot.ID: %s\n", *res.ID)
}

Output:

func (*SnapshotsClient) BeginDelete 

func (client *SnapshotsClient) BeginDelete(ctx context.Context, resourceGroupName string, accountName string, poolName string, volumeName string, snapshotName string, options *SnapshotsBeginDeleteOptions) (SnapshotsDeletePollerResponse, error)

BeginDelete - Delete snapshot If the operation fails it returns a generic error.

Example

x-ms-original-file: specification/netapp/resource-manager/Microsoft.NetApp/stable/2021-08-01/examples/Snapshots_Delete.json 

package main

import (
	"context"
	"log"

	"time"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/netapp/armnetapp"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client := armnetapp.NewSnapshotsClient("<subscription-id>", cred, nil)
	poller, err := client.BeginDelete(ctx,
		"<resource-group-name>",
		"<account-name>",
		"<pool-name>",
		"<volume-name>",
		"<snapshot-name>",
		nil)
	if err != nil {
		log.Fatal(err)
	}
	_, err = poller.PollUntilDone(ctx, 30*time.Second)
	if err != nil {
		log.Fatal(err)
	}
}

Output:

func (*SnapshotsClient) BeginUpdate 

func (client *SnapshotsClient) BeginUpdate(ctx context.Context, resourceGroupName string, accountName string, poolName string, volumeName string, snapshotName string, body map[string]interface{}, options *SnapshotsBeginUpdateOptions) (SnapshotsUpdatePollerResponse, error)

BeginUpdate - Patch a snapshot If the operation fails it returns a generic error.

Example

x-ms-original-file: specification/netapp/resource-manager/Microsoft.NetApp/stable/2021-08-01/examples/Snapshots_Update.json 

package main

import (
	"context"
	"log"

	"time"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/netapp/armnetapp"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client := armnetapp.NewSnapshotsClient("<subscription-id>", cred, nil)
	poller, err := client.BeginUpdate(ctx,
		"<resource-group-name>",
		"<account-name>",
		"<pool-name>",
		"<volume-name>",
		"<snapshot-name>",
		map[string]interface{}{},
		nil)
	if err != nil {
		log.Fatal(err)
	}
	res, err := poller.PollUntilDone(ctx, 30*time.Second)
	if err != nil {
		log.Fatal(err)
	}
	log.Printf("Snapshot.ID: %s\n", *res.ID)
}

Output:

func (*SnapshotsClient) Get 

func (client *SnapshotsClient) Get(ctx context.Context, resourceGroupName string, accountName string, poolName string, volumeName string, snapshotName string, options *SnapshotsGetOptions) (SnapshotsGetResponse, error)

Get - Get details of the specified snapshot If the operation fails it returns a generic error.

Example

x-ms-original-file: specification/netapp/resource-manager/Microsoft.NetApp/stable/2021-08-01/examples/Snapshots_Get.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/netapp/armnetapp"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client := armnetapp.NewSnapshotsClient("<subscription-id>", cred, nil)
	res, err := client.Get(ctx,
		"<resource-group-name>",
		"<account-name>",
		"<pool-name>",
		"<volume-name>",
		"<snapshot-name>",
		nil)
	if err != nil {
		log.Fatal(err)
	}
	log.Printf("Snapshot.ID: %s\n", *res.ID)
}

Output:

func (*SnapshotsClient) List 

func (client *SnapshotsClient) List(ctx context.Context, resourceGroupName string, accountName string, poolName string, volumeName string, options *SnapshotsListOptions) (SnapshotsListResponse, error)

List - List all snapshots associated with the volume If the operation fails it returns a generic error.

Example

x-ms-original-file: specification/netapp/resource-manager/Microsoft.NetApp/stable/2021-08-01/examples/Snapshots_List.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/netapp/armnetapp"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client := armnetapp.NewSnapshotsClient("<subscription-id>", cred, nil)
	_, err = client.List(ctx,
		"<resource-group-name>",
		"<account-name>",
		"<pool-name>",
		"<volume-name>",
		nil)
	if err != nil {
		log.Fatal(err)
	}
}

Output:

type SnapshotsCreatePoller 

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

SnapshotsCreatePoller provides polling facilities until the operation reaches a terminal state.

func (*SnapshotsCreatePoller) Done 

func (p *SnapshotsCreatePoller) Done() bool

Done returns true if the LRO has reached a terminal state.

func (*SnapshotsCreatePoller) FinalResponse 

func (p *SnapshotsCreatePoller) FinalResponse(ctx context.Context) (SnapshotsCreateResponse, error)

FinalResponse performs a final GET to the service and returns the final response for the polling operation. If there is an error performing the final GET then an error is returned. If the final GET succeeded then the final SnapshotsCreateResponse will be returned.

func (*SnapshotsCreatePoller) Poll 

func (p *SnapshotsCreatePoller) Poll(ctx context.Context) (*http.Response, error)

Poll fetches the latest state of the LRO. It returns an HTTP response or error. If the LRO has completed successfully, the poller's state is updated and the HTTP response is returned. If the LRO has completed with failure or was cancelled, the poller's state is updated and the error is returned. If the LRO has not reached a terminal state, the poller's state is updated and the latest HTTP response is returned. If Poll fails, the poller's state is unmodified and the error is returned. Calling Poll on an LRO that has reached a terminal state will return the final HTTP response or error.

func (*SnapshotsCreatePoller) ResumeToken 

func (p *SnapshotsCreatePoller) ResumeToken() (string, error)

ResumeToken returns a value representing the poller that can be used to resume the LRO at a later time. ResumeTokens are unique per service operation.

type SnapshotsCreatePollerResponse 

type SnapshotsCreatePollerResponse struct {
	// Poller contains an initialized poller.
	Poller *SnapshotsCreatePoller

	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

SnapshotsCreatePollerResponse contains the response from method Snapshots.Create.

func (SnapshotsCreatePollerResponse) PollUntilDone 

func (l SnapshotsCreatePollerResponse) PollUntilDone(ctx context.Context, freq time.Duration) (SnapshotsCreateResponse, error)

PollUntilDone will poll the service endpoint until a terminal state is reached or an error is received. freq: the time to wait between intervals in absence of a Retry-After header. Allowed minimum is one second. A good starting value is 30 seconds. Note that some resources might benefit from a different value.

func (*SnapshotsCreatePollerResponse) Resume 

func (l *SnapshotsCreatePollerResponse) Resume(ctx context.Context, client *SnapshotsClient, token string) error

Resume rehydrates a SnapshotsCreatePollerResponse from the provided client and resume token.

type SnapshotsCreateResponse 

type SnapshotsCreateResponse struct {
	SnapshotsCreateResult
	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

SnapshotsCreateResponse contains the response from method Snapshots.Create.

type SnapshotsCreateResult 

type SnapshotsCreateResult struct {
	Snapshot
}

SnapshotsCreateResult contains the result from method Snapshots.Create.

type SnapshotsDeletePoller 

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

SnapshotsDeletePoller provides polling facilities until the operation reaches a terminal state.

func (*SnapshotsDeletePoller) Done 

func (p *SnapshotsDeletePoller) Done() bool

Done returns true if the LRO has reached a terminal state.

func (*SnapshotsDeletePoller) FinalResponse 

func (p *SnapshotsDeletePoller) FinalResponse(ctx context.Context) (SnapshotsDeleteResponse, error)

FinalResponse performs a final GET to the service and returns the final response for the polling operation. If there is an error performing the final GET then an error is returned. If the final GET succeeded then the final SnapshotsDeleteResponse will be returned.

func (*SnapshotsDeletePoller) Poll 

func (p *SnapshotsDeletePoller) Poll(ctx context.Context) (*http.Response, error)

Poll fetches the latest state of the LRO. It returns an HTTP response or error. If the LRO has completed successfully, the poller's state is updated and the HTTP response is returned. If the LRO has completed with failure or was cancelled, the poller's state is updated and the error is returned. If the LRO has not reached a terminal state, the poller's state is updated and the latest HTTP response is returned. If Poll fails, the poller's state is unmodified and the error is returned. Calling Poll on an LRO that has reached a terminal state will return the final HTTP response or error.

func (*SnapshotsDeletePoller) ResumeToken 

func (p *SnapshotsDeletePoller) ResumeToken() (string, error)

ResumeToken returns a value representing the poller that can be used to resume the LRO at a later time. ResumeTokens are unique per service operation.

type SnapshotsDeletePollerResponse 

type SnapshotsDeletePollerResponse struct {
	// Poller contains an initialized poller.
	Poller *SnapshotsDeletePoller

	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

SnapshotsDeletePollerResponse contains the response from method Snapshots.Delete.

func (SnapshotsDeletePollerResponse) PollUntilDone 

func (l SnapshotsDeletePollerResponse) PollUntilDone(ctx context.Context, freq time.Duration) (SnapshotsDeleteResponse, error)

PollUntilDone will poll the service endpoint until a terminal state is reached or an error is received. freq: the time to wait between intervals in absence of a Retry-After header. Allowed minimum is one second. A good starting value is 30 seconds. Note that some resources might benefit from a different value.

func (*SnapshotsDeletePollerResponse) Resume 

func (l *SnapshotsDeletePollerResponse) Resume(ctx context.Context, client *SnapshotsClient, token string) error

Resume rehydrates a SnapshotsDeletePollerResponse from the provided client and resume token.

type SnapshotsDeleteResponse 

type SnapshotsDeleteResponse struct {
	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

SnapshotsDeleteResponse contains the response from method Snapshots.Delete.

type SnapshotsGetOptions 

type SnapshotsGetOptions struct {
}

SnapshotsGetOptions contains the optional parameters for the Snapshots.Get method.

type SnapshotsGetResponse 

type SnapshotsGetResponse struct {
	SnapshotsGetResult
	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

SnapshotsGetResponse contains the response from method Snapshots.Get.

type SnapshotsGetResult 

type SnapshotsGetResult struct {
	Snapshot
}

SnapshotsGetResult contains the result from method Snapshots.Get.

type SnapshotsList 

type SnapshotsList struct {
	// A list of Snapshots
	Value []*Snapshot `json:"value,omitempty"`
}

SnapshotsList - List of Snapshots

func (SnapshotsList) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type SnapshotsList.

type SnapshotsListOptions 

type SnapshotsListOptions struct {
}

SnapshotsListOptions contains the optional parameters for the Snapshots.List method.

type SnapshotsListResponse 

type SnapshotsListResponse struct {
	SnapshotsListResult
	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

SnapshotsListResponse contains the response from method Snapshots.List.

type SnapshotsListResult 

type SnapshotsListResult struct {
	SnapshotsList
}

SnapshotsListResult contains the result from method Snapshots.List.

type SnapshotsUpdatePoller 

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

SnapshotsUpdatePoller provides polling facilities until the operation reaches a terminal state.

func (*SnapshotsUpdatePoller) Done 

func (p *SnapshotsUpdatePoller) Done() bool

Done returns true if the LRO has reached a terminal state.

func (*SnapshotsUpdatePoller) FinalResponse 

func (p *SnapshotsUpdatePoller) FinalResponse(ctx context.Context) (SnapshotsUpdateResponse, error)

FinalResponse performs a final GET to the service and returns the final response for the polling operation. If there is an error performing the final GET then an error is returned. If the final GET succeeded then the final SnapshotsUpdateResponse will be returned.

func (*SnapshotsUpdatePoller) Poll 

func (p *SnapshotsUpdatePoller) Poll(ctx context.Context) (*http.Response, error)

Poll fetches the latest state of the LRO. It returns an HTTP response or error. If the LRO has completed successfully, the poller's state is updated and the HTTP response is returned. If the LRO has completed with failure or was cancelled, the poller's state is updated and the error is returned. If the LRO has not reached a terminal state, the poller's state is updated and the latest HTTP response is returned. If Poll fails, the poller's state is unmodified and the error is returned. Calling Poll on an LRO that has reached a terminal state will return the final HTTP response or error.

func (*SnapshotsUpdatePoller) ResumeToken 

func (p *SnapshotsUpdatePoller) ResumeToken() (string, error)

ResumeToken returns a value representing the poller that can be used to resume the LRO at a later time. ResumeTokens are unique per service operation.

type SnapshotsUpdatePollerResponse 

type SnapshotsUpdatePollerResponse struct {
	// Poller contains an initialized poller.
	Poller *SnapshotsUpdatePoller

	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

SnapshotsUpdatePollerResponse contains the response from method Snapshots.Update.

func (SnapshotsUpdatePollerResponse) PollUntilDone 

func (l SnapshotsUpdatePollerResponse) PollUntilDone(ctx context.Context, freq time.Duration) (SnapshotsUpdateResponse, error)

PollUntilDone will poll the service endpoint until a terminal state is reached or an error is received. freq: the time to wait between intervals in absence of a Retry-After header. Allowed minimum is one second. A good starting value is 30 seconds. Note that some resources might benefit from a different value.

func (*SnapshotsUpdatePollerResponse) Resume 

func (l *SnapshotsUpdatePollerResponse) Resume(ctx context.Context, client *SnapshotsClient, token string) error

Resume rehydrates a SnapshotsUpdatePollerResponse from the provided client and resume token.

type SnapshotsUpdateResponse 

type SnapshotsUpdateResponse struct {
	SnapshotsUpdateResult
	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

SnapshotsUpdateResponse contains the response from method Snapshots.Update.

type SnapshotsUpdateResult 

type SnapshotsUpdateResult struct {
	Snapshot
}

SnapshotsUpdateResult contains the result from method Snapshots.Update.

type SubscriptionQuotaItem 

type SubscriptionQuotaItem struct {
	ProxyResource
	// SubscriptionQuotaItem properties
	Properties *SubscriptionQuotaItemProperties `json:"properties,omitempty"`

	// READ-ONLY; The system meta data relating to this resource.
	SystemData *SystemData `json:"systemData,omitempty" azure:"ro"`
}

SubscriptionQuotaItem - Information regarding Subscription Quota Item.

type SubscriptionQuotaItemList 

type SubscriptionQuotaItemList struct {
	// A list of SubscriptionQuotaItems
	Value []*SubscriptionQuotaItem `json:"value,omitempty"`
}

SubscriptionQuotaItemList - List of Subscription Quota Items

func (SubscriptionQuotaItemList) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type SubscriptionQuotaItemList.

type SubscriptionQuotaItemProperties 

type SubscriptionQuotaItemProperties struct {
	// READ-ONLY; The current quota value.
	Current *int32 `json:"current,omitempty" azure:"ro"`

	// READ-ONLY; The default quota value.
	Default *int32 `json:"default,omitempty" azure:"ro"`
}

SubscriptionQuotaItemProperties - SubscriptionQuotaItem Properties

type SystemData 

type SystemData struct {
	// The timestamp of resource creation (UTC).
	CreatedAt *time.Time `json:"createdAt,omitempty"`

	// The identity that created the resource.
	CreatedBy *string `json:"createdBy,omitempty"`

	// The type of identity that created the resource.
	CreatedByType *CreatedByType `json:"createdByType,omitempty"`

	// The timestamp of resource last modification (UTC)
	LastModifiedAt *time.Time `json:"lastModifiedAt,omitempty"`

	// The identity that last modified the resource.
	LastModifiedBy *string `json:"lastModifiedBy,omitempty"`

	// The type of identity that last modified the resource.
	LastModifiedByType *CreatedByType `json:"lastModifiedByType,omitempty"`
}

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 Vault 

type Vault struct {
	// REQUIRED; Resource location
	Location *string `json:"location,omitempty"`

	// REQUIRED; Vault Properties
	Properties *VaultProperties `json:"properties,omitempty"`

	// READ-ONLY; Resource Id
	ID *string `json:"id,omitempty" azure:"ro"`

	// READ-ONLY; Resource name
	Name *string `json:"name,omitempty" azure:"ro"`

	// READ-ONLY; Resource type
	Type *string `json:"type,omitempty" azure:"ro"`
}

Vault information

type VaultList 

type VaultList struct {
	// A list of vaults
	Value []*Vault `json:"value,omitempty"`
}

VaultList - List of Vaults

func (VaultList) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type VaultList.

type VaultProperties 

type VaultProperties struct {
	// Vault Name
	VaultName *string `json:"vaultName,omitempty"`
}

VaultProperties - Vault properties

type VaultsClient 

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

VaultsClient contains the methods for the Vaults group. Don't use this type directly, use NewVaultsClient() instead.

func NewVaultsClient 

func NewVaultsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) *VaultsClient

NewVaultsClient creates a new instance of VaultsClient with the specified values.

func (*VaultsClient) List 

func (client *VaultsClient) List(ctx context.Context, resourceGroupName string, accountName string, options *VaultsListOptions) (VaultsListResponse, error)

List - List vaults for a Netapp Account If the operation fails it returns a generic error.

Example

x-ms-original-file: specification/netapp/resource-manager/Microsoft.NetApp/stable/2021-08-01/examples/Vaults_List.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/netapp/armnetapp"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client := armnetapp.NewVaultsClient("<subscription-id>", cred, nil)
	_, err = client.List(ctx,
		"<resource-group-name>",
		"<account-name>",
		nil)
	if err != nil {
		log.Fatal(err)
	}
}

Output:

type VaultsListOptions 

type VaultsListOptions struct {
}

VaultsListOptions contains the optional parameters for the Vaults.List method.

type VaultsListResponse 

type VaultsListResponse struct {
	VaultsListResult
	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

VaultsListResponse contains the response from method Vaults.List.

type VaultsListResult 

type VaultsListResult struct {
	VaultList
}

VaultsListResult contains the result from method Vaults.List.

type Volume 

type Volume struct {
	// REQUIRED; Resource location
	Location *string `json:"location,omitempty"`

	// REQUIRED; Volume properties
	Properties *VolumeProperties `json:"properties,omitempty"`

	// Resource tags
	Tags map[string]*string `json:"tags,omitempty"`

	// READ-ONLY; A unique read-only string that changes whenever the resource is updated.
	Etag *string `json:"etag,omitempty" azure:"ro"`

	// READ-ONLY; Resource Id
	ID *string `json:"id,omitempty" azure:"ro"`

	// READ-ONLY; Resource name
	Name *string `json:"name,omitempty" azure:"ro"`

	// READ-ONLY; Resource type
	Type *string `json:"type,omitempty" azure:"ro"`
}

Volume resource

func (Volume) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type Volume.

type VolumeBackupProperties 

type VolumeBackupProperties struct {
	// Backup Enabled
	BackupEnabled *bool `json:"backupEnabled,omitempty"`

	// Backup Policy Resource ID
	BackupPolicyID *string `json:"backupPolicyId,omitempty"`

	// Policy Enforced
	PolicyEnforced *bool `json:"policyEnforced,omitempty"`

	// Vault Resource ID
	VaultID *string `json:"vaultId,omitempty"`
}

VolumeBackupProperties - Volume Backup Properties

type VolumeBackups 

type VolumeBackups struct {
	// Total count of backups for volume
	BackupsCount *int32 `json:"backupsCount,omitempty"`

	// Policy enabled
	PolicyEnabled *bool `json:"policyEnabled,omitempty"`

	// Volume name
	VolumeName *string `json:"volumeName,omitempty"`
}

VolumeBackups - Volume details using the backup policy

type VolumeGroup 

type VolumeGroup struct {
	// Resource location
	Location *string `json:"location,omitempty"`

	// Volume group properties
	Properties *VolumeGroupListProperties `json:"properties,omitempty"`

	// Resource tags
	Tags map[string]*string `json:"tags,omitempty"`

	// READ-ONLY; Resource Id
	ID *string `json:"id,omitempty" azure:"ro"`

	// READ-ONLY; Resource name
	Name *string `json:"name,omitempty" azure:"ro"`

	// READ-ONLY; Resource type
	Type *string `json:"type,omitempty" azure:"ro"`
}

VolumeGroup - Volume group resource

func (VolumeGroup) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type VolumeGroup.

type VolumeGroupDetails 

type VolumeGroupDetails struct {
	// Resource location
	Location *string `json:"location,omitempty"`

	// Volume group properties
	Properties *VolumeGroupProperties `json:"properties,omitempty"`

	// Resource tags
	Tags map[string]*string `json:"tags,omitempty"`

	// READ-ONLY; Resource Id
	ID *string `json:"id,omitempty" azure:"ro"`

	// READ-ONLY; Resource name
	Name *string `json:"name,omitempty" azure:"ro"`

	// READ-ONLY; Resource type
	Type *string `json:"type,omitempty" azure:"ro"`
}

VolumeGroupDetails - Volume group resource for create

func (VolumeGroupDetails) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type VolumeGroupDetails.

type VolumeGroupList 

type VolumeGroupList struct {
	// List of volume Groups
	Value []*VolumeGroup `json:"value,omitempty"`
}

VolumeGroupList - List of volume group resources

func (VolumeGroupList) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type VolumeGroupList.

type VolumeGroupListProperties 

type VolumeGroupListProperties struct {
	// Volume group details
	GroupMetaData *VolumeGroupMetaData `json:"groupMetaData,omitempty"`

	// READ-ONLY; Azure lifecycle management
	ProvisioningState *string `json:"provisioningState,omitempty" azure:"ro"`
}

VolumeGroupListProperties - Volume group properties

type VolumeGroupMetaData 

type VolumeGroupMetaData struct {
	// Application specific identifier
	ApplicationIdentifier *string `json:"applicationIdentifier,omitempty"`

	// Application Type
	ApplicationType *ApplicationType `json:"applicationType,omitempty"`

	// Application specific identifier of deployment rules for the volume group
	DeploymentSpecID *string `json:"deploymentSpecId,omitempty"`

	// Application specific placement rules for the volume group
	GlobalPlacementRules []*PlacementKeyValuePairs `json:"globalPlacementRules,omitempty"`

	// Group Description
	GroupDescription *string `json:"groupDescription,omitempty"`

	// READ-ONLY; Number of volumes in volume group
	VolumesCount *int64 `json:"volumesCount,omitempty" azure:"ro"`
}

VolumeGroupMetaData - Volume group properties

func (VolumeGroupMetaData) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type VolumeGroupMetaData.

type VolumeGroupProperties 

type VolumeGroupProperties struct {
	// Volume group details
	GroupMetaData *VolumeGroupMetaData `json:"groupMetaData,omitempty"`

	// List of volumes from group
	Volumes []*VolumeGroupVolumeProperties `json:"volumes,omitempty"`

	// READ-ONLY; Azure lifecycle management
	ProvisioningState *string `json:"provisioningState,omitempty" azure:"ro"`
}

VolumeGroupProperties - Volume group properties

func (VolumeGroupProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type VolumeGroupProperties.

type VolumeGroupVolumeProperties 

type VolumeGroupVolumeProperties struct {
	// REQUIRED; Volume properties
	Properties *VolumeProperties `json:"properties,omitempty"`

	// Resource name
	Name *string `json:"name,omitempty"`

	// Resource tags
	Tags map[string]*string `json:"tags,omitempty"`

	// READ-ONLY; Resource Id
	ID *string `json:"id,omitempty" azure:"ro"`

	// READ-ONLY; Resource type
	Type *string `json:"type,omitempty" azure:"ro"`
}

VolumeGroupVolumeProperties - Volume resource

func (VolumeGroupVolumeProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type VolumeGroupVolumeProperties.

type VolumeGroupsBeginCreateOptions 

type VolumeGroupsBeginCreateOptions struct {
}

VolumeGroupsBeginCreateOptions contains the optional parameters for the VolumeGroups.BeginCreate method.

type VolumeGroupsBeginDeleteOptions 

type VolumeGroupsBeginDeleteOptions struct {
}

VolumeGroupsBeginDeleteOptions contains the optional parameters for the VolumeGroups.BeginDelete method.

type VolumeGroupsClient 

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

VolumeGroupsClient contains the methods for the VolumeGroups group. Don't use this type directly, use NewVolumeGroupsClient() instead.

func NewVolumeGroupsClient 

func NewVolumeGroupsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) *VolumeGroupsClient

NewVolumeGroupsClient creates a new instance of VolumeGroupsClient with the specified values.

func (*VolumeGroupsClient) BeginCreate 

func (client *VolumeGroupsClient) BeginCreate(ctx context.Context, resourceGroupName string, accountName string, volumeGroupName string, body VolumeGroupDetails, options *VolumeGroupsBeginCreateOptions) (VolumeGroupsCreatePollerResponse, error)

BeginCreate - Create a volume group along with specified volumes If the operation fails it returns a generic error.

Example

x-ms-original-file: specification/netapp/resource-manager/Microsoft.NetApp/stable/2021-08-01/examples/VolumeGroups_Create.json 

package main

import (
	"context"
	"log"

	"time"

	"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/netapp/armnetapp"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client := armnetapp.NewVolumeGroupsClient("<subscription-id>", cred, nil)
	poller, err := client.BeginCreate(ctx,
		"<resource-group-name>",
		"<account-name>",
		"<volume-group-name>",
		armnetapp.VolumeGroupDetails{
			Location: to.StringPtr("<location>"),
			Properties: &armnetapp.VolumeGroupProperties{
				GroupMetaData: &armnetapp.VolumeGroupMetaData{
					ApplicationIdentifier: to.StringPtr("<application-identifier>"),
					ApplicationType:       armnetapp.ApplicationTypeSAPHANA.ToPtr(),
					DeploymentSpecID:      to.StringPtr("<deployment-spec-id>"),
					GroupDescription:      to.StringPtr("<group-description>"),
				},
				Volumes: []*armnetapp.VolumeGroupVolumeProperties{
					{
						Name: to.StringPtr("<name>"),
						Properties: &armnetapp.VolumeProperties{
							CapacityPoolResourceID:  to.StringPtr("<capacity-pool-resource-id>"),
							CreationToken:           to.StringPtr("<creation-token>"),
							ProximityPlacementGroup: to.StringPtr("<proximity-placement-group>"),
							ServiceLevel:            armnetapp.ServiceLevelPremium.ToPtr(),
							SubnetID:                to.StringPtr("<subnet-id>"),
							ThroughputMibps:         to.Float32Ptr(10),
							UsageThreshold:          to.Int64Ptr(107374182400),
							VolumeSpecName:          to.StringPtr("<volume-spec-name>"),
						},
					},
					{
						Name: to.StringPtr("<name>"),
						Properties: &armnetapp.VolumeProperties{
							CapacityPoolResourceID:  to.StringPtr("<capacity-pool-resource-id>"),
							CreationToken:           to.StringPtr("<creation-token>"),
							ProximityPlacementGroup: to.StringPtr("<proximity-placement-group>"),
							ServiceLevel:            armnetapp.ServiceLevelPremium.ToPtr(),
							SubnetID:                to.StringPtr("<subnet-id>"),
							ThroughputMibps:         to.Float32Ptr(10),
							UsageThreshold:          to.Int64Ptr(107374182400),
							VolumeSpecName:          to.StringPtr("<volume-spec-name>"),
						},
					},
					{
						Name: to.StringPtr("<name>"),
						Properties: &armnetapp.VolumeProperties{
							CapacityPoolResourceID:  to.StringPtr("<capacity-pool-resource-id>"),
							CreationToken:           to.StringPtr("<creation-token>"),
							ProximityPlacementGroup: to.StringPtr("<proximity-placement-group>"),
							ServiceLevel:            armnetapp.ServiceLevelPremium.ToPtr(),
							SubnetID:                to.StringPtr("<subnet-id>"),
							ThroughputMibps:         to.Float32Ptr(10),
							UsageThreshold:          to.Int64Ptr(107374182400),
							VolumeSpecName:          to.StringPtr("<volume-spec-name>"),
						},
					}},
			},
		},
		nil)
	if err != nil {
		log.Fatal(err)
	}
	res, err := poller.PollUntilDone(ctx, 30*time.Second)
	if err != nil {
		log.Fatal(err)
	}
	log.Printf("VolumeGroupDetails.ID: %s\n", *res.ID)
}

Output:

func (*VolumeGroupsClient) BeginDelete 

func (client *VolumeGroupsClient) BeginDelete(ctx context.Context, resourceGroupName string, accountName string, volumeGroupName string, options *VolumeGroupsBeginDeleteOptions) (VolumeGroupsDeletePollerResponse, error)

BeginDelete - Delete the specified volume group only if there are no volumes under volume group. If the operation fails it returns a generic error.

Example

x-ms-original-file: specification/netapp/resource-manager/Microsoft.NetApp/stable/2021-08-01/examples/VolumeGroups_Delete.json 

package main

import (
	"context"
	"log"

	"time"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/netapp/armnetapp"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client := armnetapp.NewVolumeGroupsClient("<subscription-id>", cred, nil)
	poller, err := client.BeginDelete(ctx,
		"<resource-group-name>",
		"<account-name>",
		"<volume-group-name>",
		nil)
	if err != nil {
		log.Fatal(err)
	}
	_, err = poller.PollUntilDone(ctx, 30*time.Second)
	if err != nil {
		log.Fatal(err)
	}
}

Output:

func (*VolumeGroupsClient) Get 

func (client *VolumeGroupsClient) Get(ctx context.Context, resourceGroupName string, accountName string, volumeGroupName string, options *VolumeGroupsGetOptions) (VolumeGroupsGetResponse, error)

Get - Get details of the specified volume group If the operation fails it returns a generic error.

Example

x-ms-original-file: specification/netapp/resource-manager/Microsoft.NetApp/stable/2021-08-01/examples/VolumeGroups_Get.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/netapp/armnetapp"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client := armnetapp.NewVolumeGroupsClient("<subscription-id>", cred, nil)
	res, err := client.Get(ctx,
		"<resource-group-name>",
		"<account-name>",
		"<volume-group-name>",
		nil)
	if err != nil {
		log.Fatal(err)
	}
	log.Printf("VolumeGroupDetails.ID: %s\n", *res.ID)
}

Output:

func (*VolumeGroupsClient) ListByNetAppAccount 

func (client *VolumeGroupsClient) ListByNetAppAccount(ctx context.Context, resourceGroupName string, accountName string, options *VolumeGroupsListByNetAppAccountOptions) (VolumeGroupsListByNetAppAccountResponse, error)

ListByNetAppAccount - List all volume groups for given account If the operation fails it returns a generic error.

Example

x-ms-original-file: specification/netapp/resource-manager/Microsoft.NetApp/stable/2021-08-01/examples/VolumeGroups_List.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/netapp/armnetapp"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client := armnetapp.NewVolumeGroupsClient("<subscription-id>", cred, nil)
	_, err = client.ListByNetAppAccount(ctx,
		"<resource-group-name>",
		"<account-name>",
		nil)
	if err != nil {
		log.Fatal(err)
	}
}

Output:

type VolumeGroupsCreatePoller 

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

VolumeGroupsCreatePoller provides polling facilities until the operation reaches a terminal state.

func (*VolumeGroupsCreatePoller) Done 

func (p *VolumeGroupsCreatePoller) Done() bool

Done returns true if the LRO has reached a terminal state.

func (*VolumeGroupsCreatePoller) FinalResponse 

func (p *VolumeGroupsCreatePoller) FinalResponse(ctx context.Context) (VolumeGroupsCreateResponse, error)

FinalResponse performs a final GET to the service and returns the final response for the polling operation. If there is an error performing the final GET then an error is returned. If the final GET succeeded then the final VolumeGroupsCreateResponse will be returned.

func (*VolumeGroupsCreatePoller) Poll 

func (p *VolumeGroupsCreatePoller) Poll(ctx context.Context) (*http.Response, error)

Poll fetches the latest state of the LRO. It returns an HTTP response or error. If the LRO has completed successfully, the poller's state is updated and the HTTP response is returned. If the LRO has completed with failure or was cancelled, the poller's state is updated and the error is returned. If the LRO has not reached a terminal state, the poller's state is updated and the latest HTTP response is returned. If Poll fails, the poller's state is unmodified and the error is returned. Calling Poll on an LRO that has reached a terminal state will return the final HTTP response or error.

func (*VolumeGroupsCreatePoller) ResumeToken 

func (p *VolumeGroupsCreatePoller) ResumeToken() (string, error)

ResumeToken returns a value representing the poller that can be used to resume the LRO at a later time. ResumeTokens are unique per service operation.

type VolumeGroupsCreatePollerResponse 

type VolumeGroupsCreatePollerResponse struct {
	// Poller contains an initialized poller.
	Poller *VolumeGroupsCreatePoller

	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

VolumeGroupsCreatePollerResponse contains the response from method VolumeGroups.Create.

func (VolumeGroupsCreatePollerResponse) PollUntilDone 

func (l VolumeGroupsCreatePollerResponse) PollUntilDone(ctx context.Context, freq time.Duration) (VolumeGroupsCreateResponse, error)

PollUntilDone will poll the service endpoint until a terminal state is reached or an error is received. freq: the time to wait between intervals in absence of a Retry-After header. Allowed minimum is one second. A good starting value is 30 seconds. Note that some resources might benefit from a different value.

func (*VolumeGroupsCreatePollerResponse) Resume 

func (l *VolumeGroupsCreatePollerResponse) Resume(ctx context.Context, client *VolumeGroupsClient, token string) error

Resume rehydrates a VolumeGroupsCreatePollerResponse from the provided client and resume token.

type VolumeGroupsCreateResponse 

type VolumeGroupsCreateResponse struct {
	VolumeGroupsCreateResult
	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

VolumeGroupsCreateResponse contains the response from method VolumeGroups.Create.

type VolumeGroupsCreateResult 

type VolumeGroupsCreateResult struct {
	VolumeGroupDetails
}

VolumeGroupsCreateResult contains the result from method VolumeGroups.Create.

type VolumeGroupsDeletePoller 

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

VolumeGroupsDeletePoller provides polling facilities until the operation reaches a terminal state.

func (*VolumeGroupsDeletePoller) Done 

func (p *VolumeGroupsDeletePoller) Done() bool

Done returns true if the LRO has reached a terminal state.

func (*VolumeGroupsDeletePoller) FinalResponse 

func (p *VolumeGroupsDeletePoller) FinalResponse(ctx context.Context) (VolumeGroupsDeleteResponse, error)

FinalResponse performs a final GET to the service and returns the final response for the polling operation. If there is an error performing the final GET then an error is returned. If the final GET succeeded then the final VolumeGroupsDeleteResponse will be returned.

func (*VolumeGroupsDeletePoller) Poll 

func (p *VolumeGroupsDeletePoller) Poll(ctx context.Context) (*http.Response, error)

Poll fetches the latest state of the LRO. It returns an HTTP response or error. If the LRO has completed successfully, the poller's state is updated and the HTTP response is returned. If the LRO has completed with failure or was cancelled, the poller's state is updated and the error is returned. If the LRO has not reached a terminal state, the poller's state is updated and the latest HTTP response is returned. If Poll fails, the poller's state is unmodified and the error is returned. Calling Poll on an LRO that has reached a terminal state will return the final HTTP response or error.

func (*VolumeGroupsDeletePoller) ResumeToken 

func (p *VolumeGroupsDeletePoller) ResumeToken() (string, error)

ResumeToken returns a value representing the poller that can be used to resume the LRO at a later time. ResumeTokens are unique per service operation.

type VolumeGroupsDeletePollerResponse 

type VolumeGroupsDeletePollerResponse struct {
	// Poller contains an initialized poller.
	Poller *VolumeGroupsDeletePoller

	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

VolumeGroupsDeletePollerResponse contains the response from method VolumeGroups.Delete.

func (VolumeGroupsDeletePollerResponse) PollUntilDone 

func (l VolumeGroupsDeletePollerResponse) PollUntilDone(ctx context.Context, freq time.Duration) (VolumeGroupsDeleteResponse, error)

PollUntilDone will poll the service endpoint until a terminal state is reached or an error is received. freq: the time to wait between intervals in absence of a Retry-After header. Allowed minimum is one second. A good starting value is 30 seconds. Note that some resources might benefit from a different value.

func (*VolumeGroupsDeletePollerResponse) Resume 

func (l *VolumeGroupsDeletePollerResponse) Resume(ctx context.Context, client *VolumeGroupsClient, token string) error

Resume rehydrates a VolumeGroupsDeletePollerResponse from the provided client and resume token.

type VolumeGroupsDeleteResponse 

type VolumeGroupsDeleteResponse struct {
	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

VolumeGroupsDeleteResponse contains the response from method VolumeGroups.Delete.

type VolumeGroupsGetOptions 

type VolumeGroupsGetOptions struct {
}

VolumeGroupsGetOptions contains the optional parameters for the VolumeGroups.Get method.

type VolumeGroupsGetResponse 

type VolumeGroupsGetResponse struct {
	VolumeGroupsGetResult
	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

VolumeGroupsGetResponse contains the response from method VolumeGroups.Get.

type VolumeGroupsGetResult 

type VolumeGroupsGetResult struct {
	VolumeGroupDetails
}

VolumeGroupsGetResult contains the result from method VolumeGroups.Get.

type VolumeGroupsListByNetAppAccountOptions 

type VolumeGroupsListByNetAppAccountOptions struct {
}

VolumeGroupsListByNetAppAccountOptions contains the optional parameters for the VolumeGroups.ListByNetAppAccount method.

type VolumeGroupsListByNetAppAccountResponse 

type VolumeGroupsListByNetAppAccountResponse struct {
	VolumeGroupsListByNetAppAccountResult
	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

VolumeGroupsListByNetAppAccountResponse contains the response from method VolumeGroups.ListByNetAppAccount.

type VolumeGroupsListByNetAppAccountResult 

type VolumeGroupsListByNetAppAccountResult struct {
	VolumeGroupList
}

VolumeGroupsListByNetAppAccountResult contains the result from method VolumeGroups.ListByNetAppAccount.

type VolumeList 

type VolumeList struct {
	// URL to get the next set of results.
	NextLink *string `json:"nextLink,omitempty"`

	// List of volumes
	Value []*Volume `json:"value,omitempty"`
}

VolumeList - List of volume resources

func (VolumeList) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type VolumeList.

type VolumePatch 

type VolumePatch struct {
	// Resource location
	Location *string `json:"location,omitempty"`

	// Patchable volume properties
	Properties *VolumePatchProperties `json:"properties,omitempty"`

	// Resource tags
	Tags map[string]*string `json:"tags,omitempty"`

	// READ-ONLY; Resource Id
	ID *string `json:"id,omitempty" azure:"ro"`

	// READ-ONLY; Resource name
	Name *string `json:"name,omitempty" azure:"ro"`

	// READ-ONLY; Resource type
	Type *string `json:"type,omitempty" azure:"ro"`
}

VolumePatch - Volume patch resource

func (VolumePatch) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type VolumePatch.

type VolumePatchProperties 

type VolumePatchProperties struct {
	// DataProtection type volumes include an object containing details of the replication
	DataProtection *VolumePatchPropertiesDataProtection `json:"dataProtection,omitempty"`

	// Default group quota for volume in KiBs. If isDefaultQuotaEnabled is set, the minimum value of 4 KiBs applies.
	DefaultGroupQuotaInKiBs *int64 `json:"defaultGroupQuotaInKiBs,omitempty"`

	// Default user quota for volume in KiBs. If isDefaultQuotaEnabled is set, the minimum value of 4 KiBs applies .
	DefaultUserQuotaInKiBs *int64 `json:"defaultUserQuotaInKiBs,omitempty"`

	// Set of export policy rules
	ExportPolicy *VolumePatchPropertiesExportPolicy `json:"exportPolicy,omitempty"`

	// Specifies if default quota is enabled for the volume.
	IsDefaultQuotaEnabled *bool `json:"isDefaultQuotaEnabled,omitempty"`

	// The service level of the file system
	ServiceLevel *ServiceLevel `json:"serviceLevel,omitempty"`

	// Maximum throughput in Mibps that can be achieved by this volume and this will be accepted as input only for manual qosType volume
	ThroughputMibps *float32 `json:"throughputMibps,omitempty"`

	// Maximum storage quota allowed for a file system in bytes. This is a soft quota used for alerting only. Minimum size is 100 GiB. Upper limit is 100TiB.
	// Specified in bytes.
	UsageThreshold *int64 `json:"usageThreshold,omitempty"`
}

VolumePatchProperties - Patchable volume properties

type VolumePatchPropertiesDataProtection 

type VolumePatchPropertiesDataProtection struct {
	// Backup Properties
	Backup *VolumeBackupProperties `json:"backup,omitempty"`

	// Snapshot properties.
	Snapshot *VolumeSnapshotProperties `json:"snapshot,omitempty"`
}

VolumePatchPropertiesDataProtection - DataProtection type volumes include an object containing details of the replication

type VolumePatchPropertiesExportPolicy 

type VolumePatchPropertiesExportPolicy struct {
	// Export policy rule
	Rules []*ExportPolicyRule `json:"rules,omitempty"`
}

VolumePatchPropertiesExportPolicy - Set of export policy rules

func (VolumePatchPropertiesExportPolicy) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type VolumePatchPropertiesExportPolicy.

type VolumeProperties 

type VolumeProperties struct {
	// REQUIRED; A unique file path for the volume. Used when creating mount targets
	CreationToken *string `json:"creationToken,omitempty"`

	// REQUIRED; The Azure Resource URI for a delegated subnet. Must have the delegation Microsoft.NetApp/volumes
	SubnetID *string `json:"subnetId,omitempty"`

	// REQUIRED; Maximum storage quota allowed for a file system in bytes. This is a soft quota used for alerting only. Minimum size is 100 GiB. Upper limit
	// is 100TiB. Specified in bytes.
	UsageThreshold *int64 `json:"usageThreshold,omitempty"`

	// Specifies whether the volume is enabled for Azure VMware Solution (AVS) datastore purpose
	AvsDataStore *AvsDataStore `json:"avsDataStore,omitempty"`

	// UUID v4 or resource identifier used to identify the Backup.
	BackupID *string `json:"backupId,omitempty"`

	// Pool Resource Id used in case of creating a volume through volume group
	CapacityPoolResourceID *string `json:"capacityPoolResourceId,omitempty"`

	// Specifies whether Cool Access(tiering) is enabled for the volume.
	CoolAccess *bool `json:"coolAccess,omitempty"`

	// Specifies the number of days after which data that is not accessed by clients will be tiered.
	CoolnessPeriod *int32 `json:"coolnessPeriod,omitempty"`

	// DataProtection type volumes include an object containing details of the replication
	DataProtection *VolumePropertiesDataProtection `json:"dataProtection,omitempty"`

	// Default group quota for volume in KiBs. If isDefaultQuotaEnabled is set, the minimum value of 4 KiBs applies.
	DefaultGroupQuotaInKiBs *int64 `json:"defaultGroupQuotaInKiBs,omitempty"`

	// Default user quota for volume in KiBs. If isDefaultQuotaEnabled is set, the minimum value of 4 KiBs applies .
	DefaultUserQuotaInKiBs *int64 `json:"defaultUserQuotaInKiBs,omitempty"`

	// Encryption Key Source. Possible values are: 'Microsoft.NetApp'
	EncryptionKeySource *string `json:"encryptionKeySource,omitempty"`

	// Set of export policy rules
	ExportPolicy *VolumePropertiesExportPolicy `json:"exportPolicy,omitempty"`

	// Specifies if default quota is enabled for the volume.
	IsDefaultQuotaEnabled *bool `json:"isDefaultQuotaEnabled,omitempty"`

	// Restoring
	IsRestoring *bool `json:"isRestoring,omitempty"`

	// Describe if a volume is KerberosEnabled. To be use with swagger version 2020-05-01 or later
	KerberosEnabled *bool `json:"kerberosEnabled,omitempty"`

	// Specifies whether LDAP is enabled or not for a given NFS volume.
	LdapEnabled *bool `json:"ldapEnabled,omitempty"`

	// Basic network, or Standard features available to the volume.
	NetworkFeatures *NetworkFeatures `json:"networkFeatures,omitempty"`

	// Application specific placement rules for the particular volume
	PlacementRules []*PlacementKeyValuePairs `json:"placementRules,omitempty"`

	// Set of protocol types, default NFSv3, CIFS for SMB protocol
	ProtocolTypes []*string `json:"protocolTypes,omitempty"`

	// Proximity placement group associated with the volume
	ProximityPlacementGroup *string `json:"proximityPlacementGroup,omitempty"`

	// The security style of volume, default unix, defaults to ntfs for dual protocol or CIFS protocol
	SecurityStyle *SecurityStyle `json:"securityStyle,omitempty"`

	// The service level of the file system
	ServiceLevel *ServiceLevel `json:"serviceLevel,omitempty"`

	// Enables continuously available share property for smb volume. Only applicable for SMB volume
	SmbContinuouslyAvailable *bool `json:"smbContinuouslyAvailable,omitempty"`

	// Enables encryption for in-flight smb3 data. Only applicable for SMB/DualProtocol volume. To be used with swagger version 2020-08-01 or later
	SmbEncryption *bool `json:"smbEncryption,omitempty"`

	// If enabled (true) the volume will contain a read-only snapshot directory which provides access to each of the volume's snapshots (default to true).
	SnapshotDirectoryVisible *bool `json:"snapshotDirectoryVisible,omitempty"`

	// UUID v4 or resource identifier used to identify the Snapshot.
	SnapshotID *string `json:"snapshotId,omitempty"`

	// Maximum throughput in Mibps that can be achieved by this volume and this will be accepted as input only for manual qosType volume
	ThroughputMibps *float32 `json:"throughputMibps,omitempty"`

	// UNIX permissions for NFS volume accepted in octal 4 digit format. First digit selects the set user ID(4), set group ID (2) and sticky (1) attributes.
	// Second digit selects permission for the owner of
	// the file: read (4), write (2) and execute (1). Third selects permissions for other users in the same group. the fourth for other users not in the group.
	// 0755 - gives read/write/execute permissions to
	// owner and read/execute to group and other users.
	UnixPermissions *string `json:"unixPermissions,omitempty"`

	// Volume spec name is the application specific designation or identifier for the particular volume in a volume group for e.g. data, log
	VolumeSpecName *string `json:"volumeSpecName,omitempty"`

	// What type of volume is this. For destination volumes in Cross Region Replication, set type to DataProtection
	VolumeType *string `json:"volumeType,omitempty"`

	// READ-ONLY; Unique Baremetal Tenant Identifier.
	BaremetalTenantID *string `json:"baremetalTenantId,omitempty" azure:"ro"`

	// READ-ONLY; When a volume is being restored from another volume's snapshot, will show the percentage completion of this cloning process. When this value
	// is empty/null there is no cloning process currently
	// happening on this volume. This value will update every 5 minutes during cloning.
	CloneProgress *int32 `json:"cloneProgress,omitempty" azure:"ro"`

	// READ-ONLY; Unique FileSystem Identifier.
	FileSystemID *string `json:"fileSystemId,omitempty" azure:"ro"`

	// READ-ONLY; List of mount targets
	MountTargets []*MountTargetProperties `json:"mountTargets,omitempty" azure:"ro"`

	// READ-ONLY; Network Sibling Set ID for the the group of volumes sharing networking resources.
	NetworkSiblingSetID *string `json:"networkSiblingSetId,omitempty" azure:"ro"`

	// READ-ONLY; Azure lifecycle management
	ProvisioningState *string `json:"provisioningState,omitempty" azure:"ro"`

	// READ-ONLY; Provides storage to network proximity information for the volume.
	StorageToNetworkProximity *VolumeStorageToNetworkProximity `json:"storageToNetworkProximity,omitempty" azure:"ro"`

	// READ-ONLY; T2 network information
	T2Network *string `json:"t2Network,omitempty" azure:"ro"`

	// READ-ONLY; Volume Group Name
	VolumeGroupName *string `json:"volumeGroupName,omitempty" azure:"ro"`
}

VolumeProperties - Volume properties

func (VolumeProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type VolumeProperties.

type VolumePropertiesDataProtection 

type VolumePropertiesDataProtection struct {
	// Backup Properties
	Backup *VolumeBackupProperties `json:"backup,omitempty"`

	// Replication properties
	Replication *ReplicationObject `json:"replication,omitempty"`

	// Snapshot properties.
	Snapshot *VolumeSnapshotProperties `json:"snapshot,omitempty"`
}

VolumePropertiesDataProtection - DataProtection type volumes include an object containing details of the replication

type VolumePropertiesExportPolicy 

type VolumePropertiesExportPolicy struct {
	// Export policy rule
	Rules []*ExportPolicyRule `json:"rules,omitempty"`
}

VolumePropertiesExportPolicy - Set of export policy rules

func (VolumePropertiesExportPolicy) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type VolumePropertiesExportPolicy.

type VolumeRevert 

type VolumeRevert struct {
	// Resource id of the snapshot
	SnapshotID *string `json:"snapshotId,omitempty"`
}

VolumeRevert - revert a volume to the snapshot

type VolumeSnapshotProperties 

type VolumeSnapshotProperties struct {
	// Snapshot Policy ResourceId
	SnapshotPolicyID *string `json:"snapshotPolicyId,omitempty"`
}

VolumeSnapshotProperties - Volume Snapshot Properties

type VolumeStorageToNetworkProximity 

type VolumeStorageToNetworkProximity string

VolumeStorageToNetworkProximity - Provides storage to network proximity information for the volume. 

const (
	// VolumeStorageToNetworkProximityDefault - Basic storage to network connectivity.
	VolumeStorageToNetworkProximityDefault VolumeStorageToNetworkProximity = "Default"
	// VolumeStorageToNetworkProximityT1 - Standard T1 storage to network connectivity.
	VolumeStorageToNetworkProximityT1 VolumeStorageToNetworkProximity = "T1"
	// VolumeStorageToNetworkProximityT2 - Standard T2 storage to network connectivity.
	VolumeStorageToNetworkProximityT2 VolumeStorageToNetworkProximity = "T2"
)

func PossibleVolumeStorageToNetworkProximityValues 

func PossibleVolumeStorageToNetworkProximityValues() []VolumeStorageToNetworkProximity

PossibleVolumeStorageToNetworkProximityValues returns the possible values for the VolumeStorageToNetworkProximity const type.

func (VolumeStorageToNetworkProximity) ToPtr 

func (c VolumeStorageToNetworkProximity) ToPtr() *VolumeStorageToNetworkProximity

ToPtr returns a *VolumeStorageToNetworkProximity pointing to the current value.

type VolumesAuthorizeReplicationPoller 

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

VolumesAuthorizeReplicationPoller provides polling facilities until the operation reaches a terminal state.

func (*VolumesAuthorizeReplicationPoller) Done 

func (p *VolumesAuthorizeReplicationPoller) Done() bool

Done returns true if the LRO has reached a terminal state.

func (*VolumesAuthorizeReplicationPoller) FinalResponse 

func (p *VolumesAuthorizeReplicationPoller) FinalResponse(ctx context.Context) (VolumesAuthorizeReplicationResponse, error)

FinalResponse performs a final GET to the service and returns the final response for the polling operation. If there is an error performing the final GET then an error is returned. If the final GET succeeded then the final VolumesAuthorizeReplicationResponse will be returned.

func (*VolumesAuthorizeReplicationPoller) Poll 

func (p *VolumesAuthorizeReplicationPoller) Poll(ctx context.Context) (*http.Response, error)

Poll fetches the latest state of the LRO. It returns an HTTP response or error. If the LRO has completed successfully, the poller's state is updated and the HTTP response is returned. If the LRO has completed with failure or was cancelled, the poller's state is updated and the error is returned. If the LRO has not reached a terminal state, the poller's state is updated and the latest HTTP response is returned. If Poll fails, the poller's state is unmodified and the error is returned. Calling Poll on an LRO that has reached a terminal state will return the final HTTP response or error.

func (*VolumesAuthorizeReplicationPoller) ResumeToken 

func (p *VolumesAuthorizeReplicationPoller) ResumeToken() (string, error)

ResumeToken returns a value representing the poller that can be used to resume the LRO at a later time. ResumeTokens are unique per service operation.

type VolumesAuthorizeReplicationPollerResponse 

type VolumesAuthorizeReplicationPollerResponse struct {
	// Poller contains an initialized poller.
	Poller *VolumesAuthorizeReplicationPoller

	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

VolumesAuthorizeReplicationPollerResponse contains the response from method Volumes.AuthorizeReplication.

func (VolumesAuthorizeReplicationPollerResponse) PollUntilDone 

func (l VolumesAuthorizeReplicationPollerResponse) PollUntilDone(ctx context.Context, freq time.Duration) (VolumesAuthorizeReplicationResponse, error)

PollUntilDone will poll the service endpoint until a terminal state is reached or an error is received. freq: the time to wait between intervals in absence of a Retry-After header. Allowed minimum is one second. A good starting value is 30 seconds. Note that some resources might benefit from a different value.

func (*VolumesAuthorizeReplicationPollerResponse) Resume 

func (l *VolumesAuthorizeReplicationPollerResponse) Resume(ctx context.Context, client *VolumesClient, token string) error

Resume rehydrates a VolumesAuthorizeReplicationPollerResponse from the provided client and resume token.

type VolumesAuthorizeReplicationResponse 

type VolumesAuthorizeReplicationResponse struct {
	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

VolumesAuthorizeReplicationResponse contains the response from method Volumes.AuthorizeReplication.

type VolumesBeginAuthorizeReplicationOptions 

type VolumesBeginAuthorizeReplicationOptions struct {
}

VolumesBeginAuthorizeReplicationOptions contains the optional parameters for the Volumes.BeginAuthorizeReplication method.

type VolumesBeginBreakReplicationOptions 

type VolumesBeginBreakReplicationOptions struct {
	// Optional body to force break the replication.
	Body *BreakReplicationRequest
}

VolumesBeginBreakReplicationOptions contains the optional parameters for the Volumes.BeginBreakReplication method.

type VolumesBeginCreateOrUpdateOptions 

type VolumesBeginCreateOrUpdateOptions struct {
}

VolumesBeginCreateOrUpdateOptions contains the optional parameters for the Volumes.BeginCreateOrUpdate method.

type VolumesBeginDeleteOptions 

type VolumesBeginDeleteOptions struct {
}

VolumesBeginDeleteOptions contains the optional parameters for the Volumes.BeginDelete method.

type VolumesBeginDeleteReplicationOptions 

type VolumesBeginDeleteReplicationOptions struct {
}

VolumesBeginDeleteReplicationOptions contains the optional parameters for the Volumes.BeginDeleteReplication method.

type VolumesBeginPoolChangeOptions 

type VolumesBeginPoolChangeOptions struct {
}

VolumesBeginPoolChangeOptions contains the optional parameters for the Volumes.BeginPoolChange method.

type VolumesBeginReInitializeReplicationOptions 

type VolumesBeginReInitializeReplicationOptions struct {
}

VolumesBeginReInitializeReplicationOptions contains the optional parameters for the Volumes.BeginReInitializeReplication method.

type VolumesBeginResyncReplicationOptions 

type VolumesBeginResyncReplicationOptions struct {
}

VolumesBeginResyncReplicationOptions contains the optional parameters for the Volumes.BeginResyncReplication method.

type VolumesBeginRevertOptions 

type VolumesBeginRevertOptions struct {
}

VolumesBeginRevertOptions contains the optional parameters for the Volumes.BeginRevert method.

type VolumesBeginUpdateOptions 

type VolumesBeginUpdateOptions struct {
}

VolumesBeginUpdateOptions contains the optional parameters for the Volumes.BeginUpdate method.

type VolumesBreakReplicationPoller 

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

VolumesBreakReplicationPoller provides polling facilities until the operation reaches a terminal state.

func (*VolumesBreakReplicationPoller) Done 

func (p *VolumesBreakReplicationPoller) Done() bool

Done returns true if the LRO has reached a terminal state.

func (*VolumesBreakReplicationPoller) FinalResponse 

func (p *VolumesBreakReplicationPoller) FinalResponse(ctx context.Context) (VolumesBreakReplicationResponse, error)

FinalResponse performs a final GET to the service and returns the final response for the polling operation. If there is an error performing the final GET then an error is returned. If the final GET succeeded then the final VolumesBreakReplicationResponse will be returned.

func (*VolumesBreakReplicationPoller) Poll 

func (p *VolumesBreakReplicationPoller) Poll(ctx context.Context) (*http.Response, error)

Poll fetches the latest state of the LRO. It returns an HTTP response or error. If the LRO has completed successfully, the poller's state is updated and the HTTP response is returned. If the LRO has completed with failure or was cancelled, the poller's state is updated and the error is returned. If the LRO has not reached a terminal state, the poller's state is updated and the latest HTTP response is returned. If Poll fails, the poller's state is unmodified and the error is returned. Calling Poll on an LRO that has reached a terminal state will return the final HTTP response or error.

func (*VolumesBreakReplicationPoller) ResumeToken 

func (p *VolumesBreakReplicationPoller) ResumeToken() (string, error)

ResumeToken returns a value representing the poller that can be used to resume the LRO at a later time. ResumeTokens are unique per service operation.

type VolumesBreakReplicationPollerResponse 

type VolumesBreakReplicationPollerResponse struct {
	// Poller contains an initialized poller.
	Poller *VolumesBreakReplicationPoller

	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

VolumesBreakReplicationPollerResponse contains the response from method Volumes.BreakReplication.

func (VolumesBreakReplicationPollerResponse) PollUntilDone 

func (l VolumesBreakReplicationPollerResponse) PollUntilDone(ctx context.Context, freq time.Duration) (VolumesBreakReplicationResponse, error)

PollUntilDone will poll the service endpoint until a terminal state is reached or an error is received. freq: the time to wait between intervals in absence of a Retry-After header. Allowed minimum is one second. A good starting value is 30 seconds. Note that some resources might benefit from a different value.

func (*VolumesBreakReplicationPollerResponse) Resume 

func (l *VolumesBreakReplicationPollerResponse) Resume(ctx context.Context, client *VolumesClient, token string) error

Resume rehydrates a VolumesBreakReplicationPollerResponse from the provided client and resume token.

type VolumesBreakReplicationResponse 

type VolumesBreakReplicationResponse struct {
	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

VolumesBreakReplicationResponse contains the response from method Volumes.BreakReplication.

type VolumesClient 

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

VolumesClient contains the methods for the Volumes group. Don't use this type directly, use NewVolumesClient() instead.

func NewVolumesClient 

func NewVolumesClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) *VolumesClient

NewVolumesClient creates a new instance of VolumesClient with the specified values.

func (*VolumesClient) BeginAuthorizeReplication 

func (client *VolumesClient) BeginAuthorizeReplication(ctx context.Context, resourceGroupName string, accountName string, poolName string, volumeName string, body AuthorizeRequest, options *VolumesBeginAuthorizeReplicationOptions) (VolumesAuthorizeReplicationPollerResponse, error)

BeginAuthorizeReplication - Authorize the replication connection on the source volume If the operation fails it returns a generic error.

Example

x-ms-original-file: specification/netapp/resource-manager/Microsoft.NetApp/stable/2021-08-01/examples/Volumes_AuthorizeReplication.json 

package main

import (
	"context"
	"log"

	"time"

	"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/netapp/armnetapp"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client := armnetapp.NewVolumesClient("<subscription-id>", cred, nil)
	poller, err := client.BeginAuthorizeReplication(ctx,
		"<resource-group-name>",
		"<account-name>",
		"<pool-name>",
		"<volume-name>",
		armnetapp.AuthorizeRequest{
			RemoteVolumeResourceID: to.StringPtr("<remote-volume-resource-id>"),
		},
		nil)
	if err != nil {
		log.Fatal(err)
	}
	_, err = poller.PollUntilDone(ctx, 30*time.Second)
	if err != nil {
		log.Fatal(err)
	}
}

Output:

func (*VolumesClient) BeginBreakReplication 

func (client *VolumesClient) BeginBreakReplication(ctx context.Context, resourceGroupName string, accountName string, poolName string, volumeName string, options *VolumesBeginBreakReplicationOptions) (VolumesBreakReplicationPollerResponse, error)

BeginBreakReplication - Break the replication connection on the destination volume If the operation fails it returns a generic error.

Example

x-ms-original-file: specification/netapp/resource-manager/Microsoft.NetApp/stable/2021-08-01/examples/Volumes_BreakReplication.json 

package main

import (
	"context"
	"log"

	"time"

	"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/netapp/armnetapp"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client := armnetapp.NewVolumesClient("<subscription-id>", cred, nil)
	poller, err := client.BeginBreakReplication(ctx,
		"<resource-group-name>",
		"<account-name>",
		"<pool-name>",
		"<volume-name>",
		&armnetapp.VolumesBeginBreakReplicationOptions{Body: &armnetapp.BreakReplicationRequest{
			ForceBreakReplication: to.BoolPtr(false),
		},
		})
	if err != nil {
		log.Fatal(err)
	}
	_, err = poller.PollUntilDone(ctx, 30*time.Second)
	if err != nil {
		log.Fatal(err)
	}
}

Output:

func (*VolumesClient) BeginCreateOrUpdate 

func (client *VolumesClient) BeginCreateOrUpdate(ctx context.Context, resourceGroupName string, accountName string, poolName string, volumeName string, body Volume, options *VolumesBeginCreateOrUpdateOptions) (VolumesCreateOrUpdatePollerResponse, error)

BeginCreateOrUpdate - Create or update the specified volume within the capacity pool If the operation fails it returns a generic error.

Example

x-ms-original-file: specification/netapp/resource-manager/Microsoft.NetApp/stable/2021-08-01/examples/Volumes_CreateOrUpdate.json 

package main

import (
	"context"
	"log"

	"time"

	"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/netapp/armnetapp"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client := armnetapp.NewVolumesClient("<subscription-id>", cred, nil)
	poller, err := client.BeginCreateOrUpdate(ctx,
		"<resource-group-name>",
		"<account-name>",
		"<pool-name>",
		"<volume-name>",
		armnetapp.Volume{
			Location: to.StringPtr("<location>"),
			Properties: &armnetapp.VolumeProperties{
				CreationToken:       to.StringPtr("<creation-token>"),
				EncryptionKeySource: to.StringPtr("<encryption-key-source>"),
				ServiceLevel:        armnetapp.ServiceLevelPremium.ToPtr(),
				SubnetID:            to.StringPtr("<subnet-id>"),
				ThroughputMibps:     to.Float32Ptr(128),
				UsageThreshold:      to.Int64Ptr(107374182400),
			},
		},
		nil)
	if err != nil {
		log.Fatal(err)
	}
	res, err := poller.PollUntilDone(ctx, 30*time.Second)
	if err != nil {
		log.Fatal(err)
	}
	log.Printf("Volume.ID: %s\n", *res.ID)
}

Output:

func (*VolumesClient) BeginDelete 

func (client *VolumesClient) BeginDelete(ctx context.Context, resourceGroupName string, accountName string, poolName string, volumeName string, options *VolumesBeginDeleteOptions) (VolumesDeletePollerResponse, error)

BeginDelete - Delete the specified volume If the operation fails it returns a generic error.

Example

x-ms-original-file: specification/netapp/resource-manager/Microsoft.NetApp/stable/2021-08-01/examples/Volumes_Delete.json 

package main

import (
	"context"
	"log"

	"time"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/netapp/armnetapp"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client := armnetapp.NewVolumesClient("<subscription-id>", cred, nil)
	poller, err := client.BeginDelete(ctx,
		"<resource-group-name>",
		"<account-name>",
		"<pool-name>",
		"<volume-name>",
		nil)
	if err != nil {
		log.Fatal(err)
	}
	_, err = poller.PollUntilDone(ctx, 30*time.Second)
	if err != nil {
		log.Fatal(err)
	}
}

Output:

func (*VolumesClient) BeginDeleteReplication 

func (client *VolumesClient) BeginDeleteReplication(ctx context.Context, resourceGroupName string, accountName string, poolName string, volumeName string, options *VolumesBeginDeleteReplicationOptions) (VolumesDeleteReplicationPollerResponse, error)

BeginDeleteReplication - Delete the replication connection on the destination volume, and send release to the source replication If the operation fails it returns a generic error.

Example

x-ms-original-file: specification/netapp/resource-manager/Microsoft.NetApp/stable/2021-08-01/examples/Volumes_DeleteReplication.json 

package main

import (
	"context"
	"log"

	"time"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/netapp/armnetapp"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client := armnetapp.NewVolumesClient("<subscription-id>", cred, nil)
	poller, err := client.BeginDeleteReplication(ctx,
		"<resource-group-name>",
		"<account-name>",
		"<pool-name>",
		"<volume-name>",
		nil)
	if err != nil {
		log.Fatal(err)
	}
	_, err = poller.PollUntilDone(ctx, 30*time.Second)
	if err != nil {
		log.Fatal(err)
	}
}

Output:

func (*VolumesClient) BeginPoolChange 

func (client *VolumesClient) BeginPoolChange(ctx context.Context, resourceGroupName string, accountName string, poolName string, volumeName string, body PoolChangeRequest, options *VolumesBeginPoolChangeOptions) (VolumesPoolChangePollerResponse, error)

BeginPoolChange - Moves volume to another pool If the operation fails it returns a generic error.

Example

x-ms-original-file: specification/netapp/resource-manager/Microsoft.NetApp/stable/2021-08-01/examples/Volumes_PoolChange.json 

package main

import (
	"context"
	"log"

	"time"

	"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/netapp/armnetapp"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client := armnetapp.NewVolumesClient("<subscription-id>", cred, nil)
	poller, err := client.BeginPoolChange(ctx,
		"<resource-group-name>",
		"<account-name>",
		"<pool-name>",
		"<volume-name>",
		armnetapp.PoolChangeRequest{
			NewPoolResourceID: to.StringPtr("<new-pool-resource-id>"),
		},
		nil)
	if err != nil {
		log.Fatal(err)
	}
	_, err = poller.PollUntilDone(ctx, 30*time.Second)
	if err != nil {
		log.Fatal(err)
	}
}

Output:

func (*VolumesClient) BeginReInitializeReplication 

func (client *VolumesClient) BeginReInitializeReplication(ctx context.Context, resourceGroupName string, accountName string, poolName string, volumeName string, options *VolumesBeginReInitializeReplicationOptions) (VolumesReInitializeReplicationPollerResponse, error)

BeginReInitializeReplication - Re-Initializes the replication connection on the destination volume If the operation fails it returns a generic error.

Example

x-ms-original-file: specification/netapp/resource-manager/Microsoft.NetApp/stable/2021-08-01/examples/Volumes_ReInitializeReplication.json 

package main

import (
	"context"
	"log"

	"time"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/netapp/armnetapp"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client := armnetapp.NewVolumesClient("<subscription-id>", cred, nil)
	poller, err := client.BeginReInitializeReplication(ctx,
		"<resource-group-name>",
		"<account-name>",
		"<pool-name>",
		"<volume-name>",
		nil)
	if err != nil {
		log.Fatal(err)
	}
	_, err = poller.PollUntilDone(ctx, 30*time.Second)
	if err != nil {
		log.Fatal(err)
	}
}

Output:

func (*VolumesClient) BeginResyncReplication 

func (client *VolumesClient) BeginResyncReplication(ctx context.Context, resourceGroupName string, accountName string, poolName string, volumeName string, options *VolumesBeginResyncReplicationOptions) (VolumesResyncReplicationPollerResponse, error)

BeginResyncReplication - Resync the connection on the destination volume. If the operation is ran on the source volume it will reverse-resync the connection and sync from destination to source. If the operation fails it returns a generic error.

Example

x-ms-original-file: specification/netapp/resource-manager/Microsoft.NetApp/stable/2021-08-01/examples/Volumes_ResyncReplication.json 

package main

import (
	"context"
	"log"

	"time"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/netapp/armnetapp"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client := armnetapp.NewVolumesClient("<subscription-id>", cred, nil)
	poller, err := client.BeginResyncReplication(ctx,
		"<resource-group-name>",
		"<account-name>",
		"<pool-name>",
		"<volume-name>",
		nil)
	if err != nil {
		log.Fatal(err)
	}
	_, err = poller.PollUntilDone(ctx, 30*time.Second)
	if err != nil {
		log.Fatal(err)
	}
}

Output:

func (*VolumesClient) BeginRevert 

func (client *VolumesClient) BeginRevert(ctx context.Context, resourceGroupName string, accountName string, poolName string, volumeName string, body VolumeRevert, options *VolumesBeginRevertOptions) (VolumesRevertPollerResponse, error)

BeginRevert - Revert a volume to the snapshot specified in the body If the operation fails it returns a generic error.

Example

x-ms-original-file: specification/netapp/resource-manager/Microsoft.NetApp/stable/2021-08-01/examples/Volumes_Revert.json 

package main

import (
	"context"
	"log"

	"time"

	"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/netapp/armnetapp"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client := armnetapp.NewVolumesClient("<subscription-id>", cred, nil)
	poller, err := client.BeginRevert(ctx,
		"<resource-group-name>",
		"<account-name>",
		"<pool-name>",
		"<volume-name>",
		armnetapp.VolumeRevert{
			SnapshotID: to.StringPtr("<snapshot-id>"),
		},
		nil)
	if err != nil {
		log.Fatal(err)
	}
	_, err = poller.PollUntilDone(ctx, 30*time.Second)
	if err != nil {
		log.Fatal(err)
	}
}

Output:

func (*VolumesClient) BeginUpdate 

func (client *VolumesClient) BeginUpdate(ctx context.Context, resourceGroupName string, accountName string, poolName string, volumeName string, body VolumePatch, options *VolumesBeginUpdateOptions) (VolumesUpdatePollerResponse, error)

BeginUpdate - Patch the specified volume If the operation fails it returns the *CloudError error type.

Example

x-ms-original-file: specification/netapp/resource-manager/Microsoft.NetApp/stable/2021-08-01/examples/Volumes_Update.json 

package main

import (
	"context"
	"log"

	"time"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/netapp/armnetapp"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client := armnetapp.NewVolumesClient("<subscription-id>", cred, nil)
	poller, err := client.BeginUpdate(ctx,
		"<resource-group-name>",
		"<account-name>",
		"<pool-name>",
		"<volume-name>",
		armnetapp.VolumePatch{},
		nil)
	if err != nil {
		log.Fatal(err)
	}
	res, err := poller.PollUntilDone(ctx, 30*time.Second)
	if err != nil {
		log.Fatal(err)
	}
	log.Printf("Volume.ID: %s\n", *res.ID)
}

Output:

func (*VolumesClient) Get 

func (client *VolumesClient) Get(ctx context.Context, resourceGroupName string, accountName string, poolName string, volumeName string, options *VolumesGetOptions) (VolumesGetResponse, error)

Get - Get the details of the specified volume If the operation fails it returns a generic error.

Example

x-ms-original-file: specification/netapp/resource-manager/Microsoft.NetApp/stable/2021-08-01/examples/Volumes_Get.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/netapp/armnetapp"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client := armnetapp.NewVolumesClient("<subscription-id>", cred, nil)
	res, err := client.Get(ctx,
		"<resource-group-name>",
		"<account-name>",
		"<pool-name>",
		"<volume-name>",
		nil)
	if err != nil {
		log.Fatal(err)
	}
	log.Printf("Volume.ID: %s\n", *res.ID)
}

Output:

func (*VolumesClient) List 

func (client *VolumesClient) List(resourceGroupName string, accountName string, poolName string, options *VolumesListOptions) *VolumesListPager

List - List all volumes within the capacity pool If the operation fails it returns a generic error.

Example

x-ms-original-file: specification/netapp/resource-manager/Microsoft.NetApp/stable/2021-08-01/examples/Volumes_List.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/netapp/armnetapp"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client := armnetapp.NewVolumesClient("<subscription-id>", cred, nil)
	pager := client.List("<resource-group-name>",
		"<account-name>",
		"<pool-name>",
		nil)
	for pager.NextPage(ctx) {
		if err := pager.Err(); err != nil {
			log.Fatalf("failed to advance page: %v", err)
		}
		for _, v := range pager.PageResponse().Value {
			log.Printf("Volume.ID: %s\n", *v.ID)
		}
	}
}

Output:

func (*VolumesClient) ReplicationStatus 

func (client *VolumesClient) ReplicationStatus(ctx context.Context, resourceGroupName string, accountName string, poolName string, volumeName string, options *VolumesReplicationStatusOptions) (VolumesReplicationStatusResponse, error)

ReplicationStatus - Get the status of the replication If the operation fails it returns a generic error.

Example

x-ms-original-file: specification/netapp/resource-manager/Microsoft.NetApp/stable/2021-08-01/examples/Volumes_ReplicationStatus.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/netapp/armnetapp"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client := armnetapp.NewVolumesClient("<subscription-id>", cred, nil)
	_, err = client.ReplicationStatus(ctx,
		"<resource-group-name>",
		"<account-name>",
		"<pool-name>",
		"<volume-name>",
		nil)
	if err != nil {
		log.Fatal(err)
	}
}

Output:

type VolumesCreateOrUpdatePoller 

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

VolumesCreateOrUpdatePoller provides polling facilities until the operation reaches a terminal state.

func (*VolumesCreateOrUpdatePoller) Done 

func (p *VolumesCreateOrUpdatePoller) Done() bool

Done returns true if the LRO has reached a terminal state.

func (*VolumesCreateOrUpdatePoller) FinalResponse 

func (p *VolumesCreateOrUpdatePoller) FinalResponse(ctx context.Context) (VolumesCreateOrUpdateResponse, error)

FinalResponse performs a final GET to the service and returns the final response for the polling operation. If there is an error performing the final GET then an error is returned. If the final GET succeeded then the final VolumesCreateOrUpdateResponse will be returned.

func (*VolumesCreateOrUpdatePoller) Poll 

func (p *VolumesCreateOrUpdatePoller) Poll(ctx context.Context) (*http.Response, error)

Poll fetches the latest state of the LRO. It returns an HTTP response or error. If the LRO has completed successfully, the poller's state is updated and the HTTP response is returned. If the LRO has completed with failure or was cancelled, the poller's state is updated and the error is returned. If the LRO has not reached a terminal state, the poller's state is updated and the latest HTTP response is returned. If Poll fails, the poller's state is unmodified and the error is returned. Calling Poll on an LRO that has reached a terminal state will return the final HTTP response or error.

func (*VolumesCreateOrUpdatePoller) ResumeToken 

func (p *VolumesCreateOrUpdatePoller) ResumeToken() (string, error)

ResumeToken returns a value representing the poller that can be used to resume the LRO at a later time. ResumeTokens are unique per service operation.

type VolumesCreateOrUpdatePollerResponse 

type VolumesCreateOrUpdatePollerResponse struct {
	// Poller contains an initialized poller.
	Poller *VolumesCreateOrUpdatePoller

	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

VolumesCreateOrUpdatePollerResponse contains the response from method Volumes.CreateOrUpdate.

func (VolumesCreateOrUpdatePollerResponse) PollUntilDone 

func (l VolumesCreateOrUpdatePollerResponse) PollUntilDone(ctx context.Context, freq time.Duration) (VolumesCreateOrUpdateResponse, error)

PollUntilDone will poll the service endpoint until a terminal state is reached or an error is received. freq: the time to wait between intervals in absence of a Retry-After header. Allowed minimum is one second. A good starting value is 30 seconds. Note that some resources might benefit from a different value.

func (*VolumesCreateOrUpdatePollerResponse) Resume 

func (l *VolumesCreateOrUpdatePollerResponse) Resume(ctx context.Context, client *VolumesClient, token string) error

Resume rehydrates a VolumesCreateOrUpdatePollerResponse from the provided client and resume token.

type VolumesCreateOrUpdateResponse 

type VolumesCreateOrUpdateResponse struct {
	VolumesCreateOrUpdateResult
	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

VolumesCreateOrUpdateResponse contains the response from method Volumes.CreateOrUpdate.

type VolumesCreateOrUpdateResult 

type VolumesCreateOrUpdateResult struct {
	Volume
}

VolumesCreateOrUpdateResult contains the result from method Volumes.CreateOrUpdate.

type VolumesDeletePoller 

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

VolumesDeletePoller provides polling facilities until the operation reaches a terminal state.

func (*VolumesDeletePoller) Done 

func (p *VolumesDeletePoller) Done() bool

Done returns true if the LRO has reached a terminal state.

func (*VolumesDeletePoller) FinalResponse 

func (p *VolumesDeletePoller) FinalResponse(ctx context.Context) (VolumesDeleteResponse, error)

FinalResponse performs a final GET to the service and returns the final response for the polling operation. If there is an error performing the final GET then an error is returned. If the final GET succeeded then the final VolumesDeleteResponse will be returned.

func (*VolumesDeletePoller) Poll 

func (p *VolumesDeletePoller) Poll(ctx context.Context) (*http.Response, error)

Poll fetches the latest state of the LRO. It returns an HTTP response or error. If the LRO has completed successfully, the poller's state is updated and the HTTP response is returned. If the LRO has completed with failure or was cancelled, the poller's state is updated and the error is returned. If the LRO has not reached a terminal state, the poller's state is updated and the latest HTTP response is returned. If Poll fails, the poller's state is unmodified and the error is returned. Calling Poll on an LRO that has reached a terminal state will return the final HTTP response or error.

func (*VolumesDeletePoller) ResumeToken 

func (p *VolumesDeletePoller) ResumeToken() (string, error)

ResumeToken returns a value representing the poller that can be used to resume the LRO at a later time. ResumeTokens are unique per service operation.

type VolumesDeletePollerResponse 

type VolumesDeletePollerResponse struct {
	// Poller contains an initialized poller.
	Poller *VolumesDeletePoller

	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

VolumesDeletePollerResponse contains the response from method Volumes.Delete.

func (VolumesDeletePollerResponse) PollUntilDone 

func (l VolumesDeletePollerResponse) PollUntilDone(ctx context.Context, freq time.Duration) (VolumesDeleteResponse, error)

PollUntilDone will poll the service endpoint until a terminal state is reached or an error is received. freq: the time to wait between intervals in absence of a Retry-After header. Allowed minimum is one second. A good starting value is 30 seconds. Note that some resources might benefit from a different value.

func (*VolumesDeletePollerResponse) Resume 

func (l *VolumesDeletePollerResponse) Resume(ctx context.Context, client *VolumesClient, token string) error

Resume rehydrates a VolumesDeletePollerResponse from the provided client and resume token.

type VolumesDeleteReplicationPoller 

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

VolumesDeleteReplicationPoller provides polling facilities until the operation reaches a terminal state.

func (*VolumesDeleteReplicationPoller) Done 

func (p *VolumesDeleteReplicationPoller) Done() bool

Done returns true if the LRO has reached a terminal state.

func (*VolumesDeleteReplicationPoller) FinalResponse 

func (p *VolumesDeleteReplicationPoller) FinalResponse(ctx context.Context) (VolumesDeleteReplicationResponse, error)

FinalResponse performs a final GET to the service and returns the final response for the polling operation. If there is an error performing the final GET then an error is returned. If the final GET succeeded then the final VolumesDeleteReplicationResponse will be returned.

func (*VolumesDeleteReplicationPoller) Poll 

func (p *VolumesDeleteReplicationPoller) Poll(ctx context.Context) (*http.Response, error)

Poll fetches the latest state of the LRO. It returns an HTTP response or error. If the LRO has completed successfully, the poller's state is updated and the HTTP response is returned. If the LRO has completed with failure or was cancelled, the poller's state is updated and the error is returned. If the LRO has not reached a terminal state, the poller's state is updated and the latest HTTP response is returned. If Poll fails, the poller's state is unmodified and the error is returned. Calling Poll on an LRO that has reached a terminal state will return the final HTTP response or error.

func (*VolumesDeleteReplicationPoller) ResumeToken 

func (p *VolumesDeleteReplicationPoller) ResumeToken() (string, error)

ResumeToken returns a value representing the poller that can be used to resume the LRO at a later time. ResumeTokens are unique per service operation.

type VolumesDeleteReplicationPollerResponse 

type VolumesDeleteReplicationPollerResponse struct {
	// Poller contains an initialized poller.
	Poller *VolumesDeleteReplicationPoller

	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

VolumesDeleteReplicationPollerResponse contains the response from method Volumes.DeleteReplication.

func (VolumesDeleteReplicationPollerResponse) PollUntilDone 

func (l VolumesDeleteReplicationPollerResponse) PollUntilDone(ctx context.Context, freq time.Duration) (VolumesDeleteReplicationResponse, error)

PollUntilDone will poll the service endpoint until a terminal state is reached or an error is received. freq: the time to wait between intervals in absence of a Retry-After header. Allowed minimum is one second. A good starting value is 30 seconds. Note that some resources might benefit from a different value.

func (*VolumesDeleteReplicationPollerResponse) Resume 

func (l *VolumesDeleteReplicationPollerResponse) Resume(ctx context.Context, client *VolumesClient, token string) error

Resume rehydrates a VolumesDeleteReplicationPollerResponse from the provided client and resume token.

type VolumesDeleteReplicationResponse 

type VolumesDeleteReplicationResponse struct {
	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

VolumesDeleteReplicationResponse contains the response from method Volumes.DeleteReplication.

type VolumesDeleteResponse 

type VolumesDeleteResponse struct {
	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

VolumesDeleteResponse contains the response from method Volumes.Delete.

type VolumesGetOptions 

type VolumesGetOptions struct {
}

VolumesGetOptions contains the optional parameters for the Volumes.Get method.

type VolumesGetResponse 

type VolumesGetResponse struct {
	VolumesGetResult
	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

VolumesGetResponse contains the response from method Volumes.Get.

type VolumesGetResult 

type VolumesGetResult struct {
	Volume
}

VolumesGetResult contains the result from method Volumes.Get.

type VolumesListOptions 

type VolumesListOptions struct {
}

VolumesListOptions contains the optional parameters for the Volumes.List method.

type VolumesListPager 

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

VolumesListPager provides operations for iterating over paged responses.

func (*VolumesListPager) Err 

func (p *VolumesListPager) Err() error

Err returns the last error encountered while paging.

func (*VolumesListPager) NextPage 

func (p *VolumesListPager) NextPage(ctx context.Context) bool

NextPage returns true if the pager advanced to the next page. Returns false if there are no more pages or an error occurred.

func (*VolumesListPager) PageResponse 

func (p *VolumesListPager) PageResponse() VolumesListResponse

PageResponse returns the current VolumesListResponse page.

type VolumesListResponse 

type VolumesListResponse struct {
	VolumesListResult
	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

VolumesListResponse contains the response from method Volumes.List.

type VolumesListResult 

type VolumesListResult struct {
	VolumeList
}

VolumesListResult contains the result from method Volumes.List.

type VolumesPoolChangePoller 

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

VolumesPoolChangePoller provides polling facilities until the operation reaches a terminal state.

func (*VolumesPoolChangePoller) Done 

func (p *VolumesPoolChangePoller) Done() bool

Done returns true if the LRO has reached a terminal state.

func (*VolumesPoolChangePoller) FinalResponse 

func (p *VolumesPoolChangePoller) FinalResponse(ctx context.Context) (VolumesPoolChangeResponse, error)

FinalResponse performs a final GET to the service and returns the final response for the polling operation. If there is an error performing the final GET then an error is returned. If the final GET succeeded then the final VolumesPoolChangeResponse will be returned.

func (*VolumesPoolChangePoller) Poll 

func (p *VolumesPoolChangePoller) Poll(ctx context.Context) (*http.Response, error)

Poll fetches the latest state of the LRO. It returns an HTTP response or error. If the LRO has completed successfully, the poller's state is updated and the HTTP response is returned. If the LRO has completed with failure or was cancelled, the poller's state is updated and the error is returned. If the LRO has not reached a terminal state, the poller's state is updated and the latest HTTP response is returned. If Poll fails, the poller's state is unmodified and the error is returned. Calling Poll on an LRO that has reached a terminal state will return the final HTTP response or error.

func (*VolumesPoolChangePoller) ResumeToken 

func (p *VolumesPoolChangePoller) ResumeToken() (string, error)

ResumeToken returns a value representing the poller that can be used to resume the LRO at a later time. ResumeTokens are unique per service operation.

type VolumesPoolChangePollerResponse 

type VolumesPoolChangePollerResponse struct {
	// Poller contains an initialized poller.
	Poller *VolumesPoolChangePoller

	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

VolumesPoolChangePollerResponse contains the response from method Volumes.PoolChange.

func (VolumesPoolChangePollerResponse) PollUntilDone 

func (l VolumesPoolChangePollerResponse) PollUntilDone(ctx context.Context, freq time.Duration) (VolumesPoolChangeResponse, error)

PollUntilDone will poll the service endpoint until a terminal state is reached or an error is received. freq: the time to wait between intervals in absence of a Retry-After header. Allowed minimum is one second. A good starting value is 30 seconds. Note that some resources might benefit from a different value.

func (*VolumesPoolChangePollerResponse) Resume 

func (l *VolumesPoolChangePollerResponse) Resume(ctx context.Context, client *VolumesClient, token string) error

Resume rehydrates a VolumesPoolChangePollerResponse from the provided client and resume token.

type VolumesPoolChangeResponse 

type VolumesPoolChangeResponse struct {
	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

VolumesPoolChangeResponse contains the response from method Volumes.PoolChange.

type VolumesReInitializeReplicationPoller 

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

VolumesReInitializeReplicationPoller provides polling facilities until the operation reaches a terminal state.

func (*VolumesReInitializeReplicationPoller) Done 

func (p *VolumesReInitializeReplicationPoller) Done() bool

Done returns true if the LRO has reached a terminal state.

func (*VolumesReInitializeReplicationPoller) FinalResponse 

func (p *VolumesReInitializeReplicationPoller) FinalResponse(ctx context.Context) (VolumesReInitializeReplicationResponse, error)

FinalResponse performs a final GET to the service and returns the final response for the polling operation. If there is an error performing the final GET then an error is returned. If the final GET succeeded then the final VolumesReInitializeReplicationResponse will be returned.

func (*VolumesReInitializeReplicationPoller) Poll 

func (p *VolumesReInitializeReplicationPoller) Poll(ctx context.Context) (*http.Response, error)

Poll fetches the latest state of the LRO. It returns an HTTP response or error. If the LRO has completed successfully, the poller's state is updated and the HTTP response is returned. If the LRO has completed with failure or was cancelled, the poller's state is updated and the error is returned. If the LRO has not reached a terminal state, the poller's state is updated and the latest HTTP response is returned. If Poll fails, the poller's state is unmodified and the error is returned. Calling Poll on an LRO that has reached a terminal state will return the final HTTP response or error.

func (*VolumesReInitializeReplicationPoller) ResumeToken 

func (p *VolumesReInitializeReplicationPoller) ResumeToken() (string, error)

ResumeToken returns a value representing the poller that can be used to resume the LRO at a later time. ResumeTokens are unique per service operation.

type VolumesReInitializeReplicationPollerResponse 

type VolumesReInitializeReplicationPollerResponse struct {
	// Poller contains an initialized poller.
	Poller *VolumesReInitializeReplicationPoller

	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

VolumesReInitializeReplicationPollerResponse contains the response from method Volumes.ReInitializeReplication.

func (VolumesReInitializeReplicationPollerResponse) PollUntilDone 

func (l VolumesReInitializeReplicationPollerResponse) PollUntilDone(ctx context.Context, freq time.Duration) (VolumesReInitializeReplicationResponse, error)

PollUntilDone will poll the service endpoint until a terminal state is reached or an error is received. freq: the time to wait between intervals in absence of a Retry-After header. Allowed minimum is one second. A good starting value is 30 seconds. Note that some resources might benefit from a different value.

func (*VolumesReInitializeReplicationPollerResponse) Resume 

func (l *VolumesReInitializeReplicationPollerResponse) Resume(ctx context.Context, client *VolumesClient, token string) error

Resume rehydrates a VolumesReInitializeReplicationPollerResponse from the provided client and resume token.

type VolumesReInitializeReplicationResponse 

type VolumesReInitializeReplicationResponse struct {
	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

VolumesReInitializeReplicationResponse contains the response from method Volumes.ReInitializeReplication.

type VolumesReplicationStatusOptions 

type VolumesReplicationStatusOptions struct {
}

VolumesReplicationStatusOptions contains the optional parameters for the Volumes.ReplicationStatus method.

type VolumesReplicationStatusResponse 

type VolumesReplicationStatusResponse struct {
	VolumesReplicationStatusResult
	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

VolumesReplicationStatusResponse contains the response from method Volumes.ReplicationStatus.

type VolumesReplicationStatusResult 

type VolumesReplicationStatusResult struct {
	ReplicationStatus
}

VolumesReplicationStatusResult contains the result from method Volumes.ReplicationStatus.

type VolumesResyncReplicationPoller 

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

VolumesResyncReplicationPoller provides polling facilities until the operation reaches a terminal state.

func (*VolumesResyncReplicationPoller) Done 

func (p *VolumesResyncReplicationPoller) Done() bool

Done returns true if the LRO has reached a terminal state.

func (*VolumesResyncReplicationPoller) FinalResponse 

func (p *VolumesResyncReplicationPoller) FinalResponse(ctx context.Context) (VolumesResyncReplicationResponse, error)

FinalResponse performs a final GET to the service and returns the final response for the polling operation. If there is an error performing the final GET then an error is returned. If the final GET succeeded then the final VolumesResyncReplicationResponse will be returned.

func (*VolumesResyncReplicationPoller) Poll 

func (p *VolumesResyncReplicationPoller) Poll(ctx context.Context) (*http.Response, error)

Poll fetches the latest state of the LRO. It returns an HTTP response or error. If the LRO has completed successfully, the poller's state is updated and the HTTP response is returned. If the LRO has completed with failure or was cancelled, the poller's state is updated and the error is returned. If the LRO has not reached a terminal state, the poller's state is updated and the latest HTTP response is returned. If Poll fails, the poller's state is unmodified and the error is returned. Calling Poll on an LRO that has reached a terminal state will return the final HTTP response or error.

func (*VolumesResyncReplicationPoller) ResumeToken 

func (p *VolumesResyncReplicationPoller) ResumeToken() (string, error)

ResumeToken returns a value representing the poller that can be used to resume the LRO at a later time. ResumeTokens are unique per service operation.

type VolumesResyncReplicationPollerResponse 

type VolumesResyncReplicationPollerResponse struct {
	// Poller contains an initialized poller.
	Poller *VolumesResyncReplicationPoller

	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

VolumesResyncReplicationPollerResponse contains the response from method Volumes.ResyncReplication.

func (VolumesResyncReplicationPollerResponse) PollUntilDone 

func (l VolumesResyncReplicationPollerResponse) PollUntilDone(ctx context.Context, freq time.Duration) (VolumesResyncReplicationResponse, error)

PollUntilDone will poll the service endpoint until a terminal state is reached or an error is received. freq: the time to wait between intervals in absence of a Retry-After header. Allowed minimum is one second. A good starting value is 30 seconds. Note that some resources might benefit from a different value.

func (*VolumesResyncReplicationPollerResponse) Resume 

func (l *VolumesResyncReplicationPollerResponse) Resume(ctx context.Context, client *VolumesClient, token string) error

Resume rehydrates a VolumesResyncReplicationPollerResponse from the provided client and resume token.

type VolumesResyncReplicationResponse 

type VolumesResyncReplicationResponse struct {
	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

VolumesResyncReplicationResponse contains the response from method Volumes.ResyncReplication.

type VolumesRevertPoller 

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

VolumesRevertPoller provides polling facilities until the operation reaches a terminal state.

func (*VolumesRevertPoller) Done 

func (p *VolumesRevertPoller) Done() bool

Done returns true if the LRO has reached a terminal state.

func (*VolumesRevertPoller) FinalResponse 

func (p *VolumesRevertPoller) FinalResponse(ctx context.Context) (VolumesRevertResponse, error)

FinalResponse performs a final GET to the service and returns the final response for the polling operation. If there is an error performing the final GET then an error is returned. If the final GET succeeded then the final VolumesRevertResponse will be returned.

func (*VolumesRevertPoller) Poll 

func (p *VolumesRevertPoller) Poll(ctx context.Context) (*http.Response, error)

Poll fetches the latest state of the LRO. It returns an HTTP response or error. If the LRO has completed successfully, the poller's state is updated and the HTTP response is returned. If the LRO has completed with failure or was cancelled, the poller's state is updated and the error is returned. If the LRO has not reached a terminal state, the poller's state is updated and the latest HTTP response is returned. If Poll fails, the poller's state is unmodified and the error is returned. Calling Poll on an LRO that has reached a terminal state will return the final HTTP response or error.

func (*VolumesRevertPoller) ResumeToken 

func (p *VolumesRevertPoller) ResumeToken() (string, error)

ResumeToken returns a value representing the poller that can be used to resume the LRO at a later time. ResumeTokens are unique per service operation.

type VolumesRevertPollerResponse 

type VolumesRevertPollerResponse struct {
	// Poller contains an initialized poller.
	Poller *VolumesRevertPoller

	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

VolumesRevertPollerResponse contains the response from method Volumes.Revert.

func (VolumesRevertPollerResponse) PollUntilDone 

func (l VolumesRevertPollerResponse) PollUntilDone(ctx context.Context, freq time.Duration) (VolumesRevertResponse, error)

PollUntilDone will poll the service endpoint until a terminal state is reached or an error is received. freq: the time to wait between intervals in absence of a Retry-After header. Allowed minimum is one second. A good starting value is 30 seconds. Note that some resources might benefit from a different value.

func (*VolumesRevertPollerResponse) Resume 

func (l *VolumesRevertPollerResponse) Resume(ctx context.Context, client *VolumesClient, token string) error

Resume rehydrates a VolumesRevertPollerResponse from the provided client and resume token.

type VolumesRevertResponse 

type VolumesRevertResponse struct {
	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

VolumesRevertResponse contains the response from method Volumes.Revert.

type VolumesUpdatePoller 

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

VolumesUpdatePoller provides polling facilities until the operation reaches a terminal state.

func (*VolumesUpdatePoller) Done 

func (p *VolumesUpdatePoller) Done() bool

Done returns true if the LRO has reached a terminal state.

func (*VolumesUpdatePoller) FinalResponse 

func (p *VolumesUpdatePoller) FinalResponse(ctx context.Context) (VolumesUpdateResponse, error)

FinalResponse performs a final GET to the service and returns the final response for the polling operation. If there is an error performing the final GET then an error is returned. If the final GET succeeded then the final VolumesUpdateResponse will be returned.

func (*VolumesUpdatePoller) Poll 

func (p *VolumesUpdatePoller) Poll(ctx context.Context) (*http.Response, error)

Poll fetches the latest state of the LRO. It returns an HTTP response or error. If the LRO has completed successfully, the poller's state is updated and the HTTP response is returned. If the LRO has completed with failure or was cancelled, the poller's state is updated and the error is returned. If the LRO has not reached a terminal state, the poller's state is updated and the latest HTTP response is returned. If Poll fails, the poller's state is unmodified and the error is returned. Calling Poll on an LRO that has reached a terminal state will return the final HTTP response or error.

func (*VolumesUpdatePoller) ResumeToken 

func (p *VolumesUpdatePoller) ResumeToken() (string, error)

ResumeToken returns a value representing the poller that can be used to resume the LRO at a later time. ResumeTokens are unique per service operation.

type VolumesUpdatePollerResponse 

type VolumesUpdatePollerResponse struct {
	// Poller contains an initialized poller.
	Poller *VolumesUpdatePoller

	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

VolumesUpdatePollerResponse contains the response from method Volumes.Update.

func (VolumesUpdatePollerResponse) PollUntilDone 

func (l VolumesUpdatePollerResponse) PollUntilDone(ctx context.Context, freq time.Duration) (VolumesUpdateResponse, error)

PollUntilDone will poll the service endpoint until a terminal state is reached or an error is received. freq: the time to wait between intervals in absence of a Retry-After header. Allowed minimum is one second. A good starting value is 30 seconds. Note that some resources might benefit from a different value.

func (*VolumesUpdatePollerResponse) Resume 

func (l *VolumesUpdatePollerResponse) Resume(ctx context.Context, client *VolumesClient, token string) error

Resume rehydrates a VolumesUpdatePollerResponse from the provided client and resume token.

type VolumesUpdateResponse 

type VolumesUpdateResponse struct {
	VolumesUpdateResult
	// RawResponse contains the underlying HTTP response.
	RawResponse *http.Response
}

VolumesUpdateResponse contains the response from method Volumes.Update.

type VolumesUpdateResult 

type VolumesUpdateResult struct {
	Volume
}

VolumesUpdateResult contains the result from method Volumes.Update.

type WeeklySchedule 

type WeeklySchedule struct {
	// Indicates which weekdays snapshot should be taken, accepts a comma separated list of week day names in english
	Day *string `json:"day,omitempty"`

	// Indicates which hour in UTC timezone a snapshot should be taken
	Hour *int32 `json:"hour,omitempty"`

	// Indicates which minute snapshot should be taken
	Minute *int32 `json:"minute,omitempty"`

	// Weekly snapshot count to keep
	SnapshotsToKeep *int32 `json:"snapshotsToKeep,omitempty"`

	// Resource size in bytes, current storage usage for the volume in bytes
	UsedBytes *int64 `json:"usedBytes,omitempty"`
}

WeeklySchedule - Weekly Schedule properties, make a snapshot every week at a specific day or days

Source Files

View all Source files

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.