armdatalakestore

package module
v1.2.0 Latest Latest
Warning

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

 Go to latest Published: Nov 23, 2023 License: MIT Imports: 15 Imported by: 8

README

Azure Data Lake Storage Module for Go

PkgGoDev

The armdatalakestore module provides operations for working with Azure Data Lake Storage.

Source code

Getting started

Prerequisites

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

Install the package

This project uses Go modules for versioning and dependency management.

Install the Azure Data Lake Storage module:

go get github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/datalake-store/armdatalakestore

Authorization

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

cred, err := azidentity.NewDefaultAzureCredential(nil)

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

Client Factory

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

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

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

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

Clients

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

client := clientFactory.NewAccountsClient()

Fakes

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

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

Provide Feedback

If you encounter bugs or have suggestions, please open an issue and assign the Data Lake Storage 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 Account added in v0.3.0 

type Account struct {
	// READ-ONLY; The resource identifier.
	ID *string

	// READ-ONLY; The Key Vault encryption identity, if any.
	Identity *EncryptionIdentity

	// READ-ONLY; The resource location.
	Location *string

	// READ-ONLY; The resource name.
	Name *string

	// READ-ONLY; The Data Lake Store account properties.
	Properties *AccountProperties

	// READ-ONLY; The resource tags.
	Tags map[string]*string

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

Account - Data Lake Store account information.

func (Account) MarshalJSON added in v0.3.0 

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

MarshalJSON implements the json.Marshaller interface for type Account.

func (*Account) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type Account.

type AccountBasic added in v0.3.0 

type AccountBasic struct {
	// READ-ONLY; The resource identifier.
	ID *string

	// READ-ONLY; The resource location.
	Location *string

	// READ-ONLY; The resource name.
	Name *string

	// READ-ONLY; The basic Data Lake Store account properties.
	Properties *AccountPropertiesBasic

	// READ-ONLY; The resource tags.
	Tags map[string]*string

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

AccountBasic - Basic Data Lake Store account information, returned on list calls.

func (AccountBasic) MarshalJSON added in v0.3.0 

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

MarshalJSON implements the json.Marshaller interface for type AccountBasic.

func (*AccountBasic) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AccountBasic.

type AccountListResult added in v0.3.0 

type AccountListResult struct {
	// READ-ONLY; The link (url) to the next page of results.
	NextLink *string

	// READ-ONLY; The results of the list operation.
	Value []*AccountBasic
}

AccountListResult - Data Lake Store account list information response.

func (AccountListResult) MarshalJSON added in v0.3.0 

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

MarshalJSON implements the json.Marshaller interface for type AccountListResult.

func (*AccountListResult) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AccountListResult.

type AccountProperties added in v0.3.0 

type AccountProperties struct {
	// READ-ONLY; The unique identifier associated with this Data Lake Store account.
	AccountID *string

	// READ-ONLY; The account creation time.
	CreationTime *time.Time

	// READ-ONLY; The commitment tier in use for the current month.
	CurrentTier *TierType

	// READ-ONLY; The default owner group for all new folders and files created in the Data Lake Store account.
	DefaultGroup *string

	// READ-ONLY; The Key Vault encryption configuration.
	EncryptionConfig *EncryptionConfig

	// READ-ONLY; The current state of encryption provisioning for this Data Lake Store account.
	EncryptionProvisioningState *EncryptionProvisioningState

	// READ-ONLY; The current state of encryption for this Data Lake Store account.
	EncryptionState *EncryptionState

	// READ-ONLY; The full CName endpoint for this account.
	Endpoint *string

	// READ-ONLY; The current state of allowing or disallowing IPs originating within Azure through the firewall. If the firewall
	// is disabled, this is not enforced.
	FirewallAllowAzureIPs *FirewallAllowAzureIPsState

	// READ-ONLY; The list of firewall rules associated with this Data Lake Store account.
	FirewallRules []*FirewallRule

	// READ-ONLY; The current state of the IP address firewall for this Data Lake Store account.
	FirewallState *FirewallState

	// READ-ONLY; The account last modified time.
	LastModifiedTime *time.Time

	// READ-ONLY; The commitment tier to use for next month.
	NewTier *TierType

	// READ-ONLY; The provisioning status of the Data Lake Store account.
	ProvisioningState *DataLakeStoreAccountStatus

	// READ-ONLY; The state of the Data Lake Store account.
	State *DataLakeStoreAccountState

	// READ-ONLY; The current state of the trusted identity provider feature for this Data Lake Store account.
	TrustedIDProviderState *TrustedIDProviderState

	// READ-ONLY; The list of trusted identity providers associated with this Data Lake Store account.
	TrustedIDProviders []*TrustedIDProvider

	// READ-ONLY; The list of virtual network rules associated with this Data Lake Store account.
	VirtualNetworkRules []*VirtualNetworkRule
}

AccountProperties - Data Lake Store account properties information.

func (AccountProperties) MarshalJSON added in v0.3.0 

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

MarshalJSON implements the json.Marshaller interface for type AccountProperties.

func (*AccountProperties) UnmarshalJSON added in v0.3.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AccountProperties.

type AccountPropertiesBasic added in v0.3.0 

type AccountPropertiesBasic struct {
	// READ-ONLY; The unique identifier associated with this Data Lake Store account.
	AccountID *string

	// READ-ONLY; The account creation time.
	CreationTime *time.Time

	// READ-ONLY; The full CName endpoint for this account.
	Endpoint *string

	// READ-ONLY; The account last modified time.
	LastModifiedTime *time.Time

	// READ-ONLY; The provisioning status of the Data Lake Store account.
	ProvisioningState *DataLakeStoreAccountStatus

	// READ-ONLY; The state of the Data Lake Store account.
	State *DataLakeStoreAccountState
}

AccountPropertiesBasic - The basic account specific properties that are associated with an underlying Data Lake Store account.

func (AccountPropertiesBasic) MarshalJSON added in v0.3.0 

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

MarshalJSON implements the json.Marshaller interface for type AccountPropertiesBasic.

func (*AccountPropertiesBasic) UnmarshalJSON added in v0.3.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AccountPropertiesBasic.

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, error)

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

  • subscriptionID - Gets subscription credentials which uniquely identify Microsoft Azure subscription. The subscription ID forms part of the URI for every service call.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*AccountsClient) BeginCreate 

func (client *AccountsClient) BeginCreate(ctx context.Context, resourceGroupName string, accountName string, parameters CreateDataLakeStoreAccountParameters, options *AccountsClientBeginCreateOptions) (*runtime.Poller[AccountsClientCreateResponse], error)

BeginCreate - Creates the specified Data Lake Store account. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2016-11-01

  • resourceGroupName - The name of the Azure resource group.
  • accountName - The name of the Data Lake Store account.
  • parameters - Parameters supplied to create the Data Lake Store account.
  • options - AccountsClientBeginCreateOptions contains the optional parameters for the AccountsClient.BeginCreate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/7a2ac91de424f271cf91cc8009f3fe9ee8249086/specification/datalake-store/resource-manager/Microsoft.DataLakeStore/stable/2016-11-01/examples/Accounts_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/datalake-store/armdatalakestore"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armdatalakestore.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewAccountsClient().BeginCreate(ctx, "contosorg", "contosoadla", armdatalakestore.CreateDataLakeStoreAccountParameters{
		Identity: &armdatalakestore.EncryptionIdentity{
			Type: to.Ptr("SystemAssigned"),
		},
		Location: to.Ptr("eastus2"),
		Properties: &armdatalakestore.CreateDataLakeStoreAccountProperties{
			DefaultGroup: to.Ptr("test_default_group"),
			EncryptionConfig: &armdatalakestore.EncryptionConfig{
				Type: to.Ptr(armdatalakestore.EncryptionConfigTypeUserManaged),
				KeyVaultMetaInfo: &armdatalakestore.KeyVaultMetaInfo{
					EncryptionKeyName:    to.Ptr("test_encryption_key_name"),
					EncryptionKeyVersion: to.Ptr("encryption_key_version"),
					KeyVaultResourceID:   to.Ptr("34adfa4f-cedf-4dc0-ba29-b6d1a69ab345"),
				},
			},
			EncryptionState:       to.Ptr(armdatalakestore.EncryptionStateEnabled),
			FirewallAllowAzureIPs: to.Ptr(armdatalakestore.FirewallAllowAzureIPsStateEnabled),
			FirewallRules: []*armdatalakestore.CreateFirewallRuleWithAccountParameters{
				{
					Name: to.Ptr("test_rule"),
					Properties: &armdatalakestore.CreateOrUpdateFirewallRuleProperties{
						EndIPAddress:   to.Ptr("2.2.2.2"),
						StartIPAddress: to.Ptr("1.1.1.1"),
					},
				}},
			FirewallState:          to.Ptr(armdatalakestore.FirewallStateEnabled),
			NewTier:                to.Ptr(armdatalakestore.TierTypeConsumption),
			TrustedIDProviderState: to.Ptr(armdatalakestore.TrustedIDProviderStateEnabled),
			TrustedIDProviders: []*armdatalakestore.CreateTrustedIDProviderWithAccountParameters{
				{
					Name: to.Ptr("test_trusted_id_provider_name"),
					Properties: &armdatalakestore.CreateOrUpdateTrustedIDProviderProperties{
						IDProvider: to.Ptr("https://sts.windows.net/ea9ec534-a3e3-4e45-ad36-3afc5bb291c1"),
					},
				}},
		},
		Tags: map[string]*string{
			"test_key": to.Ptr("test_value"),
		},
	}, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	res, err := poller.PollUntilDone(ctx, nil)
	if err != nil {
		log.Fatalf("failed to pull the result: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res.Account = armdatalakestore.Account{
	// 	Name: to.Ptr("contosoadla"),
	// 	Type: to.Ptr("test_type"),
	// 	ID: to.Ptr("34adfa4f-cedf-4dc0-ba29-b6d1a69ab345"),
	// 	Location: to.Ptr("eastus2"),
	// 	Tags: map[string]*string{
	// 		"test_key": to.Ptr("test_value"),
	// 	},
	// 	Identity: &armdatalakestore.EncryptionIdentity{
	// 		Type: to.Ptr("SystemAssigned"),
	// 		PrincipalID: to.Ptr("34adfa4f-cedf-4dc0-ba29-b6d1a69ab345"),
	// 		TenantID: to.Ptr("34adfa4f-cedf-4dc0-ba29-b6d1a69ab346"),
	// 	},
	// 	Properties: &armdatalakestore.AccountProperties{
	// 		AccountID: to.Ptr("94f4bf5d-78a9-4c31-8aa7-b34d07bad898"),
	// 		CreationTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-04-14T20:21:56.681Z"); return t}()),
	// 		Endpoint: to.Ptr("testadlfs17607.azuredatalakestore.net"),
	// 		LastModifiedTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-04-14T20:21:56.681Z"); return t}()),
	// 		ProvisioningState: to.Ptr(armdatalakestore.DataLakeStoreAccountStatusSucceeded),
	// 		State: to.Ptr(armdatalakestore.DataLakeStoreAccountStateActive),
	// 		CurrentTier: to.Ptr(armdatalakestore.TierTypeConsumption),
	// 		DefaultGroup: to.Ptr("test_default_group"),
	// 		EncryptionConfig: &armdatalakestore.EncryptionConfig{
	// 			Type: to.Ptr(armdatalakestore.EncryptionConfigTypeUserManaged),
	// 			KeyVaultMetaInfo: &armdatalakestore.KeyVaultMetaInfo{
	// 				EncryptionKeyName: to.Ptr("test_encryption_key_name"),
	// 				EncryptionKeyVersion: to.Ptr("encryption_key_version"),
	// 				KeyVaultResourceID: to.Ptr("34adfa4f-cedf-4dc0-ba29-b6d1a69ab345"),
	// 			},
	// 		},
	// 		EncryptionProvisioningState: to.Ptr(armdatalakestore.EncryptionProvisioningStateSucceeded),
	// 		EncryptionState: to.Ptr(armdatalakestore.EncryptionStateEnabled),
	// 		FirewallAllowAzureIPs: to.Ptr(armdatalakestore.FirewallAllowAzureIPsStateEnabled),
	// 		FirewallRules: []*armdatalakestore.FirewallRule{
	// 			{
	// 				Name: to.Ptr("test_rule"),
	// 				Type: to.Ptr("test_type"),
	// 				ID: to.Ptr("34adfa4f-cedf-4dc0-ba29-b6d1a69ab345"),
	// 				Properties: &armdatalakestore.FirewallRuleProperties{
	// 					EndIPAddress: to.Ptr("2.2.2.2"),
	// 					StartIPAddress: to.Ptr("1.1.1.1"),
	// 				},
	// 		}},
	// 		FirewallState: to.Ptr(armdatalakestore.FirewallStateEnabled),
	// 		NewTier: to.Ptr(armdatalakestore.TierTypeConsumption),
	// 		TrustedIDProviderState: to.Ptr(armdatalakestore.TrustedIDProviderStateEnabled),
	// 		TrustedIDProviders: []*armdatalakestore.TrustedIDProvider{
	// 			{
	// 				Name: to.Ptr("test_trusted_id_provider_name"),
	// 				Type: to.Ptr("test_type"),
	// 				ID: to.Ptr("34adfa4f-cedf-4dc0-ba29-b6d1a69ab345"),
	// 				Properties: &armdatalakestore.TrustedIDProviderProperties{
	// 					IDProvider: to.Ptr("https://sts.windows.net/ea9ec534-a3e3-4e45-ad36-3afc5bb291c1"),
	// 				},
	// 		}},
	// 	},
	// }
}

Output:

func (*AccountsClient) BeginDelete 

func (client *AccountsClient) BeginDelete(ctx context.Context, resourceGroupName string, accountName string, options *AccountsClientBeginDeleteOptions) (*runtime.Poller[AccountsClientDeleteResponse], error)

BeginDelete - Deletes the specified Data Lake Store account. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2016-11-01

  • resourceGroupName - The name of the Azure resource group.
  • accountName - The name of the Data Lake Store account.
  • options - AccountsClientBeginDeleteOptions contains the optional parameters for the AccountsClient.BeginDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/7a2ac91de424f271cf91cc8009f3fe9ee8249086/specification/datalake-store/resource-manager/Microsoft.DataLakeStore/stable/2016-11-01/examples/Accounts_Delete.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/datalake-store/armdatalakestore"
)

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

Output:

func (*AccountsClient) BeginUpdate 

func (client *AccountsClient) BeginUpdate(ctx context.Context, resourceGroupName string, accountName string, parameters UpdateDataLakeStoreAccountParameters, options *AccountsClientBeginUpdateOptions) (*runtime.Poller[AccountsClientUpdateResponse], error)

BeginUpdate - Updates the specified Data Lake Store account information. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2016-11-01

  • resourceGroupName - The name of the Azure resource group.
  • accountName - The name of the Data Lake Store account.
  • parameters - Parameters supplied to update the Data Lake Store account.
  • options - AccountsClientBeginUpdateOptions contains the optional parameters for the AccountsClient.BeginUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/7a2ac91de424f271cf91cc8009f3fe9ee8249086/specification/datalake-store/resource-manager/Microsoft.DataLakeStore/stable/2016-11-01/examples/Accounts_Update.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/datalake-store/armdatalakestore"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armdatalakestore.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewAccountsClient().BeginUpdate(ctx, "contosorg", "contosoadla", armdatalakestore.UpdateDataLakeStoreAccountParameters{
		Properties: &armdatalakestore.UpdateDataLakeStoreAccountProperties{
			DefaultGroup: to.Ptr("test_default_group"),
			EncryptionConfig: &armdatalakestore.UpdateEncryptionConfig{
				KeyVaultMetaInfo: &armdatalakestore.UpdateKeyVaultMetaInfo{
					EncryptionKeyVersion: to.Ptr("encryption_key_version"),
				},
			},
			FirewallAllowAzureIPs:  to.Ptr(armdatalakestore.FirewallAllowAzureIPsStateEnabled),
			FirewallState:          to.Ptr(armdatalakestore.FirewallStateEnabled),
			NewTier:                to.Ptr(armdatalakestore.TierTypeConsumption),
			TrustedIDProviderState: to.Ptr(armdatalakestore.TrustedIDProviderStateEnabled),
		},
		Tags: map[string]*string{
			"test_key": to.Ptr("test_value"),
		},
	}, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	res, err := poller.PollUntilDone(ctx, nil)
	if err != nil {
		log.Fatalf("failed to pull the result: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res.Account = armdatalakestore.Account{
	// 	Name: to.Ptr("contosoadla"),
	// 	Type: to.Ptr("test_type"),
	// 	ID: to.Ptr("34adfa4f-cedf-4dc0-ba29-b6d1a69ab345"),
	// 	Location: to.Ptr("eastus2"),
	// 	Tags: map[string]*string{
	// 		"test_key": to.Ptr("test_value"),
	// 	},
	// 	Identity: &armdatalakestore.EncryptionIdentity{
	// 		Type: to.Ptr("SystemAssigned"),
	// 		PrincipalID: to.Ptr("34adfa4f-cedf-4dc0-ba29-b6d1a69ab345"),
	// 		TenantID: to.Ptr("34adfa4f-cedf-4dc0-ba29-b6d1a69ab346"),
	// 	},
	// 	Properties: &armdatalakestore.AccountProperties{
	// 		AccountID: to.Ptr("94f4bf5d-78a9-4c31-8aa7-b34d07bad898"),
	// 		CreationTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-04-14T20:21:56.681Z"); return t}()),
	// 		Endpoint: to.Ptr("testadlfs17607.azuredatalakestore.net"),
	// 		LastModifiedTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-04-14T20:21:56.681Z"); return t}()),
	// 		ProvisioningState: to.Ptr(armdatalakestore.DataLakeStoreAccountStatusSucceeded),
	// 		State: to.Ptr(armdatalakestore.DataLakeStoreAccountStateActive),
	// 		CurrentTier: to.Ptr(armdatalakestore.TierTypeConsumption),
	// 		DefaultGroup: to.Ptr("test_default_group"),
	// 		EncryptionConfig: &armdatalakestore.EncryptionConfig{
	// 			Type: to.Ptr(armdatalakestore.EncryptionConfigTypeUserManaged),
	// 			KeyVaultMetaInfo: &armdatalakestore.KeyVaultMetaInfo{
	// 				EncryptionKeyName: to.Ptr("test_encryption_key_name"),
	// 				EncryptionKeyVersion: to.Ptr("encryption_key_version"),
	// 				KeyVaultResourceID: to.Ptr("34adfa4f-cedf-4dc0-ba29-b6d1a69ab345"),
	// 			},
	// 		},
	// 		EncryptionProvisioningState: to.Ptr(armdatalakestore.EncryptionProvisioningStateSucceeded),
	// 		EncryptionState: to.Ptr(armdatalakestore.EncryptionStateEnabled),
	// 		FirewallAllowAzureIPs: to.Ptr(armdatalakestore.FirewallAllowAzureIPsStateEnabled),
	// 		FirewallRules: []*armdatalakestore.FirewallRule{
	// 			{
	// 				Name: to.Ptr("test_rule"),
	// 				Type: to.Ptr("test_type"),
	// 				ID: to.Ptr("34adfa4f-cedf-4dc0-ba29-b6d1a69ab345"),
	// 				Properties: &armdatalakestore.FirewallRuleProperties{
	// 					EndIPAddress: to.Ptr("2.2.2.2"),
	// 					StartIPAddress: to.Ptr("1.1.1.1"),
	// 				},
	// 		}},
	// 		FirewallState: to.Ptr(armdatalakestore.FirewallStateEnabled),
	// 		NewTier: to.Ptr(armdatalakestore.TierTypeConsumption),
	// 		TrustedIDProviderState: to.Ptr(armdatalakestore.TrustedIDProviderStateEnabled),
	// 		TrustedIDProviders: []*armdatalakestore.TrustedIDProvider{
	// 			{
	// 				Name: to.Ptr("test_trusted_id_provider_name"),
	// 				Type: to.Ptr("test_type"),
	// 				ID: to.Ptr("34adfa4f-cedf-4dc0-ba29-b6d1a69ab345"),
	// 				Properties: &armdatalakestore.TrustedIDProviderProperties{
	// 					IDProvider: to.Ptr("https://sts.windows.net/ea9ec534-a3e3-4e45-ad36-3afc5bb291c1"),
	// 				},
	// 		}},
	// 	},
	// }
}

Output:

func (*AccountsClient) CheckNameAvailability 

func (client *AccountsClient) CheckNameAvailability(ctx context.Context, location string, parameters CheckNameAvailabilityParameters, options *AccountsClientCheckNameAvailabilityOptions) (AccountsClientCheckNameAvailabilityResponse, error)

CheckNameAvailability - Checks whether the specified account name is available or taken. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2016-11-01

  • location - The resource location without whitespace.
  • parameters - Parameters supplied to check the Data Lake Store account name availability.
  • options - AccountsClientCheckNameAvailabilityOptions contains the optional parameters for the AccountsClient.CheckNameAvailability method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/7a2ac91de424f271cf91cc8009f3fe9ee8249086/specification/datalake-store/resource-manager/Microsoft.DataLakeStore/stable/2016-11-01/examples/Accounts_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/datalake-store/armdatalakestore"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armdatalakestore.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewAccountsClient().CheckNameAvailability(ctx, "EastUS2", armdatalakestore.CheckNameAvailabilityParameters{
		Name: to.Ptr("contosoadla"),
		Type: to.Ptr(armdatalakestore.CheckNameAvailabilityParametersTypeMicrosoftDataLakeStoreAccounts),
	}, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res.NameAvailabilityInformation = armdatalakestore.NameAvailabilityInformation{
	// 	Message: to.Ptr("An account named 'abc' already exists."),
	// 	NameAvailable: to.Ptr(false),
	// 	Reason: to.Ptr("AlreadyExists"),
	// }
}

Output:

func (*AccountsClient) EnableKeyVault 

func (client *AccountsClient) EnableKeyVault(ctx context.Context, resourceGroupName string, accountName string, options *AccountsClientEnableKeyVaultOptions) (AccountsClientEnableKeyVaultResponse, error)

EnableKeyVault - Attempts to enable a user managed Key Vault for encryption of the specified Data Lake Store account. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2016-11-01

  • resourceGroupName - The name of the Azure resource group.
  • accountName - The name of the Data Lake Store account.
  • options - AccountsClientEnableKeyVaultOptions contains the optional parameters for the AccountsClient.EnableKeyVault method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/7a2ac91de424f271cf91cc8009f3fe9ee8249086/specification/datalake-store/resource-manager/Microsoft.DataLakeStore/stable/2016-11-01/examples/Accounts_EnableKeyVault.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/datalake-store/armdatalakestore"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armdatalakestore.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	_, err = clientFactory.NewAccountsClient().EnableKeyVault(ctx, "contosorg", "contosoadla", nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
}

Output:

func (*AccountsClient) Get 

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

Get - Gets the specified Data Lake Store account. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2016-11-01

  • resourceGroupName - The name of the Azure resource group.
  • accountName - The name of the Data Lake Store account.
  • options - AccountsClientGetOptions contains the optional parameters for the AccountsClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/7a2ac91de424f271cf91cc8009f3fe9ee8249086/specification/datalake-store/resource-manager/Microsoft.DataLakeStore/stable/2016-11-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/datalake-store/armdatalakestore"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armdatalakestore.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewAccountsClient().Get(ctx, "contosorg", "contosoadla", nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res.Account = armdatalakestore.Account{
	// 	Name: to.Ptr("contosoadla"),
	// 	Type: to.Ptr("test_type"),
	// 	ID: to.Ptr("34adfa4f-cedf-4dc0-ba29-b6d1a69ab345"),
	// 	Location: to.Ptr("eastus2"),
	// 	Tags: map[string]*string{
	// 		"test_key": to.Ptr("test_value"),
	// 	},
	// 	Identity: &armdatalakestore.EncryptionIdentity{
	// 		Type: to.Ptr("SystemAssigned"),
	// 		PrincipalID: to.Ptr("34adfa4f-cedf-4dc0-ba29-b6d1a69ab345"),
	// 		TenantID: to.Ptr("34adfa4f-cedf-4dc0-ba29-b6d1a69ab346"),
	// 	},
	// 	Properties: &armdatalakestore.AccountProperties{
	// 		AccountID: to.Ptr("94f4bf5d-78a9-4c31-8aa7-b34d07bad898"),
	// 		CreationTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-04-14T20:21:56.681Z"); return t}()),
	// 		Endpoint: to.Ptr("testadlfs17607.azuredatalakestore.net"),
	// 		LastModifiedTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-04-14T20:21:56.681Z"); return t}()),
	// 		ProvisioningState: to.Ptr(armdatalakestore.DataLakeStoreAccountStatusSucceeded),
	// 		State: to.Ptr(armdatalakestore.DataLakeStoreAccountStateActive),
	// 		CurrentTier: to.Ptr(armdatalakestore.TierTypeConsumption),
	// 		DefaultGroup: to.Ptr("test_default_group"),
	// 		EncryptionConfig: &armdatalakestore.EncryptionConfig{
	// 			Type: to.Ptr(armdatalakestore.EncryptionConfigTypeUserManaged),
	// 			KeyVaultMetaInfo: &armdatalakestore.KeyVaultMetaInfo{
	// 				EncryptionKeyName: to.Ptr("test_encryption_key_name"),
	// 				EncryptionKeyVersion: to.Ptr("encryption_key_version"),
	// 				KeyVaultResourceID: to.Ptr("34adfa4f-cedf-4dc0-ba29-b6d1a69ab345"),
	// 			},
	// 		},
	// 		EncryptionProvisioningState: to.Ptr(armdatalakestore.EncryptionProvisioningStateSucceeded),
	// 		EncryptionState: to.Ptr(armdatalakestore.EncryptionStateEnabled),
	// 		FirewallAllowAzureIPs: to.Ptr(armdatalakestore.FirewallAllowAzureIPsStateEnabled),
	// 		FirewallRules: []*armdatalakestore.FirewallRule{
	// 			{
	// 				Name: to.Ptr("test_rule"),
	// 				Type: to.Ptr("test_type"),
	// 				ID: to.Ptr("34adfa4f-cedf-4dc0-ba29-b6d1a69ab345"),
	// 				Properties: &armdatalakestore.FirewallRuleProperties{
	// 					EndIPAddress: to.Ptr("2.2.2.2"),
	// 					StartIPAddress: to.Ptr("1.1.1.1"),
	// 				},
	// 		}},
	// 		FirewallState: to.Ptr(armdatalakestore.FirewallStateEnabled),
	// 		NewTier: to.Ptr(armdatalakestore.TierTypeConsumption),
	// 		TrustedIDProviderState: to.Ptr(armdatalakestore.TrustedIDProviderStateEnabled),
	// 		TrustedIDProviders: []*armdatalakestore.TrustedIDProvider{
	// 			{
	// 				Name: to.Ptr("test_trusted_id_provider_name"),
	// 				Type: to.Ptr("test_type"),
	// 				ID: to.Ptr("34adfa4f-cedf-4dc0-ba29-b6d1a69ab345"),
	// 				Properties: &armdatalakestore.TrustedIDProviderProperties{
	// 					IDProvider: to.Ptr("https://sts.windows.net/ea9ec534-a3e3-4e45-ad36-3afc5bb291c1"),
	// 				},
	// 		}},
	// 	},
	// }
}

Output:

func (*AccountsClient) NewListByResourceGroupPager added in v0.5.0 

func (client *AccountsClient) NewListByResourceGroupPager(resourceGroupName string, options *AccountsClientListByResourceGroupOptions) *runtime.Pager[AccountsClientListByResourceGroupResponse]

NewListByResourceGroupPager - Lists the Data Lake Store accounts within a specific resource group. The response includes a link to the next page of results, if any.

Generated from API version 2016-11-01

  • resourceGroupName - The name of the Azure resource group.
  • options - AccountsClientListByResourceGroupOptions contains the optional parameters for the AccountsClient.NewListByResourceGroupPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/7a2ac91de424f271cf91cc8009f3fe9ee8249086/specification/datalake-store/resource-manager/Microsoft.DataLakeStore/stable/2016-11-01/examples/Accounts_ListByResourceGroup.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/datalake-store/armdatalakestore"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armdatalakestore.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewAccountsClient().NewListByResourceGroupPager("contosorg", &armdatalakestore.AccountsClientListByResourceGroupOptions{Filter: to.Ptr("test_filter"),
		Top:     to.Ptr[int32](1),
		Skip:    to.Ptr[int32](1),
		Select:  to.Ptr("test_select"),
		Orderby: to.Ptr("test_orderby"),
		Count:   to.Ptr(false),
	})
	for pager.More() {
		page, err := pager.NextPage(ctx)
		if err != nil {
			log.Fatalf("failed to advance page: %v", err)
		}
		for _, v := range page.Value {
			// You could use page here. We use blank identifier for just demo purposes.
			_ = v
		}
		// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
		// page.AccountListResult = armdatalakestore.AccountListResult{
		// 	Value: []*armdatalakestore.AccountBasic{
		// 		{
		// 			Name: to.Ptr("contosoadla"),
		// 			Type: to.Ptr("test_type"),
		// 			ID: to.Ptr("34adfa4f-cedf-4dc0-ba29-b6d1a69ab345"),
		// 			Location: to.Ptr("eastus2"),
		// 			Tags: map[string]*string{
		// 				"test_key": to.Ptr("test_value"),
		// 			},
		// 			Properties: &armdatalakestore.AccountPropertiesBasic{
		// 				AccountID: to.Ptr("94f4bf5d-78a9-4c31-8aa7-b34d07bad898"),
		// 				CreationTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-04-14T20:21:56.681Z"); return t}()),
		// 				Endpoint: to.Ptr("testadlfs17607.azuredatalakestore.net"),
		// 				LastModifiedTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-04-14T20:21:56.681Z"); return t}()),
		// 				ProvisioningState: to.Ptr(armdatalakestore.DataLakeStoreAccountStatusSucceeded),
		// 				State: to.Ptr(armdatalakestore.DataLakeStoreAccountStateActive),
		// 			},
		// 	}},
		// }
	}
}

Output:

func (*AccountsClient) NewListPager added in v0.5.0 

func (client *AccountsClient) NewListPager(options *AccountsClientListOptions) *runtime.Pager[AccountsClientListResponse]

NewListPager - Lists the Data Lake Store accounts within the subscription. The response includes a link to the next page of results, if any.

Generated from API version 2016-11-01

  • options - AccountsClientListOptions contains the optional parameters for the AccountsClient.NewListPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/7a2ac91de424f271cf91cc8009f3fe9ee8249086/specification/datalake-store/resource-manager/Microsoft.DataLakeStore/stable/2016-11-01/examples/Accounts_List.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/datalake-store/armdatalakestore"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armdatalakestore.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewAccountsClient().NewListPager(&armdatalakestore.AccountsClientListOptions{Filter: to.Ptr("test_filter"),
		Top:     to.Ptr[int32](1),
		Skip:    to.Ptr[int32](1),
		Select:  to.Ptr("test_select"),
		Orderby: to.Ptr("test_orderby"),
		Count:   to.Ptr(false),
	})
	for pager.More() {
		page, err := pager.NextPage(ctx)
		if err != nil {
			log.Fatalf("failed to advance page: %v", err)
		}
		for _, v := range page.Value {
			// You could use page here. We use blank identifier for just demo purposes.
			_ = v
		}
		// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
		// page.AccountListResult = armdatalakestore.AccountListResult{
		// 	Value: []*armdatalakestore.AccountBasic{
		// 		{
		// 			Name: to.Ptr("contosoadla"),
		// 			Type: to.Ptr("test_type"),
		// 			ID: to.Ptr("34adfa4f-cedf-4dc0-ba29-b6d1a69ab345"),
		// 			Location: to.Ptr("eastus2"),
		// 			Tags: map[string]*string{
		// 				"test_key": to.Ptr("test_value"),
		// 			},
		// 			Properties: &armdatalakestore.AccountPropertiesBasic{
		// 				AccountID: to.Ptr("94f4bf5d-78a9-4c31-8aa7-b34d07bad898"),
		// 				CreationTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-04-14T20:21:56.681Z"); return t}()),
		// 				Endpoint: to.Ptr("testadlfs17607.azuredatalakestore.net"),
		// 				LastModifiedTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-04-14T20:21:56.681Z"); return t}()),
		// 				ProvisioningState: to.Ptr(armdatalakestore.DataLakeStoreAccountStatusSucceeded),
		// 				State: to.Ptr(armdatalakestore.DataLakeStoreAccountStateActive),
		// 			},
		// 	}},
		// }
	}
}

Output:

type AccountsClientBeginCreateOptions added in v0.3.0 

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

AccountsClientBeginCreateOptions contains the optional parameters for the AccountsClient.BeginCreate method.

type AccountsClientBeginDeleteOptions added in v0.3.0 

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

AccountsClientBeginDeleteOptions contains the optional parameters for the AccountsClient.BeginDelete method.

type AccountsClientBeginUpdateOptions added in v0.3.0 

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

AccountsClientBeginUpdateOptions contains the optional parameters for the AccountsClient.BeginUpdate method.

type AccountsClientCheckNameAvailabilityOptions added in v0.3.0 

type AccountsClientCheckNameAvailabilityOptions struct {
}

AccountsClientCheckNameAvailabilityOptions contains the optional parameters for the AccountsClient.CheckNameAvailability method.

type AccountsClientCheckNameAvailabilityResponse added in v0.3.0 

type AccountsClientCheckNameAvailabilityResponse struct {
	// Data Lake Store account name availability result information.
	NameAvailabilityInformation
}

AccountsClientCheckNameAvailabilityResponse contains the response from method AccountsClient.CheckNameAvailability.

type AccountsClientCreateResponse added in v0.3.0 

type AccountsClientCreateResponse struct {
	// Data Lake Store account information.
	Account
}

AccountsClientCreateResponse contains the response from method AccountsClient.BeginCreate.

type AccountsClientDeleteResponse added in v0.3.0 

type AccountsClientDeleteResponse struct {
}

AccountsClientDeleteResponse contains the response from method AccountsClient.BeginDelete.

type AccountsClientEnableKeyVaultOptions added in v0.3.0 

type AccountsClientEnableKeyVaultOptions struct {
}

AccountsClientEnableKeyVaultOptions contains the optional parameters for the AccountsClient.EnableKeyVault method.

type AccountsClientEnableKeyVaultResponse added in v0.3.0 

type AccountsClientEnableKeyVaultResponse struct {
}

AccountsClientEnableKeyVaultResponse contains the response from method AccountsClient.EnableKeyVault.

type AccountsClientGetOptions added in v0.3.0 

type AccountsClientGetOptions struct {
}

AccountsClientGetOptions contains the optional parameters for the AccountsClient.Get method.

type AccountsClientGetResponse added in v0.3.0 

type AccountsClientGetResponse struct {
	// Data Lake Store account information.
	Account
}

AccountsClientGetResponse contains the response from method AccountsClient.Get.

type AccountsClientListByResourceGroupOptions added in v0.3.0 

type AccountsClientListByResourceGroupOptions struct {
	// A Boolean value of true or false to request a count of the matching resources included with the resources in the response,
	// e.g. Categories?$count=true. Optional.
	Count *bool

	// OData filter. Optional.
	Filter *string

	// OrderBy clause. One or more comma-separated expressions with an optional "asc" (the default) or "desc" depending on the
	// order you'd like the values sorted, e.g. Categories?$orderby=CategoryName desc.
	// Optional.
	Orderby *string

	// OData Select statement. Limits the properties on each entry to just those requested, e.g. Categories?$select=CategoryName,Description.
	// Optional.
	Select *string

	// The number of items to skip over before returning elements. Optional.
	Skip *int32

	// The number of items to return. Optional.
	Top *int32
}

AccountsClientListByResourceGroupOptions contains the optional parameters for the AccountsClient.NewListByResourceGroupPager method.

type AccountsClientListByResourceGroupResponse added in v0.3.0 

type AccountsClientListByResourceGroupResponse struct {
	// Data Lake Store account list information response.
	AccountListResult
}

AccountsClientListByResourceGroupResponse contains the response from method AccountsClient.NewListByResourceGroupPager.

type AccountsClientListOptions added in v0.3.0 

type AccountsClientListOptions struct {
	// The Boolean value of true or false to request a count of the matching resources included with the resources in the response,
	// e.g. Categories?$count=true. Optional.
	Count *bool

	// OData filter. Optional.
	Filter *string

	// OrderBy clause. One or more comma-separated expressions with an optional "asc" (the default) or "desc" depending on the
	// order you'd like the values sorted, e.g. Categories?$orderby=CategoryName desc.
	// Optional.
	Orderby *string

	// OData Select statement. Limits the properties on each entry to just those requested, e.g. Categories?$select=CategoryName,Description.
	// Optional.
	Select *string

	// The number of items to skip over before returning elements. Optional.
	Skip *int32

	// The number of items to return. Optional.
	Top *int32
}

AccountsClientListOptions contains the optional parameters for the AccountsClient.NewListPager method.

type AccountsClientListResponse added in v0.3.0 

type AccountsClientListResponse struct {
	// Data Lake Store account list information response.
	AccountListResult
}

AccountsClientListResponse contains the response from method AccountsClient.NewListPager.

type AccountsClientUpdateResponse added in v0.3.0 

type AccountsClientUpdateResponse struct {
	// Data Lake Store account information.
	Account
}

AccountsClientUpdateResponse contains the response from method AccountsClient.BeginUpdate.

type CapabilityInformation 

type CapabilityInformation struct {
	// READ-ONLY; The current number of accounts under this subscription.
	AccountCount *int32

	// READ-ONLY; The maximum supported number of accounts under this subscription.
	MaxAccountCount *int32

	// READ-ONLY; The Boolean value of true or false to indicate the maintenance state.
	MigrationState *bool

	// READ-ONLY; The subscription state.
	State *SubscriptionState

	// READ-ONLY; The subscription credentials that uniquely identifies the subscription.
	SubscriptionID *string
}

CapabilityInformation - Subscription-level properties and limits for Data Lake Store.

func (CapabilityInformation) MarshalJSON added in v1.1.0 

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

MarshalJSON implements the json.Marshaller interface for type CapabilityInformation.

func (*CapabilityInformation) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type CapabilityInformation.

type CheckNameAvailabilityParameters 

type CheckNameAvailabilityParameters struct {
	// REQUIRED; The Data Lake Store name to check availability for.
	Name *string

	// REQUIRED; The resource type. Note: This should not be set by the user, as the constant value is Microsoft.DataLakeStore/accounts
	Type *CheckNameAvailabilityParametersType
}

CheckNameAvailabilityParameters - Data Lake Store account name availability check parameters.

func (CheckNameAvailabilityParameters) MarshalJSON added in v1.1.0 

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

MarshalJSON implements the json.Marshaller interface for type CheckNameAvailabilityParameters.

func (*CheckNameAvailabilityParameters) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type CheckNameAvailabilityParameters.

type CheckNameAvailabilityParametersType 

type CheckNameAvailabilityParametersType string

CheckNameAvailabilityParametersType - The resource type. Note: This should not be set by the user, as the constant value is Microsoft.DataLakeStore/accounts 

const (
	CheckNameAvailabilityParametersTypeMicrosoftDataLakeStoreAccounts CheckNameAvailabilityParametersType = "Microsoft.DataLakeStore/accounts"
)

func PossibleCheckNameAvailabilityParametersTypeValues 

func PossibleCheckNameAvailabilityParametersTypeValues() []CheckNameAvailabilityParametersType

PossibleCheckNameAvailabilityParametersTypeValues returns the possible values for the CheckNameAvailabilityParametersType const type.

type ClientFactory added in v1.1.0 

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

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

func NewClientFactory added in v1.1.0 

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

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

  • subscriptionID - Gets subscription credentials which uniquely identify Microsoft Azure subscription. The subscription ID forms part of the URI for every service call.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*ClientFactory) NewAccountsClient added in v1.1.0 

func (c *ClientFactory) NewAccountsClient() *AccountsClient

NewAccountsClient creates a new instance of AccountsClient.

func (*ClientFactory) NewFirewallRulesClient added in v1.1.0 

func (c *ClientFactory) NewFirewallRulesClient() *FirewallRulesClient

NewFirewallRulesClient creates a new instance of FirewallRulesClient.

func (*ClientFactory) NewLocationsClient added in v1.1.0 

func (c *ClientFactory) NewLocationsClient() *LocationsClient

NewLocationsClient creates a new instance of LocationsClient.

func (*ClientFactory) NewOperationsClient added in v1.1.0 

func (c *ClientFactory) NewOperationsClient() *OperationsClient

NewOperationsClient creates a new instance of OperationsClient.

func (*ClientFactory) NewTrustedIDProvidersClient added in v1.1.0 

func (c *ClientFactory) NewTrustedIDProvidersClient() *TrustedIDProvidersClient

NewTrustedIDProvidersClient creates a new instance of TrustedIDProvidersClient.

func (*ClientFactory) NewVirtualNetworkRulesClient added in v1.1.0 

func (c *ClientFactory) NewVirtualNetworkRulesClient() *VirtualNetworkRulesClient

NewVirtualNetworkRulesClient creates a new instance of VirtualNetworkRulesClient.

type CreateDataLakeStoreAccountParameters 

type CreateDataLakeStoreAccountParameters struct {
	// REQUIRED; The resource location.
	Location *string

	// The Key Vault encryption identity, if any.
	Identity *EncryptionIdentity

	// The Data Lake Store account properties to use for creating.
	Properties *CreateDataLakeStoreAccountProperties

	// The resource tags.
	Tags map[string]*string
}

func (CreateDataLakeStoreAccountParameters) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type CreateDataLakeStoreAccountParameters.

func (*CreateDataLakeStoreAccountParameters) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type CreateDataLakeStoreAccountParameters.

type CreateDataLakeStoreAccountProperties 

type CreateDataLakeStoreAccountProperties struct {
	// The default owner group for all new folders and files created in the Data Lake Store account.
	DefaultGroup *string

	// The Key Vault encryption configuration.
	EncryptionConfig *EncryptionConfig

	// The current state of encryption for this Data Lake Store account.
	EncryptionState *EncryptionState

	// The current state of allowing or disallowing IPs originating within Azure through the firewall. If the firewall is disabled,
	// this is not enforced.
	FirewallAllowAzureIPs *FirewallAllowAzureIPsState

	// The list of firewall rules associated with this Data Lake Store account.
	FirewallRules []*CreateFirewallRuleWithAccountParameters

	// The current state of the IP address firewall for this Data Lake Store account.
	FirewallState *FirewallState

	// The commitment tier to use for next month.
	NewTier *TierType

	// The current state of the trusted identity provider feature for this Data Lake Store account.
	TrustedIDProviderState *TrustedIDProviderState

	// The list of trusted identity providers associated with this Data Lake Store account.
	TrustedIDProviders []*CreateTrustedIDProviderWithAccountParameters

	// The list of virtual network rules associated with this Data Lake Store account.
	VirtualNetworkRules []*CreateVirtualNetworkRuleWithAccountParameters
}

func (CreateDataLakeStoreAccountProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type CreateDataLakeStoreAccountProperties.

func (*CreateDataLakeStoreAccountProperties) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type CreateDataLakeStoreAccountProperties.

type CreateFirewallRuleWithAccountParameters 

type CreateFirewallRuleWithAccountParameters struct {
	// REQUIRED; The unique name of the firewall rule to create.
	Name *string

	// REQUIRED; The firewall rule properties to use when creating a new firewall rule.
	Properties *CreateOrUpdateFirewallRuleProperties
}

CreateFirewallRuleWithAccountParameters - The parameters used to create a new firewall rule while creating a new Data Lake Store account.

func (CreateFirewallRuleWithAccountParameters) MarshalJSON added in v1.1.0 

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

MarshalJSON implements the json.Marshaller interface for type CreateFirewallRuleWithAccountParameters.

func (*CreateFirewallRuleWithAccountParameters) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type CreateFirewallRuleWithAccountParameters.

type CreateOrUpdateFirewallRuleParameters 

type CreateOrUpdateFirewallRuleParameters struct {
	// REQUIRED; The firewall rule properties to use when creating a new firewall rule.
	Properties *CreateOrUpdateFirewallRuleProperties
}

CreateOrUpdateFirewallRuleParameters - The parameters used to create a new firewall rule.

func (CreateOrUpdateFirewallRuleParameters) MarshalJSON added in v1.1.0 

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

MarshalJSON implements the json.Marshaller interface for type CreateOrUpdateFirewallRuleParameters.

func (*CreateOrUpdateFirewallRuleParameters) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type CreateOrUpdateFirewallRuleParameters.

type CreateOrUpdateFirewallRuleProperties 

type CreateOrUpdateFirewallRuleProperties struct {
	// REQUIRED; The end IP address for the firewall rule. This can be either ipv4 or ipv6. Start and End should be in the same
	// protocol.
	EndIPAddress *string

	// REQUIRED; The start IP address for the firewall rule. This can be either ipv4 or ipv6. Start and End should be in the same
	// protocol.
	StartIPAddress *string
}

CreateOrUpdateFirewallRuleProperties - The firewall rule properties to use when creating a new firewall rule.

func (CreateOrUpdateFirewallRuleProperties) MarshalJSON added in v1.1.0 

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

MarshalJSON implements the json.Marshaller interface for type CreateOrUpdateFirewallRuleProperties.

func (*CreateOrUpdateFirewallRuleProperties) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type CreateOrUpdateFirewallRuleProperties.

type CreateOrUpdateTrustedIDProviderParameters 

type CreateOrUpdateTrustedIDProviderParameters struct {
	// REQUIRED; The trusted identity provider properties to use when creating a new trusted identity provider.
	Properties *CreateOrUpdateTrustedIDProviderProperties
}

CreateOrUpdateTrustedIDProviderParameters - The parameters used to create a new trusted identity provider.

func (CreateOrUpdateTrustedIDProviderParameters) MarshalJSON added in v1.1.0 

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

MarshalJSON implements the json.Marshaller interface for type CreateOrUpdateTrustedIDProviderParameters.

func (*CreateOrUpdateTrustedIDProviderParameters) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type CreateOrUpdateTrustedIDProviderParameters.

type CreateOrUpdateTrustedIDProviderProperties 

type CreateOrUpdateTrustedIDProviderProperties struct {
	// REQUIRED; The URL of this trusted identity provider.
	IDProvider *string
}

CreateOrUpdateTrustedIDProviderProperties - The trusted identity provider properties to use when creating a new trusted identity provider.

func (CreateOrUpdateTrustedIDProviderProperties) MarshalJSON added in v1.1.0 

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

MarshalJSON implements the json.Marshaller interface for type CreateOrUpdateTrustedIDProviderProperties.

func (*CreateOrUpdateTrustedIDProviderProperties) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type CreateOrUpdateTrustedIDProviderProperties.

type CreateOrUpdateVirtualNetworkRuleParameters 

type CreateOrUpdateVirtualNetworkRuleParameters struct {
	// REQUIRED; The virtual network rule properties to use when creating a new virtual network rule.
	Properties *CreateOrUpdateVirtualNetworkRuleProperties
}

CreateOrUpdateVirtualNetworkRuleParameters - The parameters used to create a new virtual network rule.

func (CreateOrUpdateVirtualNetworkRuleParameters) MarshalJSON added in v1.1.0 

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

MarshalJSON implements the json.Marshaller interface for type CreateOrUpdateVirtualNetworkRuleParameters.

func (*CreateOrUpdateVirtualNetworkRuleParameters) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type CreateOrUpdateVirtualNetworkRuleParameters.

type CreateOrUpdateVirtualNetworkRuleProperties 

type CreateOrUpdateVirtualNetworkRuleProperties struct {
	// REQUIRED; The resource identifier for the subnet.
	SubnetID *string
}

CreateOrUpdateVirtualNetworkRuleProperties - The virtual network rule properties to use when creating a new virtual network rule.

func (CreateOrUpdateVirtualNetworkRuleProperties) MarshalJSON added in v1.1.0 

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

MarshalJSON implements the json.Marshaller interface for type CreateOrUpdateVirtualNetworkRuleProperties.

func (*CreateOrUpdateVirtualNetworkRuleProperties) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type CreateOrUpdateVirtualNetworkRuleProperties.

type CreateTrustedIDProviderWithAccountParameters 

type CreateTrustedIDProviderWithAccountParameters struct {
	// REQUIRED; The unique name of the trusted identity provider to create.
	Name *string

	// REQUIRED; The trusted identity provider properties to use when creating a new trusted identity provider.
	Properties *CreateOrUpdateTrustedIDProviderProperties
}

CreateTrustedIDProviderWithAccountParameters - The parameters used to create a new trusted identity provider while creating a new Data Lake Store account.

func (CreateTrustedIDProviderWithAccountParameters) MarshalJSON added in v1.1.0 

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

MarshalJSON implements the json.Marshaller interface for type CreateTrustedIDProviderWithAccountParameters.

func (*CreateTrustedIDProviderWithAccountParameters) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type CreateTrustedIDProviderWithAccountParameters.

type CreateVirtualNetworkRuleWithAccountParameters 

type CreateVirtualNetworkRuleWithAccountParameters struct {
	// REQUIRED; The unique name of the virtual network rule to create.
	Name *string

	// REQUIRED; The virtual network rule properties to use when creating a new virtual network rule.
	Properties *CreateOrUpdateVirtualNetworkRuleProperties
}

CreateVirtualNetworkRuleWithAccountParameters - The parameters used to create a new virtual network rule while creating a new Data Lake Store account.

func (CreateVirtualNetworkRuleWithAccountParameters) MarshalJSON added in v1.1.0 

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

MarshalJSON implements the json.Marshaller interface for type CreateVirtualNetworkRuleWithAccountParameters.

func (*CreateVirtualNetworkRuleWithAccountParameters) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type CreateVirtualNetworkRuleWithAccountParameters.

type DataLakeStoreAccountState 

type DataLakeStoreAccountState string

DataLakeStoreAccountState - The state of the Data Lake Store account. 

const (
	DataLakeStoreAccountStateActive    DataLakeStoreAccountState = "Active"
	DataLakeStoreAccountStateSuspended DataLakeStoreAccountState = "Suspended"
)

func PossibleDataLakeStoreAccountStateValues 

func PossibleDataLakeStoreAccountStateValues() []DataLakeStoreAccountState

PossibleDataLakeStoreAccountStateValues returns the possible values for the DataLakeStoreAccountState const type.

type DataLakeStoreAccountStatus 

type DataLakeStoreAccountStatus string

DataLakeStoreAccountStatus - The provisioning status of the Data Lake Store account. 

const (
	DataLakeStoreAccountStatusCanceled   DataLakeStoreAccountStatus = "Canceled"
	DataLakeStoreAccountStatusCreating   DataLakeStoreAccountStatus = "Creating"
	DataLakeStoreAccountStatusDeleted    DataLakeStoreAccountStatus = "Deleted"
	DataLakeStoreAccountStatusDeleting   DataLakeStoreAccountStatus = "Deleting"
	DataLakeStoreAccountStatusFailed     DataLakeStoreAccountStatus = "Failed"
	DataLakeStoreAccountStatusPatching   DataLakeStoreAccountStatus = "Patching"
	DataLakeStoreAccountStatusResuming   DataLakeStoreAccountStatus = "Resuming"
	DataLakeStoreAccountStatusRunning    DataLakeStoreAccountStatus = "Running"
	DataLakeStoreAccountStatusSucceeded  DataLakeStoreAccountStatus = "Succeeded"
	DataLakeStoreAccountStatusSuspending DataLakeStoreAccountStatus = "Suspending"
	DataLakeStoreAccountStatusUndeleting DataLakeStoreAccountStatus = "Undeleting"
)

func PossibleDataLakeStoreAccountStatusValues 

func PossibleDataLakeStoreAccountStatusValues() []DataLakeStoreAccountStatus

PossibleDataLakeStoreAccountStatusValues returns the possible values for the DataLakeStoreAccountStatus const type.

type EncryptionConfig 

type EncryptionConfig struct {
	// REQUIRED; The type of encryption configuration being used. Currently the only supported types are 'UserManaged' and 'ServiceManaged'.
	Type *EncryptionConfigType

	// The Key Vault information for connecting to user managed encryption keys.
	KeyVaultMetaInfo *KeyVaultMetaInfo
}

EncryptionConfig - The encryption configuration for the account.

func (EncryptionConfig) MarshalJSON added in v1.1.0 

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

MarshalJSON implements the json.Marshaller interface for type EncryptionConfig.

func (*EncryptionConfig) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type EncryptionConfig.

type EncryptionConfigType 

type EncryptionConfigType string

EncryptionConfigType - The type of encryption configuration being used. Currently the only supported types are 'UserManaged' and 'ServiceManaged'. 

const (
	EncryptionConfigTypeServiceManaged EncryptionConfigType = "ServiceManaged"
	EncryptionConfigTypeUserManaged    EncryptionConfigType = "UserManaged"
)

func PossibleEncryptionConfigTypeValues 

func PossibleEncryptionConfigTypeValues() []EncryptionConfigType

PossibleEncryptionConfigTypeValues returns the possible values for the EncryptionConfigType const type.

type EncryptionIdentity 

type EncryptionIdentity struct {
	// CONSTANT; The type of encryption being used. Currently the only supported type is 'SystemAssigned'.
	// Field has constant value "SystemAssigned", any specified value is ignored.
	Type *string

	// READ-ONLY; The principal identifier associated with the encryption.
	PrincipalID *string

	// READ-ONLY; The tenant identifier associated with the encryption.
	TenantID *string
}

EncryptionIdentity - The encryption identity properties.

func (EncryptionIdentity) MarshalJSON added in v1.1.0 

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

MarshalJSON implements the json.Marshaller interface for type EncryptionIdentity.

func (*EncryptionIdentity) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type EncryptionIdentity.

type EncryptionProvisioningState 

type EncryptionProvisioningState string

EncryptionProvisioningState - The current state of encryption provisioning for this Data Lake Store account. 

const (
	EncryptionProvisioningStateCreating  EncryptionProvisioningState = "Creating"
	EncryptionProvisioningStateSucceeded EncryptionProvisioningState = "Succeeded"
)

func PossibleEncryptionProvisioningStateValues 

func PossibleEncryptionProvisioningStateValues() []EncryptionProvisioningState

PossibleEncryptionProvisioningStateValues returns the possible values for the EncryptionProvisioningState const type.

type EncryptionState 

type EncryptionState string

EncryptionState - The current state of encryption for this Data Lake Store account. 

const (
	EncryptionStateDisabled EncryptionState = "Disabled"
	EncryptionStateEnabled  EncryptionState = "Enabled"
)

func PossibleEncryptionStateValues 

func PossibleEncryptionStateValues() []EncryptionState

PossibleEncryptionStateValues returns the possible values for the EncryptionState const type.

type FirewallAllowAzureIPsState 

type FirewallAllowAzureIPsState string

FirewallAllowAzureIPsState - The current state of allowing or disallowing IPs originating within Azure through the firewall. If the firewall is disabled, this is not enforced. 

const (
	FirewallAllowAzureIPsStateDisabled FirewallAllowAzureIPsState = "Disabled"
	FirewallAllowAzureIPsStateEnabled  FirewallAllowAzureIPsState = "Enabled"
)

func PossibleFirewallAllowAzureIPsStateValues 

func PossibleFirewallAllowAzureIPsStateValues() []FirewallAllowAzureIPsState

PossibleFirewallAllowAzureIPsStateValues returns the possible values for the FirewallAllowAzureIPsState const type.

type FirewallRule 

type FirewallRule struct {
	// READ-ONLY; The resource identifier.
	ID *string

	// READ-ONLY; The resource name.
	Name *string

	// READ-ONLY; The firewall rule properties.
	Properties *FirewallRuleProperties

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

FirewallRule - Data Lake Store firewall rule information.

func (FirewallRule) MarshalJSON added in v1.1.0 

func (f FirewallRule) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type FirewallRule.

func (*FirewallRule) UnmarshalJSON added in v1.1.0 

func (f *FirewallRule) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type FirewallRule.

type FirewallRuleListResult 

type FirewallRuleListResult struct {
	// READ-ONLY; The link (url) to the next page of results.
	NextLink *string

	// READ-ONLY; The results of the list operation.
	Value []*FirewallRule
}

FirewallRuleListResult - Data Lake Store firewall rule list information.

func (FirewallRuleListResult) MarshalJSON 

func (f FirewallRuleListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type FirewallRuleListResult.

func (*FirewallRuleListResult) UnmarshalJSON added in v1.1.0 

func (f *FirewallRuleListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type FirewallRuleListResult.

type FirewallRuleProperties 

type FirewallRuleProperties struct {
	// READ-ONLY; The end IP address for the firewall rule. This can be either ipv4 or ipv6. Start and End should be in the same
	// protocol.
	EndIPAddress *string

	// READ-ONLY; The start IP address for the firewall rule. This can be either ipv4 or ipv6. Start and End should be in the
	// same protocol.
	StartIPAddress *string
}

FirewallRuleProperties - The firewall rule properties.

func (FirewallRuleProperties) MarshalJSON added in v1.1.0 

func (f FirewallRuleProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type FirewallRuleProperties.

func (*FirewallRuleProperties) UnmarshalJSON added in v1.1.0 

func (f *FirewallRuleProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type FirewallRuleProperties.

type FirewallRulesClient 

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

FirewallRulesClient contains the methods for the FirewallRules group. Don't use this type directly, use NewFirewallRulesClient() instead.

func NewFirewallRulesClient 

func NewFirewallRulesClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*FirewallRulesClient, error)

NewFirewallRulesClient creates a new instance of FirewallRulesClient with the specified values.

  • subscriptionID - Gets subscription credentials which uniquely identify Microsoft Azure subscription. The subscription ID forms part of the URI for every service call.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*FirewallRulesClient) CreateOrUpdate 

func (client *FirewallRulesClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, accountName string, firewallRuleName string, parameters CreateOrUpdateFirewallRuleParameters, options *FirewallRulesClientCreateOrUpdateOptions) (FirewallRulesClientCreateOrUpdateResponse, error)

CreateOrUpdate - Creates or updates the specified firewall rule. During update, the firewall rule with the specified name will be replaced with this new firewall rule. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2016-11-01

  • resourceGroupName - The name of the Azure resource group.
  • accountName - The name of the Data Lake Store account.
  • firewallRuleName - The name of the firewall rule to create or update.
  • parameters - Parameters supplied to create or update the firewall rule.
  • options - FirewallRulesClientCreateOrUpdateOptions contains the optional parameters for the FirewallRulesClient.CreateOrUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/7a2ac91de424f271cf91cc8009f3fe9ee8249086/specification/datalake-store/resource-manager/Microsoft.DataLakeStore/stable/2016-11-01/examples/FirewallRules_CreateOrUpdate.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/datalake-store/armdatalakestore"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armdatalakestore.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewFirewallRulesClient().CreateOrUpdate(ctx, "contosorg", "contosoadla", "test_rule", armdatalakestore.CreateOrUpdateFirewallRuleParameters{
		Properties: &armdatalakestore.CreateOrUpdateFirewallRuleProperties{
			EndIPAddress:   to.Ptr("2.2.2.2"),
			StartIPAddress: to.Ptr("1.1.1.1"),
		},
	}, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res.FirewallRule = armdatalakestore.FirewallRule{
	// 	Name: to.Ptr("test_rule"),
	// 	Type: to.Ptr("test_type"),
	// 	ID: to.Ptr("34adfa4f-cedf-4dc0-ba29-b6d1a69ab345"),
	// 	Properties: &armdatalakestore.FirewallRuleProperties{
	// 		EndIPAddress: to.Ptr("2.2.2.2"),
	// 		StartIPAddress: to.Ptr("1.1.1.1"),
	// 	},
	// }
}

Output:

func (*FirewallRulesClient) Delete 

func (client *FirewallRulesClient) Delete(ctx context.Context, resourceGroupName string, accountName string, firewallRuleName string, options *FirewallRulesClientDeleteOptions) (FirewallRulesClientDeleteResponse, error)

Delete - Deletes the specified firewall rule from the specified Data Lake Store account. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2016-11-01

  • resourceGroupName - The name of the Azure resource group.
  • accountName - The name of the Data Lake Store account.
  • firewallRuleName - The name of the firewall rule to delete.
  • options - FirewallRulesClientDeleteOptions contains the optional parameters for the FirewallRulesClient.Delete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/7a2ac91de424f271cf91cc8009f3fe9ee8249086/specification/datalake-store/resource-manager/Microsoft.DataLakeStore/stable/2016-11-01/examples/FirewallRules_Delete.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/datalake-store/armdatalakestore"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armdatalakestore.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	_, err = clientFactory.NewFirewallRulesClient().Delete(ctx, "contosorg", "contosoadla", "test_rule", nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
}

Output:

func (*FirewallRulesClient) Get 

func (client *FirewallRulesClient) Get(ctx context.Context, resourceGroupName string, accountName string, firewallRuleName string, options *FirewallRulesClientGetOptions) (FirewallRulesClientGetResponse, error)

Get - Gets the specified Data Lake Store firewall rule. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2016-11-01

  • resourceGroupName - The name of the Azure resource group.
  • accountName - The name of the Data Lake Store account.
  • firewallRuleName - The name of the firewall rule to retrieve.
  • options - FirewallRulesClientGetOptions contains the optional parameters for the FirewallRulesClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/7a2ac91de424f271cf91cc8009f3fe9ee8249086/specification/datalake-store/resource-manager/Microsoft.DataLakeStore/stable/2016-11-01/examples/FirewallRules_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/datalake-store/armdatalakestore"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armdatalakestore.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewFirewallRulesClient().Get(ctx, "contosorg", "contosoadla", "test_rule", nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res.FirewallRule = armdatalakestore.FirewallRule{
	// 	Name: to.Ptr("test_rule"),
	// 	Type: to.Ptr("test_type"),
	// 	ID: to.Ptr("34adfa4f-cedf-4dc0-ba29-b6d1a69ab345"),
	// 	Properties: &armdatalakestore.FirewallRuleProperties{
	// 		EndIPAddress: to.Ptr("2.2.2.2"),
	// 		StartIPAddress: to.Ptr("1.1.1.1"),
	// 	},
	// }
}

Output:

func (*FirewallRulesClient) NewListByAccountPager added in v0.5.0 

func (client *FirewallRulesClient) NewListByAccountPager(resourceGroupName string, accountName string, options *FirewallRulesClientListByAccountOptions) *runtime.Pager[FirewallRulesClientListByAccountResponse]

NewListByAccountPager - Lists the Data Lake Store firewall rules within the specified Data Lake Store account.

Generated from API version 2016-11-01

  • resourceGroupName - The name of the Azure resource group.
  • accountName - The name of the Data Lake Store account.
  • options - FirewallRulesClientListByAccountOptions contains the optional parameters for the FirewallRulesClient.NewListByAccountPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/7a2ac91de424f271cf91cc8009f3fe9ee8249086/specification/datalake-store/resource-manager/Microsoft.DataLakeStore/stable/2016-11-01/examples/FirewallRules_ListByAccount.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/datalake-store/armdatalakestore"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armdatalakestore.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewFirewallRulesClient().NewListByAccountPager("contosorg", "contosoadla", nil)
	for pager.More() {
		page, err := pager.NextPage(ctx)
		if err != nil {
			log.Fatalf("failed to advance page: %v", err)
		}
		for _, v := range page.Value {
			// You could use page here. We use blank identifier for just demo purposes.
			_ = v
		}
		// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
		// page.FirewallRuleListResult = armdatalakestore.FirewallRuleListResult{
		// 	Value: []*armdatalakestore.FirewallRule{
		// 		{
		// 			Name: to.Ptr("test_rule"),
		// 			Type: to.Ptr("test_type"),
		// 			ID: to.Ptr("34adfa4f-cedf-4dc0-ba29-b6d1a69ab345"),
		// 			Properties: &armdatalakestore.FirewallRuleProperties{
		// 				EndIPAddress: to.Ptr("2.2.2.2"),
		// 				StartIPAddress: to.Ptr("1.1.1.1"),
		// 			},
		// 	}},
		// }
	}
}

Output:

func (*FirewallRulesClient) Update 

func (client *FirewallRulesClient) Update(ctx context.Context, resourceGroupName string, accountName string, firewallRuleName string, options *FirewallRulesClientUpdateOptions) (FirewallRulesClientUpdateResponse, error)

Update - Updates the specified firewall rule. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2016-11-01

  • resourceGroupName - The name of the Azure resource group.
  • accountName - The name of the Data Lake Store account.
  • firewallRuleName - The name of the firewall rule to update.
  • options - FirewallRulesClientUpdateOptions contains the optional parameters for the FirewallRulesClient.Update method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/7a2ac91de424f271cf91cc8009f3fe9ee8249086/specification/datalake-store/resource-manager/Microsoft.DataLakeStore/stable/2016-11-01/examples/FirewallRules_Update.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/datalake-store/armdatalakestore"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armdatalakestore.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewFirewallRulesClient().Update(ctx, "contosorg", "contosoadla", "test_rule", &armdatalakestore.FirewallRulesClientUpdateOptions{Parameters: &armdatalakestore.UpdateFirewallRuleParameters{
		Properties: &armdatalakestore.UpdateFirewallRuleProperties{
			EndIPAddress:   to.Ptr("2.2.2.2"),
			StartIPAddress: to.Ptr("1.1.1.1"),
		},
	},
	})
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res.FirewallRule = armdatalakestore.FirewallRule{
	// 	Name: to.Ptr("test_rule"),
	// 	Type: to.Ptr("test_type"),
	// 	ID: to.Ptr("34adfa4f-cedf-4dc0-ba29-b6d1a69ab345"),
	// 	Properties: &armdatalakestore.FirewallRuleProperties{
	// 		EndIPAddress: to.Ptr("2.2.2.2"),
	// 		StartIPAddress: to.Ptr("1.1.1.1"),
	// 	},
	// }
}

Output:

type FirewallRulesClientCreateOrUpdateOptions added in v0.3.0 

type FirewallRulesClientCreateOrUpdateOptions struct {
}

FirewallRulesClientCreateOrUpdateOptions contains the optional parameters for the FirewallRulesClient.CreateOrUpdate method.

type FirewallRulesClientCreateOrUpdateResponse added in v0.3.0 

type FirewallRulesClientCreateOrUpdateResponse struct {
	// Data Lake Store firewall rule information.
	FirewallRule
}

FirewallRulesClientCreateOrUpdateResponse contains the response from method FirewallRulesClient.CreateOrUpdate.

type FirewallRulesClientDeleteOptions added in v0.3.0 

type FirewallRulesClientDeleteOptions struct {
}

FirewallRulesClientDeleteOptions contains the optional parameters for the FirewallRulesClient.Delete method.

type FirewallRulesClientDeleteResponse added in v0.3.0 

type FirewallRulesClientDeleteResponse struct {
}

FirewallRulesClientDeleteResponse contains the response from method FirewallRulesClient.Delete.

type FirewallRulesClientGetOptions added in v0.3.0 

type FirewallRulesClientGetOptions struct {
}

FirewallRulesClientGetOptions contains the optional parameters for the FirewallRulesClient.Get method.

type FirewallRulesClientGetResponse added in v0.3.0 

type FirewallRulesClientGetResponse struct {
	// Data Lake Store firewall rule information.
	FirewallRule
}

FirewallRulesClientGetResponse contains the response from method FirewallRulesClient.Get.

type FirewallRulesClientListByAccountOptions added in v0.3.0 

type FirewallRulesClientListByAccountOptions struct {
}

FirewallRulesClientListByAccountOptions contains the optional parameters for the FirewallRulesClient.NewListByAccountPager method.

type FirewallRulesClientListByAccountResponse added in v0.3.0 

type FirewallRulesClientListByAccountResponse struct {
	// Data Lake Store firewall rule list information.
	FirewallRuleListResult
}

FirewallRulesClientListByAccountResponse contains the response from method FirewallRulesClient.NewListByAccountPager.

type FirewallRulesClientUpdateOptions added in v0.3.0 

type FirewallRulesClientUpdateOptions struct {
	// Parameters supplied to update the firewall rule.
	Parameters *UpdateFirewallRuleParameters
}

FirewallRulesClientUpdateOptions contains the optional parameters for the FirewallRulesClient.Update method.

type FirewallRulesClientUpdateResponse added in v0.3.0 

type FirewallRulesClientUpdateResponse struct {
	// Data Lake Store firewall rule information.
	FirewallRule
}

FirewallRulesClientUpdateResponse contains the response from method FirewallRulesClient.Update.

type FirewallState 

type FirewallState string

FirewallState - The current state of the IP address firewall for this Data Lake Store account. 

const (
	FirewallStateDisabled FirewallState = "Disabled"
	FirewallStateEnabled  FirewallState = "Enabled"
)

func PossibleFirewallStateValues 

func PossibleFirewallStateValues() []FirewallState

PossibleFirewallStateValues returns the possible values for the FirewallState const type.

type KeyVaultMetaInfo 

type KeyVaultMetaInfo struct {
	// REQUIRED; The name of the user managed encryption key.
	EncryptionKeyName *string

	// REQUIRED; The version of the user managed encryption key.
	EncryptionKeyVersion *string

	// REQUIRED; The resource identifier for the user managed Key Vault being used to encrypt.
	KeyVaultResourceID *string
}

KeyVaultMetaInfo - Metadata information used by account encryption.

func (KeyVaultMetaInfo) MarshalJSON added in v1.1.0 

func (k KeyVaultMetaInfo) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type KeyVaultMetaInfo.

func (*KeyVaultMetaInfo) UnmarshalJSON added in v1.1.0 

func (k *KeyVaultMetaInfo) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type KeyVaultMetaInfo.

type LocationsClient 

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

LocationsClient contains the methods for the Locations group. Don't use this type directly, use NewLocationsClient() instead.

func NewLocationsClient 

func NewLocationsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*LocationsClient, error)

NewLocationsClient creates a new instance of LocationsClient with the specified values.

  • subscriptionID - Gets subscription credentials which uniquely identify Microsoft Azure subscription. The subscription ID forms part of the URI for every service call.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*LocationsClient) GetCapability 

func (client *LocationsClient) GetCapability(ctx context.Context, location string, options *LocationsClientGetCapabilityOptions) (LocationsClientGetCapabilityResponse, error)

GetCapability - Gets subscription-level properties and limits for Data Lake Store specified by resource location. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2016-11-01

  • location - The resource location without whitespace.
  • options - LocationsClientGetCapabilityOptions contains the optional parameters for the LocationsClient.GetCapability method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/7a2ac91de424f271cf91cc8009f3fe9ee8249086/specification/datalake-store/resource-manager/Microsoft.DataLakeStore/stable/2016-11-01/examples/Locations_GetCapability.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/datalake-store/armdatalakestore"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armdatalakestore.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewLocationsClient().GetCapability(ctx, "EastUS2", nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res.CapabilityInformation = armdatalakestore.CapabilityInformation{
	// 	AccountCount: to.Ptr[int32](100),
	// 	MaxAccountCount: to.Ptr[int32](150),
	// 	MigrationState: to.Ptr(false),
	// 	State: to.Ptr(armdatalakestore.SubscriptionStateRegistered),
	// 	SubscriptionID: to.Ptr("34adfa4f-cedf-4dc0-ba29-b6d1a69ab345"),
	// }
}

Output:

func (*LocationsClient) NewGetUsagePager added in v0.5.0 

func (client *LocationsClient) NewGetUsagePager(location string, options *LocationsClientGetUsageOptions) *runtime.Pager[LocationsClientGetUsageResponse]

NewGetUsagePager - Gets the current usage count and the limit for the resources of the location under the subscription.

Generated from API version 2016-11-01

  • location - The resource location without whitespace.
  • options - LocationsClientGetUsageOptions contains the optional parameters for the LocationsClient.NewGetUsagePager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/7a2ac91de424f271cf91cc8009f3fe9ee8249086/specification/datalake-store/resource-manager/Microsoft.DataLakeStore/stable/2016-11-01/examples/Locations_GetUsage.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/datalake-store/armdatalakestore"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armdatalakestore.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewLocationsClient().NewGetUsagePager("WestUS", nil)
	for pager.More() {
		page, err := pager.NextPage(ctx)
		if err != nil {
			log.Fatalf("failed to advance page: %v", err)
		}
		for _, v := range page.Value {
			// You could use page here. We use blank identifier for just demo purposes.
			_ = v
		}
		// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
		// page.UsageListResult = armdatalakestore.UsageListResult{
		// 	Value: []*armdatalakestore.Usage{
		// 		{
		// 			Name: &armdatalakestore.UsageName{
		// 				LocalizedValue: to.Ptr("Data Lake Store Accounts"),
		// 				Value: to.Ptr("DataLakeStoreAccounts"),
		// 			},
		// 			CurrentValue: to.Ptr[int32](69),
		// 			ID: to.Ptr("/subscriptions/0f936178-0d48-4777-a7ab-47860b604941/providers/Microsoft.DataLakeStore/locations/WestUS/usages/DataLakeStoreAccounts"),
		// 			Limit: to.Ptr[int32](-1),
		// 			Unit: to.Ptr(armdatalakestore.UsageUnitCount),
		// 	}},
		// }
	}
}

Output:

type LocationsClientGetCapabilityOptions added in v0.3.0 

type LocationsClientGetCapabilityOptions struct {
}

LocationsClientGetCapabilityOptions contains the optional parameters for the LocationsClient.GetCapability method.

type LocationsClientGetCapabilityResponse added in v0.3.0 

type LocationsClientGetCapabilityResponse struct {
	// Subscription-level properties and limits for Data Lake Store.
	CapabilityInformation
}

LocationsClientGetCapabilityResponse contains the response from method LocationsClient.GetCapability.

type LocationsClientGetUsageOptions added in v0.3.0 

type LocationsClientGetUsageOptions struct {
}

LocationsClientGetUsageOptions contains the optional parameters for the LocationsClient.NewGetUsagePager method.

type LocationsClientGetUsageResponse added in v0.3.0 

type LocationsClientGetUsageResponse struct {
	// The response from the List Usages operation.
	UsageListResult
}

LocationsClientGetUsageResponse contains the response from method LocationsClient.NewGetUsagePager.

type NameAvailabilityInformation 

type NameAvailabilityInformation struct {
	// READ-ONLY; The message describing why the Data Lake Store account name is not available, if nameAvailable is false.
	Message *string

	// READ-ONLY; The Boolean value of true or false to indicate whether the Data Lake Store account name is available or not.
	NameAvailable *bool

	// READ-ONLY; The reason why the Data Lake Store account name is not available, if nameAvailable is false.
	Reason *string
}

NameAvailabilityInformation - Data Lake Store account name availability result information.

func (NameAvailabilityInformation) MarshalJSON added in v1.1.0 

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

MarshalJSON implements the json.Marshaller interface for type NameAvailabilityInformation.

func (*NameAvailabilityInformation) UnmarshalJSON added in v1.1.0 

func (n *NameAvailabilityInformation) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type NameAvailabilityInformation.

type Operation 

type Operation struct {
	// The display information for the operation.
	Display *OperationDisplay

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

	// READ-ONLY; The intended executor of the operation.
	Origin *OperationOrigin
}

Operation - An available operation for Data Lake Store.

func (Operation) MarshalJSON added in v1.1.0 

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

MarshalJSON implements the json.Marshaller interface for type Operation.

func (*Operation) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type Operation.

type OperationDisplay 

type OperationDisplay struct {
	// READ-ONLY; A friendly description of the operation.
	Description *string

	// READ-ONLY; A friendly name of the operation.
	Operation *string

	// READ-ONLY; The resource provider of the operation.
	Provider *string

	// READ-ONLY; The resource type of the operation.
	Resource *string
}

OperationDisplay - The display information for a particular operation.

func (OperationDisplay) MarshalJSON added in v1.1.0 

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

MarshalJSON implements the json.Marshaller interface for type OperationDisplay.

func (*OperationDisplay) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type OperationDisplay.

type OperationListResult 

type OperationListResult struct {
	// READ-ONLY; The link (url) to the next page of results.
	NextLink *string

	// READ-ONLY; The results of the list operation.
	Value []*Operation
}

OperationListResult - The list of available operations for Data Lake Store.

func (OperationListResult) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type OperationListResult.

func (*OperationListResult) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type OperationListResult.

type OperationOrigin 

type OperationOrigin string

OperationOrigin - The intended executor of the operation. 

const (
	OperationOriginSystem     OperationOrigin = "system"
	OperationOriginUser       OperationOrigin = "user"
	OperationOriginUserSystem OperationOrigin = "user,system"
)

func PossibleOperationOriginValues 

func PossibleOperationOriginValues() []OperationOrigin

PossibleOperationOriginValues returns the possible values for the OperationOrigin const type.

type OperationsClient 

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

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

func NewOperationsClient 

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

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

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

func (*OperationsClient) List 

func (client *OperationsClient) List(ctx context.Context, options *OperationsClientListOptions) (OperationsClientListResponse, error)

List - Lists all of the available Data Lake Store REST API operations. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2016-11-01

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

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/7a2ac91de424f271cf91cc8009f3fe9ee8249086/specification/datalake-store/resource-manager/Microsoft.DataLakeStore/stable/2016-11-01/examples/Operations_List.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/datalake-store/armdatalakestore"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armdatalakestore.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewOperationsClient().List(ctx, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res.OperationListResult = armdatalakestore.OperationListResult{
	// 	Value: []*armdatalakestore.Operation{
	// 		{
	// 			Name: to.Ptr("Microsoft.DataLakeStore/operations/read"),
	// 			Display: &armdatalakestore.OperationDisplay{
	// 				Description: to.Ptr("Get available operations of DataLakeStore."),
	// 				Operation: to.Ptr("Get Available Operations"),
	// 				Provider: to.Ptr("Microsoft DataLakeStore"),
	// 				Resource: to.Ptr("Available Operations"),
	// 			},
	// 	}},
	// }
}

Output:

type OperationsClientListOptions added in v0.3.0 

type OperationsClientListOptions struct {
}

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

type OperationsClientListResponse added in v0.3.0 

type OperationsClientListResponse struct {
	// The list of available operations for Data Lake Store.
	OperationListResult
}

OperationsClientListResponse contains the response from method OperationsClient.List.

type Resource 

type Resource struct {
	// READ-ONLY; The resource identifier.
	ID *string

	// READ-ONLY; The resource location.
	Location *string

	// READ-ONLY; The resource name.
	Name *string

	// READ-ONLY; The resource tags.
	Tags map[string]*string

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

Resource - The resource model definition.

func (Resource) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type Resource.

func (*Resource) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type Resource.

type SubResource 

type SubResource struct {
	// READ-ONLY; The resource identifier.
	ID *string

	// READ-ONLY; The resource name.
	Name *string

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

SubResource - The resource model definition for a nested resource.

func (SubResource) MarshalJSON added in v1.1.0 

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

MarshalJSON implements the json.Marshaller interface for type SubResource.

func (*SubResource) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SubResource.

type SubscriptionState 

type SubscriptionState string

SubscriptionState - The subscription state. 

const (
	SubscriptionStateDeleted      SubscriptionState = "Deleted"
	SubscriptionStateRegistered   SubscriptionState = "Registered"
	SubscriptionStateSuspended    SubscriptionState = "Suspended"
	SubscriptionStateUnregistered SubscriptionState = "Unregistered"
	SubscriptionStateWarned       SubscriptionState = "Warned"
)

func PossibleSubscriptionStateValues 

func PossibleSubscriptionStateValues() []SubscriptionState

PossibleSubscriptionStateValues returns the possible values for the SubscriptionState const type.

type TierType 

type TierType string

TierType - The commitment tier to use for next month. 

const (
	TierTypeCommitment100TB TierType = "Commitment_100TB"
	TierTypeCommitment10TB  TierType = "Commitment_10TB"
	TierTypeCommitment1PB   TierType = "Commitment_1PB"
	TierTypeCommitment1TB   TierType = "Commitment_1TB"
	TierTypeCommitment500TB TierType = "Commitment_500TB"
	TierTypeCommitment5PB   TierType = "Commitment_5PB"
	TierTypeConsumption     TierType = "Consumption"
)

func PossibleTierTypeValues 

func PossibleTierTypeValues() []TierType

PossibleTierTypeValues returns the possible values for the TierType const type.

type TrustedIDProvider 

type TrustedIDProvider struct {
	// READ-ONLY; The resource identifier.
	ID *string

	// READ-ONLY; The resource name.
	Name *string

	// READ-ONLY; The trusted identity provider properties.
	Properties *TrustedIDProviderProperties

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

TrustedIDProvider - Data Lake Store trusted identity provider information.

func (TrustedIDProvider) MarshalJSON added in v1.1.0 

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

MarshalJSON implements the json.Marshaller interface for type TrustedIDProvider.

func (*TrustedIDProvider) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type TrustedIDProvider.

type TrustedIDProviderListResult 

type TrustedIDProviderListResult struct {
	// READ-ONLY; The link (url) to the next page of results.
	NextLink *string

	// READ-ONLY; The results of the list operation.
	Value []*TrustedIDProvider
}

TrustedIDProviderListResult - Data Lake Store trusted identity provider list information.

func (TrustedIDProviderListResult) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type TrustedIDProviderListResult.

func (*TrustedIDProviderListResult) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type TrustedIDProviderListResult.

type TrustedIDProviderProperties 

type TrustedIDProviderProperties struct {
	// READ-ONLY; The URL of this trusted identity provider.
	IDProvider *string
}

TrustedIDProviderProperties - The trusted identity provider properties.

func (TrustedIDProviderProperties) MarshalJSON added in v1.1.0 

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

MarshalJSON implements the json.Marshaller interface for type TrustedIDProviderProperties.

func (*TrustedIDProviderProperties) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type TrustedIDProviderProperties.

type TrustedIDProviderState 

type TrustedIDProviderState string

TrustedIDProviderState - The current state of the trusted identity provider feature for this Data Lake Store account. 

const (
	TrustedIDProviderStateDisabled TrustedIDProviderState = "Disabled"
	TrustedIDProviderStateEnabled  TrustedIDProviderState = "Enabled"
)

func PossibleTrustedIDProviderStateValues 

func PossibleTrustedIDProviderStateValues() []TrustedIDProviderState

PossibleTrustedIDProviderStateValues returns the possible values for the TrustedIDProviderState const type.

type TrustedIDProvidersClient 

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

TrustedIDProvidersClient contains the methods for the TrustedIDProviders group. Don't use this type directly, use NewTrustedIDProvidersClient() instead.

func NewTrustedIDProvidersClient 

func NewTrustedIDProvidersClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*TrustedIDProvidersClient, error)

NewTrustedIDProvidersClient creates a new instance of TrustedIDProvidersClient with the specified values.

  • subscriptionID - Gets subscription credentials which uniquely identify Microsoft Azure subscription. The subscription ID forms part of the URI for every service call.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*TrustedIDProvidersClient) CreateOrUpdate 

func (client *TrustedIDProvidersClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, accountName string, trustedIDProviderName string, parameters CreateOrUpdateTrustedIDProviderParameters, options *TrustedIDProvidersClientCreateOrUpdateOptions) (TrustedIDProvidersClientCreateOrUpdateResponse, error)

CreateOrUpdate - Creates or updates the specified trusted identity provider. During update, the trusted identity provider with the specified name will be replaced with this new provider If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2016-11-01

  • resourceGroupName - The name of the Azure resource group.
  • accountName - The name of the Data Lake Store account.
  • trustedIDProviderName - The name of the trusted identity provider. This is used for differentiation of providers in the account.
  • parameters - Parameters supplied to create or replace the trusted identity provider.
  • options - TrustedIDProvidersClientCreateOrUpdateOptions contains the optional parameters for the TrustedIDProvidersClient.CreateOrUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/7a2ac91de424f271cf91cc8009f3fe9ee8249086/specification/datalake-store/resource-manager/Microsoft.DataLakeStore/stable/2016-11-01/examples/TrustedIdProviders_CreateOrUpdate.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/datalake-store/armdatalakestore"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armdatalakestore.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewTrustedIDProvidersClient().CreateOrUpdate(ctx, "contosorg", "contosoadla", "test_trusted_id_provider_name", armdatalakestore.CreateOrUpdateTrustedIDProviderParameters{
		Properties: &armdatalakestore.CreateOrUpdateTrustedIDProviderProperties{
			IDProvider: to.Ptr("https://sts.windows.net/ea9ec534-a3e3-4e45-ad36-3afc5bb291c1"),
		},
	}, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res.TrustedIDProvider = armdatalakestore.TrustedIDProvider{
	// 	Name: to.Ptr("test_trusted_id_provider_name"),
	// 	Type: to.Ptr("test_type"),
	// 	ID: to.Ptr("34adfa4f-cedf-4dc0-ba29-b6d1a69ab345"),
	// 	Properties: &armdatalakestore.TrustedIDProviderProperties{
	// 		IDProvider: to.Ptr("https://sts.windows.net/ea9ec534-a3e3-4e45-ad36-3afc5bb291c1"),
	// 	},
	// }
}

Output:

func (*TrustedIDProvidersClient) Delete 

func (client *TrustedIDProvidersClient) Delete(ctx context.Context, resourceGroupName string, accountName string, trustedIDProviderName string, options *TrustedIDProvidersClientDeleteOptions) (TrustedIDProvidersClientDeleteResponse, error)

Delete - Deletes the specified trusted identity provider from the specified Data Lake Store account If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2016-11-01

  • resourceGroupName - The name of the Azure resource group.
  • accountName - The name of the Data Lake Store account.
  • trustedIDProviderName - The name of the trusted identity provider to delete.
  • options - TrustedIDProvidersClientDeleteOptions contains the optional parameters for the TrustedIDProvidersClient.Delete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/7a2ac91de424f271cf91cc8009f3fe9ee8249086/specification/datalake-store/resource-manager/Microsoft.DataLakeStore/stable/2016-11-01/examples/TrustedIdProviders_Delete.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/datalake-store/armdatalakestore"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armdatalakestore.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	_, err = clientFactory.NewTrustedIDProvidersClient().Delete(ctx, "contosorg", "contosoadla", "test_trusted_id_provider_name", nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
}

Output:

func (*TrustedIDProvidersClient) Get 

func (client *TrustedIDProvidersClient) Get(ctx context.Context, resourceGroupName string, accountName string, trustedIDProviderName string, options *TrustedIDProvidersClientGetOptions) (TrustedIDProvidersClientGetResponse, error)

Get - Gets the specified Data Lake Store trusted identity provider. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2016-11-01

  • resourceGroupName - The name of the Azure resource group.
  • accountName - The name of the Data Lake Store account.
  • trustedIDProviderName - The name of the trusted identity provider to retrieve.
  • options - TrustedIDProvidersClientGetOptions contains the optional parameters for the TrustedIDProvidersClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/7a2ac91de424f271cf91cc8009f3fe9ee8249086/specification/datalake-store/resource-manager/Microsoft.DataLakeStore/stable/2016-11-01/examples/TrustedIdProviders_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/datalake-store/armdatalakestore"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armdatalakestore.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewTrustedIDProvidersClient().Get(ctx, "contosorg", "contosoadla", "test_trusted_id_provider_name", nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res.TrustedIDProvider = armdatalakestore.TrustedIDProvider{
	// 	Name: to.Ptr("test_trusted_id_provider_name"),
	// 	Type: to.Ptr("test_type"),
	// 	ID: to.Ptr("34adfa4f-cedf-4dc0-ba29-b6d1a69ab345"),
	// 	Properties: &armdatalakestore.TrustedIDProviderProperties{
	// 		IDProvider: to.Ptr("https://sts.windows.net/ea9ec534-a3e3-4e45-ad36-3afc5bb291c1"),
	// 	},
	// }
}

Output:

func (*TrustedIDProvidersClient) NewListByAccountPager added in v0.5.0 

func (client *TrustedIDProvidersClient) NewListByAccountPager(resourceGroupName string, accountName string, options *TrustedIDProvidersClientListByAccountOptions) *runtime.Pager[TrustedIDProvidersClientListByAccountResponse]

NewListByAccountPager - Lists the Data Lake Store trusted identity providers within the specified Data Lake Store account.

Generated from API version 2016-11-01

  • resourceGroupName - The name of the Azure resource group.
  • accountName - The name of the Data Lake Store account.
  • options - TrustedIDProvidersClientListByAccountOptions contains the optional parameters for the TrustedIDProvidersClient.NewListByAccountPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/7a2ac91de424f271cf91cc8009f3fe9ee8249086/specification/datalake-store/resource-manager/Microsoft.DataLakeStore/stable/2016-11-01/examples/TrustedIdProviders_ListByAccount.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/datalake-store/armdatalakestore"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armdatalakestore.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewTrustedIDProvidersClient().NewListByAccountPager("contosorg", "contosoadla", nil)
	for pager.More() {
		page, err := pager.NextPage(ctx)
		if err != nil {
			log.Fatalf("failed to advance page: %v", err)
		}
		for _, v := range page.Value {
			// You could use page here. We use blank identifier for just demo purposes.
			_ = v
		}
		// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
		// page.TrustedIDProviderListResult = armdatalakestore.TrustedIDProviderListResult{
		// 	Value: []*armdatalakestore.TrustedIDProvider{
		// 		{
		// 			Name: to.Ptr("test_trusted_id_provider_name"),
		// 			Type: to.Ptr("test_type"),
		// 			ID: to.Ptr("34adfa4f-cedf-4dc0-ba29-b6d1a69ab345"),
		// 			Properties: &armdatalakestore.TrustedIDProviderProperties{
		// 				IDProvider: to.Ptr("https://sts.windows.net/ea9ec534-a3e3-4e45-ad36-3afc5bb291c1"),
		// 			},
		// 	}},
		// }
	}
}

Output:

func (*TrustedIDProvidersClient) Update 

func (client *TrustedIDProvidersClient) Update(ctx context.Context, resourceGroupName string, accountName string, trustedIDProviderName string, options *TrustedIDProvidersClientUpdateOptions) (TrustedIDProvidersClientUpdateResponse, error)

Update - Updates the specified trusted identity provider. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2016-11-01

  • resourceGroupName - The name of the Azure resource group.
  • accountName - The name of the Data Lake Store account.
  • trustedIDProviderName - The name of the trusted identity provider. This is used for differentiation of providers in the account.
  • options - TrustedIDProvidersClientUpdateOptions contains the optional parameters for the TrustedIDProvidersClient.Update method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/7a2ac91de424f271cf91cc8009f3fe9ee8249086/specification/datalake-store/resource-manager/Microsoft.DataLakeStore/stable/2016-11-01/examples/TrustedIdProviders_Update.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/datalake-store/armdatalakestore"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armdatalakestore.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewTrustedIDProvidersClient().Update(ctx, "contosorg", "contosoadla", "test_trusted_id_provider_name", &armdatalakestore.TrustedIDProvidersClientUpdateOptions{Parameters: &armdatalakestore.UpdateTrustedIDProviderParameters{
		Properties: &armdatalakestore.UpdateTrustedIDProviderProperties{
			IDProvider: to.Ptr("https://sts.windows.net/ea9ec534-a3e3-4e45-ad36-3afc5bb291c1"),
		},
	},
	})
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res.TrustedIDProvider = armdatalakestore.TrustedIDProvider{
	// 	Name: to.Ptr("test_trusted_id_provider_name"),
	// 	Type: to.Ptr("test_type"),
	// 	ID: to.Ptr("34adfa4f-cedf-4dc0-ba29-b6d1a69ab345"),
	// 	Properties: &armdatalakestore.TrustedIDProviderProperties{
	// 		IDProvider: to.Ptr("https://sts.windows.net/ea9ec534-a3e3-4e45-ad36-3afc5bb291c1"),
	// 	},
	// }
}

Output:

type TrustedIDProvidersClientCreateOrUpdateOptions added in v0.3.0 

type TrustedIDProvidersClientCreateOrUpdateOptions struct {
}

TrustedIDProvidersClientCreateOrUpdateOptions contains the optional parameters for the TrustedIDProvidersClient.CreateOrUpdate method.

type TrustedIDProvidersClientCreateOrUpdateResponse added in v0.3.0 

type TrustedIDProvidersClientCreateOrUpdateResponse struct {
	// Data Lake Store trusted identity provider information.
	TrustedIDProvider
}

TrustedIDProvidersClientCreateOrUpdateResponse contains the response from method TrustedIDProvidersClient.CreateOrUpdate.

type TrustedIDProvidersClientDeleteOptions added in v0.3.0 

type TrustedIDProvidersClientDeleteOptions struct {
}

TrustedIDProvidersClientDeleteOptions contains the optional parameters for the TrustedIDProvidersClient.Delete method.

type TrustedIDProvidersClientDeleteResponse added in v0.3.0 

type TrustedIDProvidersClientDeleteResponse struct {
}

TrustedIDProvidersClientDeleteResponse contains the response from method TrustedIDProvidersClient.Delete.

type TrustedIDProvidersClientGetOptions added in v0.3.0 

type TrustedIDProvidersClientGetOptions struct {
}

TrustedIDProvidersClientGetOptions contains the optional parameters for the TrustedIDProvidersClient.Get method.

type TrustedIDProvidersClientGetResponse added in v0.3.0 

type TrustedIDProvidersClientGetResponse struct {
	// Data Lake Store trusted identity provider information.
	TrustedIDProvider
}

TrustedIDProvidersClientGetResponse contains the response from method TrustedIDProvidersClient.Get.

type TrustedIDProvidersClientListByAccountOptions added in v0.3.0 

type TrustedIDProvidersClientListByAccountOptions struct {
}

TrustedIDProvidersClientListByAccountOptions contains the optional parameters for the TrustedIDProvidersClient.NewListByAccountPager method.

type TrustedIDProvidersClientListByAccountResponse added in v0.3.0 

type TrustedIDProvidersClientListByAccountResponse struct {
	// Data Lake Store trusted identity provider list information.
	TrustedIDProviderListResult
}

TrustedIDProvidersClientListByAccountResponse contains the response from method TrustedIDProvidersClient.NewListByAccountPager.

type TrustedIDProvidersClientUpdateOptions added in v0.3.0 

type TrustedIDProvidersClientUpdateOptions struct {
	// Parameters supplied to update the trusted identity provider.
	Parameters *UpdateTrustedIDProviderParameters
}

TrustedIDProvidersClientUpdateOptions contains the optional parameters for the TrustedIDProvidersClient.Update method.

type TrustedIDProvidersClientUpdateResponse added in v0.3.0 

type TrustedIDProvidersClientUpdateResponse struct {
	// Data Lake Store trusted identity provider information.
	TrustedIDProvider
}

TrustedIDProvidersClientUpdateResponse contains the response from method TrustedIDProvidersClient.Update.

type UpdateDataLakeStoreAccountParameters 

type UpdateDataLakeStoreAccountParameters struct {
	// The Data Lake Store account properties to update.
	Properties *UpdateDataLakeStoreAccountProperties

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

UpdateDataLakeStoreAccountParameters - Data Lake Store account information to update.

func (UpdateDataLakeStoreAccountParameters) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type UpdateDataLakeStoreAccountParameters.

func (*UpdateDataLakeStoreAccountParameters) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type UpdateDataLakeStoreAccountParameters.

type UpdateDataLakeStoreAccountProperties 

type UpdateDataLakeStoreAccountProperties struct {
	// The default owner group for all new folders and files created in the Data Lake Store account.
	DefaultGroup *string

	// Used for rotation of user managed Key Vault keys. Can only be used to rotate a user managed encryption Key Vault key.
	EncryptionConfig *UpdateEncryptionConfig

	// The current state of allowing or disallowing IPs originating within Azure through the firewall. If the firewall is disabled,
	// this is not enforced.
	FirewallAllowAzureIPs *FirewallAllowAzureIPsState

	// The list of firewall rules associated with this Data Lake Store account.
	FirewallRules []*UpdateFirewallRuleWithAccountParameters

	// The current state of the IP address firewall for this Data Lake Store account. Disabling the firewall does not remove existing
	// rules, they will just be ignored until the firewall is re-enabled.
	FirewallState *FirewallState

	// The commitment tier to use for next month.
	NewTier *TierType

	// The current state of the trusted identity provider feature for this Data Lake Store account. Disabling trusted identity
	// provider functionality does not remove the providers, they will just be ignored
	// until this feature is re-enabled.
	TrustedIDProviderState *TrustedIDProviderState

	// The list of trusted identity providers associated with this Data Lake Store account.
	TrustedIDProviders []*UpdateTrustedIDProviderWithAccountParameters

	// The list of virtual network rules associated with this Data Lake Store account.
	VirtualNetworkRules []*UpdateVirtualNetworkRuleWithAccountParameters
}

UpdateDataLakeStoreAccountProperties - Data Lake Store account properties information to be updated.

func (UpdateDataLakeStoreAccountProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type UpdateDataLakeStoreAccountProperties.

func (*UpdateDataLakeStoreAccountProperties) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type UpdateDataLakeStoreAccountProperties.

type UpdateEncryptionConfig 

type UpdateEncryptionConfig struct {
	// The updated Key Vault key to use in user managed key rotation.
	KeyVaultMetaInfo *UpdateKeyVaultMetaInfo
}

UpdateEncryptionConfig - The encryption configuration used to update a user managed Key Vault key.

func (UpdateEncryptionConfig) MarshalJSON added in v1.1.0 

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

MarshalJSON implements the json.Marshaller interface for type UpdateEncryptionConfig.

func (*UpdateEncryptionConfig) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type UpdateEncryptionConfig.

type UpdateFirewallRuleParameters 

type UpdateFirewallRuleParameters struct {
	// The firewall rule properties to use when updating a firewall rule.
	Properties *UpdateFirewallRuleProperties
}

UpdateFirewallRuleParameters - The parameters used to update a firewall rule.

func (UpdateFirewallRuleParameters) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type UpdateFirewallRuleParameters.

func (*UpdateFirewallRuleParameters) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type UpdateFirewallRuleParameters.

type UpdateFirewallRuleProperties 

type UpdateFirewallRuleProperties struct {
	// The end IP address for the firewall rule. This can be either ipv4 or ipv6. Start and End should be in the same protocol.
	EndIPAddress *string

	// The start IP address for the firewall rule. This can be either ipv4 or ipv6. Start and End should be in the same protocol.
	StartIPAddress *string
}

UpdateFirewallRuleProperties - The firewall rule properties to use when updating a firewall rule.

func (UpdateFirewallRuleProperties) MarshalJSON added in v1.1.0 

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

MarshalJSON implements the json.Marshaller interface for type UpdateFirewallRuleProperties.

func (*UpdateFirewallRuleProperties) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type UpdateFirewallRuleProperties.

type UpdateFirewallRuleWithAccountParameters 

type UpdateFirewallRuleWithAccountParameters struct {
	// REQUIRED; The unique name of the firewall rule to update.
	Name *string

	// The firewall rule properties to use when updating a firewall rule.
	Properties *UpdateFirewallRuleProperties
}

UpdateFirewallRuleWithAccountParameters - The parameters used to update a firewall rule while updating a Data Lake Store account.

func (UpdateFirewallRuleWithAccountParameters) MarshalJSON added in v1.1.0 

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

MarshalJSON implements the json.Marshaller interface for type UpdateFirewallRuleWithAccountParameters.

func (*UpdateFirewallRuleWithAccountParameters) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type UpdateFirewallRuleWithAccountParameters.

type UpdateKeyVaultMetaInfo 

type UpdateKeyVaultMetaInfo struct {
	// The version of the user managed encryption key to update through a key rotation.
	EncryptionKeyVersion *string
}

UpdateKeyVaultMetaInfo - The Key Vault update information used for user managed key rotation.

func (UpdateKeyVaultMetaInfo) MarshalJSON added in v1.1.0 

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

MarshalJSON implements the json.Marshaller interface for type UpdateKeyVaultMetaInfo.

func (*UpdateKeyVaultMetaInfo) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type UpdateKeyVaultMetaInfo.

type UpdateTrustedIDProviderParameters 

type UpdateTrustedIDProviderParameters struct {
	// The trusted identity provider properties to use when updating a trusted identity provider.
	Properties *UpdateTrustedIDProviderProperties
}

UpdateTrustedIDProviderParameters - The parameters used to update a trusted identity provider.

func (UpdateTrustedIDProviderParameters) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type UpdateTrustedIDProviderParameters.

func (*UpdateTrustedIDProviderParameters) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type UpdateTrustedIDProviderParameters.

type UpdateTrustedIDProviderProperties 

type UpdateTrustedIDProviderProperties struct {
	// The URL of this trusted identity provider.
	IDProvider *string
}

UpdateTrustedIDProviderProperties - The trusted identity provider properties to use when updating a trusted identity provider.

func (UpdateTrustedIDProviderProperties) MarshalJSON added in v1.1.0 

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

MarshalJSON implements the json.Marshaller interface for type UpdateTrustedIDProviderProperties.

func (*UpdateTrustedIDProviderProperties) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type UpdateTrustedIDProviderProperties.

type UpdateTrustedIDProviderWithAccountParameters 

type UpdateTrustedIDProviderWithAccountParameters struct {
	// REQUIRED; The unique name of the trusted identity provider to update.
	Name *string

	// The trusted identity provider properties to use when updating a trusted identity provider.
	Properties *UpdateTrustedIDProviderProperties
}

UpdateTrustedIDProviderWithAccountParameters - The parameters used to update a trusted identity provider while updating a Data Lake Store account.

func (UpdateTrustedIDProviderWithAccountParameters) MarshalJSON added in v1.1.0 

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

MarshalJSON implements the json.Marshaller interface for type UpdateTrustedIDProviderWithAccountParameters.

func (*UpdateTrustedIDProviderWithAccountParameters) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type UpdateTrustedIDProviderWithAccountParameters.

type UpdateVirtualNetworkRuleParameters 

type UpdateVirtualNetworkRuleParameters struct {
	// The virtual network rule properties to use when updating a virtual network rule.
	Properties *UpdateVirtualNetworkRuleProperties
}

UpdateVirtualNetworkRuleParameters - The parameters used to update a virtual network rule.

func (UpdateVirtualNetworkRuleParameters) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type UpdateVirtualNetworkRuleParameters.

func (*UpdateVirtualNetworkRuleParameters) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type UpdateVirtualNetworkRuleParameters.

type UpdateVirtualNetworkRuleProperties 

type UpdateVirtualNetworkRuleProperties struct {
	// The resource identifier for the subnet.
	SubnetID *string
}

UpdateVirtualNetworkRuleProperties - The virtual network rule properties to use when updating a virtual network rule.

func (UpdateVirtualNetworkRuleProperties) MarshalJSON added in v1.1.0 

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

MarshalJSON implements the json.Marshaller interface for type UpdateVirtualNetworkRuleProperties.

func (*UpdateVirtualNetworkRuleProperties) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type UpdateVirtualNetworkRuleProperties.

type UpdateVirtualNetworkRuleWithAccountParameters 

type UpdateVirtualNetworkRuleWithAccountParameters struct {
	// REQUIRED; The unique name of the virtual network rule to update.
	Name *string

	// The virtual network rule properties to use when updating a virtual network rule.
	Properties *UpdateVirtualNetworkRuleProperties
}

UpdateVirtualNetworkRuleWithAccountParameters - The parameters used to update a virtual network rule while updating a Data Lake Store account.

func (UpdateVirtualNetworkRuleWithAccountParameters) MarshalJSON added in v1.1.0 

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

MarshalJSON implements the json.Marshaller interface for type UpdateVirtualNetworkRuleWithAccountParameters.

func (*UpdateVirtualNetworkRuleWithAccountParameters) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type UpdateVirtualNetworkRuleWithAccountParameters.

type Usage 

type Usage struct {
	// READ-ONLY; Gets the current count of the allocated resources in the subscription.
	CurrentValue *int32

	// READ-ONLY; Resource identifier.
	ID *string

	// READ-ONLY; Gets the maximum count of the resources that can be allocated in the subscription.
	Limit *int32

	// READ-ONLY; Gets the name of the type of usage.
	Name *UsageName

	// READ-ONLY; Gets the unit of measurement.
	Unit *UsageUnit
}

Usage - Describes the Resource Usage.

func (Usage) MarshalJSON added in v1.1.0 

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

MarshalJSON implements the json.Marshaller interface for type Usage.

func (*Usage) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type Usage.

type UsageListResult 

type UsageListResult struct {
	// Gets or sets the list of Storage Resource Usages.
	Value []*Usage
}

UsageListResult - The response from the List Usages operation.

func (UsageListResult) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type UsageListResult.

func (*UsageListResult) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type UsageListResult.

type UsageName 

type UsageName struct {
	// READ-ONLY; Gets a localized string describing the resource name.
	LocalizedValue *string

	// READ-ONLY; Gets a string describing the resource name.
	Value *string
}

UsageName - The usage names that can be used.

func (UsageName) MarshalJSON added in v1.1.0 

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

MarshalJSON implements the json.Marshaller interface for type UsageName.

func (*UsageName) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type UsageName.

type UsageUnit 

type UsageUnit string

UsageUnit - Gets the unit of measurement. 

const (
	UsageUnitBytes           UsageUnit = "Bytes"
	UsageUnitBytesPerSecond  UsageUnit = "BytesPerSecond"
	UsageUnitCount           UsageUnit = "Count"
	UsageUnitCountsPerSecond UsageUnit = "CountsPerSecond"
	UsageUnitPercent         UsageUnit = "Percent"
	UsageUnitSeconds         UsageUnit = "Seconds"
)

func PossibleUsageUnitValues 

func PossibleUsageUnitValues() []UsageUnit

PossibleUsageUnitValues returns the possible values for the UsageUnit const type.

type VirtualNetworkRule 

type VirtualNetworkRule struct {
	// READ-ONLY; The resource identifier.
	ID *string

	// READ-ONLY; The resource name.
	Name *string

	// READ-ONLY; The virtual network rule properties.
	Properties *VirtualNetworkRuleProperties

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

VirtualNetworkRule - Data Lake Store virtual network rule information.

func (VirtualNetworkRule) MarshalJSON added in v1.1.0 

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

MarshalJSON implements the json.Marshaller interface for type VirtualNetworkRule.

func (*VirtualNetworkRule) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type VirtualNetworkRule.

type VirtualNetworkRuleListResult 

type VirtualNetworkRuleListResult struct {
	// READ-ONLY; The link (url) to the next page of results.
	NextLink *string

	// READ-ONLY; The results of the list operation.
	Value []*VirtualNetworkRule
}

VirtualNetworkRuleListResult - Data Lake Store virtual network rule list information.

func (VirtualNetworkRuleListResult) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type VirtualNetworkRuleListResult.

func (*VirtualNetworkRuleListResult) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type VirtualNetworkRuleListResult.

type VirtualNetworkRuleProperties 

type VirtualNetworkRuleProperties struct {
	// READ-ONLY; The resource identifier for the subnet.
	SubnetID *string
}

VirtualNetworkRuleProperties - The virtual network rule properties.

func (VirtualNetworkRuleProperties) MarshalJSON added in v1.1.0 

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

MarshalJSON implements the json.Marshaller interface for type VirtualNetworkRuleProperties.

func (*VirtualNetworkRuleProperties) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type VirtualNetworkRuleProperties.

type VirtualNetworkRulesClient 

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

VirtualNetworkRulesClient contains the methods for the VirtualNetworkRules group. Don't use this type directly, use NewVirtualNetworkRulesClient() instead.

func NewVirtualNetworkRulesClient 

func NewVirtualNetworkRulesClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*VirtualNetworkRulesClient, error)

NewVirtualNetworkRulesClient creates a new instance of VirtualNetworkRulesClient with the specified values.

  • subscriptionID - Gets subscription credentials which uniquely identify Microsoft Azure subscription. The subscription ID forms part of the URI for every service call.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*VirtualNetworkRulesClient) CreateOrUpdate 

func (client *VirtualNetworkRulesClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, accountName string, virtualNetworkRuleName string, parameters CreateOrUpdateVirtualNetworkRuleParameters, options *VirtualNetworkRulesClientCreateOrUpdateOptions) (VirtualNetworkRulesClientCreateOrUpdateResponse, error)

CreateOrUpdate - Creates or updates the specified virtual network rule. During update, the virtual network rule with the specified name will be replaced with this new virtual network rule. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2016-11-01

  • resourceGroupName - The name of the Azure resource group.
  • accountName - The name of the Data Lake Store account.
  • virtualNetworkRuleName - The name of the virtual network rule to create or update.
  • parameters - Parameters supplied to create or update the virtual network rule.
  • options - VirtualNetworkRulesClientCreateOrUpdateOptions contains the optional parameters for the VirtualNetworkRulesClient.CreateOrUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/7a2ac91de424f271cf91cc8009f3fe9ee8249086/specification/datalake-store/resource-manager/Microsoft.DataLakeStore/stable/2016-11-01/examples/VirtualNetworkRules_CreateOrUpdate.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/datalake-store/armdatalakestore"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armdatalakestore.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewVirtualNetworkRulesClient().CreateOrUpdate(ctx, "contosorg", "contosoadla", "test_virtual_network_rules_name", armdatalakestore.CreateOrUpdateVirtualNetworkRuleParameters{
		Properties: &armdatalakestore.CreateOrUpdateVirtualNetworkRuleProperties{
			SubnetID: to.Ptr("test_subnetId"),
		},
	}, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res.VirtualNetworkRule = armdatalakestore.VirtualNetworkRule{
	// 	Name: to.Ptr("test_virtual_network_rules_name"),
	// 	Type: to.Ptr("test_type"),
	// 	ID: to.Ptr("34adfa4f-cedf-4dc0-ba29-b6d1a69ab345"),
	// 	Properties: &armdatalakestore.VirtualNetworkRuleProperties{
	// 		SubnetID: to.Ptr("test_subnetId"),
	// 	},
	// }
}

Output:

func (*VirtualNetworkRulesClient) Delete 

func (client *VirtualNetworkRulesClient) Delete(ctx context.Context, resourceGroupName string, accountName string, virtualNetworkRuleName string, options *VirtualNetworkRulesClientDeleteOptions) (VirtualNetworkRulesClientDeleteResponse, error)

Delete - Deletes the specified virtual network rule from the specified Data Lake Store account. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2016-11-01

  • resourceGroupName - The name of the Azure resource group.
  • accountName - The name of the Data Lake Store account.
  • virtualNetworkRuleName - The name of the virtual network rule to delete.
  • options - VirtualNetworkRulesClientDeleteOptions contains the optional parameters for the VirtualNetworkRulesClient.Delete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/7a2ac91de424f271cf91cc8009f3fe9ee8249086/specification/datalake-store/resource-manager/Microsoft.DataLakeStore/stable/2016-11-01/examples/VirtualNetworkRules_Delete.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/datalake-store/armdatalakestore"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armdatalakestore.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	_, err = clientFactory.NewVirtualNetworkRulesClient().Delete(ctx, "contosorg", "contosoadla", "test_virtual_network_rules_name", nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
}

Output:

func (*VirtualNetworkRulesClient) Get 

func (client *VirtualNetworkRulesClient) Get(ctx context.Context, resourceGroupName string, accountName string, virtualNetworkRuleName string, options *VirtualNetworkRulesClientGetOptions) (VirtualNetworkRulesClientGetResponse, error)

Get - Gets the specified Data Lake Store virtual network rule. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2016-11-01

  • resourceGroupName - The name of the Azure resource group.
  • accountName - The name of the Data Lake Store account.
  • virtualNetworkRuleName - The name of the virtual network rule to retrieve.
  • options - VirtualNetworkRulesClientGetOptions contains the optional parameters for the VirtualNetworkRulesClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/7a2ac91de424f271cf91cc8009f3fe9ee8249086/specification/datalake-store/resource-manager/Microsoft.DataLakeStore/stable/2016-11-01/examples/VirtualNetworkRules_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/datalake-store/armdatalakestore"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armdatalakestore.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewVirtualNetworkRulesClient().Get(ctx, "contosorg", "contosoadla", "test_virtual_network_rules_name", nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res.VirtualNetworkRule = armdatalakestore.VirtualNetworkRule{
	// 	Name: to.Ptr("test_virtual_network_rules_name"),
	// 	Type: to.Ptr("test_type"),
	// 	ID: to.Ptr("34adfa4f-cedf-4dc0-ba29-b6d1a69ab345"),
	// 	Properties: &armdatalakestore.VirtualNetworkRuleProperties{
	// 		SubnetID: to.Ptr("test_subnetId"),
	// 	},
	// }
}

Output:

func (*VirtualNetworkRulesClient) NewListByAccountPager added in v0.5.0 

func (client *VirtualNetworkRulesClient) NewListByAccountPager(resourceGroupName string, accountName string, options *VirtualNetworkRulesClientListByAccountOptions) *runtime.Pager[VirtualNetworkRulesClientListByAccountResponse]

NewListByAccountPager - Lists the Data Lake Store virtual network rules within the specified Data Lake Store account.

Generated from API version 2016-11-01

  • resourceGroupName - The name of the Azure resource group.
  • accountName - The name of the Data Lake Store account.
  • options - VirtualNetworkRulesClientListByAccountOptions contains the optional parameters for the VirtualNetworkRulesClient.NewListByAccountPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/7a2ac91de424f271cf91cc8009f3fe9ee8249086/specification/datalake-store/resource-manager/Microsoft.DataLakeStore/stable/2016-11-01/examples/VirtualNetworkRules_ListByAccount.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/datalake-store/armdatalakestore"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armdatalakestore.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewVirtualNetworkRulesClient().NewListByAccountPager("contosorg", "contosoadla", nil)
	for pager.More() {
		page, err := pager.NextPage(ctx)
		if err != nil {
			log.Fatalf("failed to advance page: %v", err)
		}
		for _, v := range page.Value {
			// You could use page here. We use blank identifier for just demo purposes.
			_ = v
		}
		// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
		// page.VirtualNetworkRuleListResult = armdatalakestore.VirtualNetworkRuleListResult{
		// 	Value: []*armdatalakestore.VirtualNetworkRule{
		// 		{
		// 			Name: to.Ptr("test_virtual_network_rules_name"),
		// 			Type: to.Ptr("test_type"),
		// 			ID: to.Ptr("34adfa4f-cedf-4dc0-ba29-b6d1a69ab345"),
		// 			Properties: &armdatalakestore.VirtualNetworkRuleProperties{
		// 				SubnetID: to.Ptr("test_subnetId"),
		// 			},
		// 	}},
		// }
	}
}

Output:

func (*VirtualNetworkRulesClient) Update 

func (client *VirtualNetworkRulesClient) Update(ctx context.Context, resourceGroupName string, accountName string, virtualNetworkRuleName string, options *VirtualNetworkRulesClientUpdateOptions) (VirtualNetworkRulesClientUpdateResponse, error)

Update - Updates the specified virtual network rule. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2016-11-01

  • resourceGroupName - The name of the Azure resource group.
  • accountName - The name of the Data Lake Store account.
  • virtualNetworkRuleName - The name of the virtual network rule to update.
  • options - VirtualNetworkRulesClientUpdateOptions contains the optional parameters for the VirtualNetworkRulesClient.Update method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/7a2ac91de424f271cf91cc8009f3fe9ee8249086/specification/datalake-store/resource-manager/Microsoft.DataLakeStore/stable/2016-11-01/examples/VirtualNetworkRules_Update.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/datalake-store/armdatalakestore"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armdatalakestore.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewVirtualNetworkRulesClient().Update(ctx, "contosorg", "contosoadla", "test_virtual_network_rules_name", &armdatalakestore.VirtualNetworkRulesClientUpdateOptions{Parameters: &armdatalakestore.UpdateVirtualNetworkRuleParameters{
		Properties: &armdatalakestore.UpdateVirtualNetworkRuleProperties{
			SubnetID: to.Ptr("test_subnetId"),
		},
	},
	})
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res.VirtualNetworkRule = armdatalakestore.VirtualNetworkRule{
	// 	Name: to.Ptr("test_virtual_network_rules_name"),
	// 	Type: to.Ptr("test_type"),
	// 	ID: to.Ptr("34adfa4f-cedf-4dc0-ba29-b6d1a69ab345"),
	// 	Properties: &armdatalakestore.VirtualNetworkRuleProperties{
	// 		SubnetID: to.Ptr("test_subnetId"),
	// 	},
	// }
}

Output:

type VirtualNetworkRulesClientCreateOrUpdateOptions added in v0.3.0 

type VirtualNetworkRulesClientCreateOrUpdateOptions struct {
}

VirtualNetworkRulesClientCreateOrUpdateOptions contains the optional parameters for the VirtualNetworkRulesClient.CreateOrUpdate method.

type VirtualNetworkRulesClientCreateOrUpdateResponse added in v0.3.0 

type VirtualNetworkRulesClientCreateOrUpdateResponse struct {
	// Data Lake Store virtual network rule information.
	VirtualNetworkRule
}

VirtualNetworkRulesClientCreateOrUpdateResponse contains the response from method VirtualNetworkRulesClient.CreateOrUpdate.

type VirtualNetworkRulesClientDeleteOptions added in v0.3.0 

type VirtualNetworkRulesClientDeleteOptions struct {
}

VirtualNetworkRulesClientDeleteOptions contains the optional parameters for the VirtualNetworkRulesClient.Delete method.

type VirtualNetworkRulesClientDeleteResponse added in v0.3.0 

type VirtualNetworkRulesClientDeleteResponse struct {
}

VirtualNetworkRulesClientDeleteResponse contains the response from method VirtualNetworkRulesClient.Delete.

type VirtualNetworkRulesClientGetOptions added in v0.3.0 

type VirtualNetworkRulesClientGetOptions struct {
}

VirtualNetworkRulesClientGetOptions contains the optional parameters for the VirtualNetworkRulesClient.Get method.

type VirtualNetworkRulesClientGetResponse added in v0.3.0 

type VirtualNetworkRulesClientGetResponse struct {
	// Data Lake Store virtual network rule information.
	VirtualNetworkRule
}

VirtualNetworkRulesClientGetResponse contains the response from method VirtualNetworkRulesClient.Get.

type VirtualNetworkRulesClientListByAccountOptions added in v0.3.0 

type VirtualNetworkRulesClientListByAccountOptions struct {
}

VirtualNetworkRulesClientListByAccountOptions contains the optional parameters for the VirtualNetworkRulesClient.NewListByAccountPager method.

type VirtualNetworkRulesClientListByAccountResponse added in v0.3.0 

type VirtualNetworkRulesClientListByAccountResponse struct {
	// Data Lake Store virtual network rule list information.
	VirtualNetworkRuleListResult
}

VirtualNetworkRulesClientListByAccountResponse contains the response from method VirtualNetworkRulesClient.NewListByAccountPager.

type VirtualNetworkRulesClientUpdateOptions added in v0.3.0 

type VirtualNetworkRulesClientUpdateOptions struct {
	// Parameters supplied to update the virtual network rule.
	Parameters *UpdateVirtualNetworkRuleParameters
}

VirtualNetworkRulesClientUpdateOptions contains the optional parameters for the VirtualNetworkRulesClient.Update method.

type VirtualNetworkRulesClientUpdateResponse added in v0.3.0 

type VirtualNetworkRulesClientUpdateResponse struct {
	// Data Lake Store virtual network rule information.
	VirtualNetworkRule
}

VirtualNetworkRulesClientUpdateResponse contains the response from method VirtualNetworkRulesClient.Update.

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

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