armdatalakeanalytics

package module
v0.8.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: 7

README

Azure Data Lake Analytics Module for Go

PkgGoDev

The armdatalakeanalytics module provides operations for working with Azure Data Lake Analytics.

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 Analytics module:

go get github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/datalake-analytics/armdatalakeanalytics

Authorization

When creating a client, you will need to provide a credential for authenticating with Azure Data Lake Analytics. 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 Analytics 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 := armdatalakeanalytics.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 := armdatalakeanalytics.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.NewDataLakeStoreAccountsClient()

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 Analytics 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 AADObjectType 

type AADObjectType string

AADObjectType - The type of AAD object the object identifier refers to. 

const (
	AADObjectTypeGroup            AADObjectType = "Group"
	AADObjectTypeServicePrincipal AADObjectType = "ServicePrincipal"
	AADObjectTypeUser             AADObjectType = "User"
)

func PossibleAADObjectTypeValues 

func PossibleAADObjectTypeValues() []AADObjectType

PossibleAADObjectTypeValues returns the possible values for the AADObjectType const type.

type Account added in v0.3.0 

type Account 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 properties defined by Data Lake Analytics all properties are specific to each resource provider.
	Properties *AccountProperties

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

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

Account - A Data Lake Analytics account object, containing all information associated with the named Data Lake Analytics account.

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 v0.7.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 properties defined by Data Lake Analytics all properties are specific to each resource provider.
	Properties *AccountPropertiesBasic

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

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

AccountBasic - A Data Lake Analytics account object, containing all information associated with the named Data Lake Analytics account.

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 v0.7.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 current number of data lake analytics accounts under this subscription.
	Count *int32

	// 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 Analytics account list information.

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 v0.7.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 {
	// 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 current state of the IP address firewall for this account.
	FirewallState *FirewallState

	// The maximum supported degree of parallelism for this account.
	MaxDegreeOfParallelism *int32

	// The maximum supported degree of parallelism per job for this account.
	MaxDegreeOfParallelismPerJob *int32

	// The maximum supported jobs running under the account at the same time.
	MaxJobCount *int32

	// The commitment tier for the next month.
	NewTier *TierType

	// The list of Data Lake Store accounts associated with this account.
	PublicDataLakeStoreAccounts []*DataLakeStoreAccountInformation

	// The number of days that job metadata is retained.
	QueryStoreRetention *int32

	// READ-ONLY; The unique identifier associated with this Data Lake Analytics account.
	AccountID *string

	// READ-ONLY; The list of compute policies associated with this account.
	ComputePolicies []*ComputePolicy

	// 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 list of Data Lake Store accounts associated with this account.
	DataLakeStoreAccounts []*DataLakeStoreAccountInformation

	// READ-ONLY; The current state of the DebugDataAccessLevel for this account.
	DebugDataAccessLevel *DebugDataAccessLevel

	// READ-ONLY; The default Data Lake Store account associated with this account.
	DefaultDataLakeStoreAccount *string

	// READ-ONLY; The type of the default Data Lake Store account associated with this account.
	DefaultDataLakeStoreAccountType *string

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

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

	// READ-ONLY; The list of hiveMetastores associated with this account.
	HiveMetastores []*HiveMetastore

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

	// READ-ONLY; The maximum supported active jobs under the account at the same time.
	MaxActiveJobCountPerUser *int32

	// READ-ONLY; The maximum supported active jobs under the account at the same time.
	MaxJobRunningTimeInMin *int32

	// READ-ONLY; The maximum supported jobs queued under the account at the same time.
	MaxQueuedJobCountPerUser *int32

	// READ-ONLY; The minimum supported priority per job for this account.
	MinPriorityPerJob *int32

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

	// READ-ONLY; The state of the Data Lake Analytics account.
	State *DataLakeAnalyticsAccountState

	// READ-ONLY; The list of Azure Blob Storage accounts associated with this account.
	StorageAccounts []*StorageAccountInformation

	// READ-ONLY; The system defined maximum supported degree of parallelism for this account, which restricts the maximum value
	// of parallelism the user can set for the account.
	SystemMaxDegreeOfParallelism *int32

	// READ-ONLY; The system defined maximum supported jobs running under the account at the same time, which restricts the maximum
	// number of running jobs the user can set for the account.
	SystemMaxJobCount *int32

	// READ-ONLY; The list of virtualNetwork rules associated with this account.
	VirtualNetworkRules []*VirtualNetworkRule
}

AccountProperties - The account specific properties that are associated with an underlying Data Lake Analytics account. Returned only when retrieving a specific account.

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 Analytics 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 Analytics account.
	ProvisioningState *DataLakeAnalyticsAccountStatus

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

AccountPropertiesBasic - The basic account specific properties that are associated with an underlying Data Lake Analytics 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 - Get 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 CreateDataLakeAnalyticsAccountParameters, options *AccountsClientBeginCreateOptions) (*runtime.Poller[AccountsClientCreateResponse], error)

BeginCreate - Creates the specified Data Lake Analytics account. This supplies the user with computation services for Data Lake Analytics workloads. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2019-11-01-preview

  • resourceGroupName - The name of the Azure resource group.
  • accountName - The name of the Data Lake Analytics account.
  • parameters - Parameters supplied to create a new Data Lake Analytics 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/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/datalake-analytics/resource-manager/Microsoft.DataLakeAnalytics/preview/2019-11-01-preview/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-analytics/armdatalakeanalytics"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armdatalakeanalytics.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewAccountsClient().BeginCreate(ctx, "contosorg", "contosoadla", armdatalakeanalytics.CreateDataLakeAnalyticsAccountParameters{
		Location: to.Ptr("eastus2"),
		Properties: &armdatalakeanalytics.CreateDataLakeAnalyticsAccountProperties{
			ComputePolicies: []*armdatalakeanalytics.CreateComputePolicyWithAccountParameters{
				{
					Name: to.Ptr("test_policy"),
					Properties: &armdatalakeanalytics.CreateOrUpdateComputePolicyProperties{
						MaxDegreeOfParallelismPerJob: to.Ptr[int32](1),
						MinPriorityPerJob:            to.Ptr[int32](1),
						ObjectID:                     to.Ptr("34adfa4f-cedf-4dc0-ba29-b6d1a69ab345"),
						ObjectType:                   to.Ptr(armdatalakeanalytics.AADObjectTypeUser),
					},
				}},
			DataLakeStoreAccounts: []*armdatalakeanalytics.AddDataLakeStoreWithAccountParameters{
				{
					Name: to.Ptr("test_adls"),
					Properties: &armdatalakeanalytics.AddDataLakeStoreProperties{
						Suffix: to.Ptr("test_suffix"),
					},
				}},
			DefaultDataLakeStoreAccount: to.Ptr("test_adls"),
			FirewallAllowAzureIPs:       to.Ptr(armdatalakeanalytics.FirewallAllowAzureIPsStateEnabled),
			FirewallRules: []*armdatalakeanalytics.CreateFirewallRuleWithAccountParameters{
				{
					Name: to.Ptr("test_rule"),
					Properties: &armdatalakeanalytics.CreateOrUpdateFirewallRuleProperties{
						EndIPAddress:   to.Ptr("2.2.2.2"),
						StartIPAddress: to.Ptr("1.1.1.1"),
					},
				}},
			FirewallState:                to.Ptr(armdatalakeanalytics.FirewallStateEnabled),
			MaxDegreeOfParallelism:       to.Ptr[int32](30),
			MaxDegreeOfParallelismPerJob: to.Ptr[int32](1),
			MaxJobCount:                  to.Ptr[int32](3),
			MinPriorityPerJob:            to.Ptr[int32](1),
			NewTier:                      to.Ptr(armdatalakeanalytics.TierTypeConsumption),
			QueryStoreRetention:          to.Ptr[int32](30),
			StorageAccounts: []*armdatalakeanalytics.AddStorageAccountWithAccountParameters{
				{
					Name: to.Ptr("test_storage"),
					Properties: &armdatalakeanalytics.AddStorageAccountProperties{
						AccessKey: to.Ptr("34adfa4f-cedf-4dc0-ba29-b6d1a69ab346"),
						Suffix:    to.Ptr("test_suffix"),
					},
				}},
		},
		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 = armdatalakeanalytics.Account{
	// 	Name: to.Ptr("test_account"),
	// 	Type: to.Ptr("Microsoft.DataLakeAnalytics/accounts"),
	// 	ID: to.Ptr("/subscriptions/34adfa4f-cedf-4dc0-ba29-b6d1a69ab345/resourceGroups/rgaba12041/providers/Microsoft.DataLakeAnalytics/accounts/testaba15818"),
	// 	Properties: &armdatalakeanalytics.AccountProperties{
	// 		AccountID: to.Ptr("34adfa4f-cedf-4dc0-ba29-b6d1a69ab345"),
	// 		CreationTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-04-14T20:21:56.681Z"); return t}()),
	// 		Endpoint: to.Ptr("test_endpoint"),
	// 		LastModifiedTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-04-14T20:21:56.681Z"); return t}()),
	// 		ProvisioningState: to.Ptr(armdatalakeanalytics.DataLakeAnalyticsAccountStatusSucceeded),
	// 		State: to.Ptr(armdatalakeanalytics.DataLakeAnalyticsAccountStateActive),
	// 		ComputePolicies: []*armdatalakeanalytics.ComputePolicy{
	// 			{
	// 				Name: to.Ptr("test_policy"),
	// 				Type: to.Ptr("test_type"),
	// 				ID: to.Ptr("test_policy_id"),
	// 				Properties: &armdatalakeanalytics.ComputePolicyProperties{
	// 					MaxDegreeOfParallelismPerJob: to.Ptr[int32](1),
	// 					MinPriorityPerJob: to.Ptr[int32](1),
	// 					ObjectID: to.Ptr("34adfa4f-cedf-4dc0-ba29-b6d1a69ab345"),
	// 					ObjectType: to.Ptr(armdatalakeanalytics.AADObjectTypeUser),
	// 				},
	// 		}},
	// 		CurrentTier: to.Ptr(armdatalakeanalytics.TierTypeConsumption),
	// 		DataLakeStoreAccounts: []*armdatalakeanalytics.DataLakeStoreAccountInformation{
	// 			{
	// 				Name: to.Ptr("test_adls"),
	// 				Type: to.Ptr("test_type"),
	// 				ID: to.Ptr("test_adls_id"),
	// 				Properties: &armdatalakeanalytics.DataLakeStoreAccountInformationProperties{
	// 					Suffix: to.Ptr("test_suffix"),
	// 				},
	// 		}},
	// 		DefaultDataLakeStoreAccount: to.Ptr("test_adls"),
	// 		FirewallAllowAzureIPs: to.Ptr(armdatalakeanalytics.FirewallAllowAzureIPsStateEnabled),
	// 		FirewallRules: []*armdatalakeanalytics.FirewallRule{
	// 			{
	// 				Name: to.Ptr("test_rule"),
	// 				Type: to.Ptr("test_type"),
	// 				ID: to.Ptr("test_firewall_id"),
	// 				Properties: &armdatalakeanalytics.FirewallRuleProperties{
	// 					EndIPAddress: to.Ptr("2.2.2.2"),
	// 					StartIPAddress: to.Ptr("1.1.1.1"),
	// 				},
	// 		}},
	// 		FirewallState: to.Ptr(armdatalakeanalytics.FirewallStateEnabled),
	// 		MaxDegreeOfParallelism: to.Ptr[int32](30),
	// 		MaxDegreeOfParallelismPerJob: to.Ptr[int32](1),
	// 		MaxJobCount: to.Ptr[int32](3),
	// 		MinPriorityPerJob: to.Ptr[int32](1),
	// 		NewTier: to.Ptr(armdatalakeanalytics.TierTypeConsumption),
	// 		QueryStoreRetention: to.Ptr[int32](30),
	// 		StorageAccounts: []*armdatalakeanalytics.StorageAccountInformation{
	// 			{
	// 				Name: to.Ptr("test_storage"),
	// 				Type: to.Ptr("test_type"),
	// 				ID: to.Ptr("test_storage_id"),
	// 				Properties: &armdatalakeanalytics.StorageAccountInformationProperties{
	// 					Suffix: to.Ptr("test_suffix"),
	// 				},
	// 		}},
	// 		SystemMaxDegreeOfParallelism: to.Ptr[int32](1),
	// 		SystemMaxJobCount: to.Ptr[int32](1),
	// 	},
	// }
}

Output:

func (*AccountsClient) BeginDelete 

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

BeginDelete - Begins the delete process for the Data Lake Analytics account object specified by the account name. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2019-11-01-preview

  • resourceGroupName - The name of the Azure resource group.
  • accountName - The name of the Data Lake Analytics 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/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/datalake-analytics/resource-manager/Microsoft.DataLakeAnalytics/preview/2019-11-01-preview/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-analytics/armdatalakeanalytics"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armdatalakeanalytics.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, options *AccountsClientBeginUpdateOptions) (*runtime.Poller[AccountsClientUpdateResponse], error)

BeginUpdate - Updates the Data Lake Analytics account object specified by the accountName with the contents of the account object. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2019-11-01-preview

  • resourceGroupName - The name of the Azure resource group.
  • accountName - The name of the Data Lake Analytics 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/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/datalake-analytics/resource-manager/Microsoft.DataLakeAnalytics/preview/2019-11-01-preview/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-analytics/armdatalakeanalytics"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armdatalakeanalytics.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewAccountsClient().BeginUpdate(ctx, "contosorg", "contosoadla", &armdatalakeanalytics.AccountsClientBeginUpdateOptions{Parameters: &armdatalakeanalytics.UpdateDataLakeAnalyticsAccountParameters{
		Properties: &armdatalakeanalytics.UpdateDataLakeAnalyticsAccountProperties{
			ComputePolicies: []*armdatalakeanalytics.UpdateComputePolicyWithAccountParameters{
				{
					Name: to.Ptr("test_policy"),
					Properties: &armdatalakeanalytics.UpdateComputePolicyProperties{
						MaxDegreeOfParallelismPerJob: to.Ptr[int32](1),
						MinPriorityPerJob:            to.Ptr[int32](1),
						ObjectID:                     to.Ptr("34adfa4f-cedf-4dc0-ba29-b6d1a69ab345"),
						ObjectType:                   to.Ptr(armdatalakeanalytics.AADObjectTypeUser),
					},
				}},
			FirewallAllowAzureIPs: to.Ptr(armdatalakeanalytics.FirewallAllowAzureIPsStateEnabled),
			FirewallRules: []*armdatalakeanalytics.UpdateFirewallRuleWithAccountParameters{
				{
					Name: to.Ptr("test_rule"),
					Properties: &armdatalakeanalytics.UpdateFirewallRuleProperties{
						EndIPAddress:   to.Ptr("2.2.2.2"),
						StartIPAddress: to.Ptr("1.1.1.1"),
					},
				}},
			FirewallState:                to.Ptr(armdatalakeanalytics.FirewallStateEnabled),
			MaxDegreeOfParallelism:       to.Ptr[int32](1),
			MaxDegreeOfParallelismPerJob: to.Ptr[int32](1),
			MaxJobCount:                  to.Ptr[int32](1),
			MinPriorityPerJob:            to.Ptr[int32](1),
			NewTier:                      to.Ptr(armdatalakeanalytics.TierTypeConsumption),
			QueryStoreRetention:          to.Ptr[int32](1),
		},
		Tags: map[string]*string{
			"test_key": to.Ptr("test_value"),
		},
	},
	})
	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 = armdatalakeanalytics.Account{
	// 	Name: to.Ptr("test_account"),
	// 	Type: to.Ptr("Microsoft.DataLakeAnalytics/accounts"),
	// 	ID: to.Ptr("/subscriptions/34adfa4f-cedf-4dc0-ba29-b6d1a69ab345/resourceGroups/rgaba12041/providers/Microsoft.DataLakeAnalytics/accounts/testaba15818"),
	// 	Properties: &armdatalakeanalytics.AccountProperties{
	// 		AccountID: to.Ptr("34adfa4f-cedf-4dc0-ba29-b6d1a69ab345"),
	// 		CreationTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-04-14T20:21:56.681Z"); return t}()),
	// 		Endpoint: to.Ptr("test_endpoint"),
	// 		LastModifiedTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-04-14T20:21:56.681Z"); return t}()),
	// 		ProvisioningState: to.Ptr(armdatalakeanalytics.DataLakeAnalyticsAccountStatusSucceeded),
	// 		State: to.Ptr(armdatalakeanalytics.DataLakeAnalyticsAccountStateActive),
	// 		ComputePolicies: []*armdatalakeanalytics.ComputePolicy{
	// 			{
	// 				Name: to.Ptr("test_policy"),
	// 				Type: to.Ptr("test_type"),
	// 				ID: to.Ptr("test_policy_id"),
	// 				Properties: &armdatalakeanalytics.ComputePolicyProperties{
	// 					MaxDegreeOfParallelismPerJob: to.Ptr[int32](1),
	// 					MinPriorityPerJob: to.Ptr[int32](1),
	// 					ObjectID: to.Ptr("34adfa4f-cedf-4dc0-ba29-b6d1a69ab345"),
	// 					ObjectType: to.Ptr(armdatalakeanalytics.AADObjectTypeUser),
	// 				},
	// 		}},
	// 		CurrentTier: to.Ptr(armdatalakeanalytics.TierTypeConsumption),
	// 		DataLakeStoreAccounts: []*armdatalakeanalytics.DataLakeStoreAccountInformation{
	// 			{
	// 				Name: to.Ptr("test_adls"),
	// 				Type: to.Ptr("test_type"),
	// 				ID: to.Ptr("test_adls_id"),
	// 				Properties: &armdatalakeanalytics.DataLakeStoreAccountInformationProperties{
	// 					Suffix: to.Ptr("test_suffix"),
	// 				},
	// 		}},
	// 		DefaultDataLakeStoreAccount: to.Ptr("test_adls"),
	// 		FirewallAllowAzureIPs: to.Ptr(armdatalakeanalytics.FirewallAllowAzureIPsStateEnabled),
	// 		FirewallRules: []*armdatalakeanalytics.FirewallRule{
	// 			{
	// 				Name: to.Ptr("test_rule"),
	// 				Type: to.Ptr("test_type"),
	// 				ID: to.Ptr("test_firewall_id"),
	// 				Properties: &armdatalakeanalytics.FirewallRuleProperties{
	// 					EndIPAddress: to.Ptr("2.2.2.2"),
	// 					StartIPAddress: to.Ptr("1.1.1.1"),
	// 				},
	// 		}},
	// 		FirewallState: to.Ptr(armdatalakeanalytics.FirewallStateEnabled),
	// 		MaxDegreeOfParallelism: to.Ptr[int32](30),
	// 		MaxDegreeOfParallelismPerJob: to.Ptr[int32](1),
	// 		MaxJobCount: to.Ptr[int32](3),
	// 		MinPriorityPerJob: to.Ptr[int32](1),
	// 		NewTier: to.Ptr(armdatalakeanalytics.TierTypeConsumption),
	// 		QueryStoreRetention: to.Ptr[int32](30),
	// 		StorageAccounts: []*armdatalakeanalytics.StorageAccountInformation{
	// 			{
	// 				Name: to.Ptr("test_storage"),
	// 				Type: to.Ptr("test_type"),
	// 				ID: to.Ptr("test_storage_id"),
	// 				Properties: &armdatalakeanalytics.StorageAccountInformationProperties{
	// 					Suffix: to.Ptr("test_suffix"),
	// 				},
	// 		}},
	// 		SystemMaxDegreeOfParallelism: to.Ptr[int32](1),
	// 		SystemMaxJobCount: to.Ptr[int32](1),
	// 	},
	// }
}

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 2019-11-01-preview

  • location - The resource location without whitespace.
  • parameters - Parameters supplied to check the Data Lake Analytics 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/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/datalake-analytics/resource-manager/Microsoft.DataLakeAnalytics/preview/2019-11-01-preview/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-analytics/armdatalakeanalytics"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armdatalakeanalytics.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewAccountsClient().CheckNameAvailability(ctx, "EastUS2", armdatalakeanalytics.CheckNameAvailabilityParameters{
		Name: to.Ptr("contosoadla"),
		Type: to.Ptr(armdatalakeanalytics.CheckNameAvailabilityParametersTypeMicrosoftDataLakeAnalyticsAccounts),
	}, 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 = armdatalakeanalytics.NameAvailabilityInformation{
	// 	Message: to.Ptr("An account named 'abc' already exists."),
	// 	NameAvailable: to.Ptr(false),
	// 	Reason: to.Ptr("AlreadyExists"),
	// }
}

Output:

func (*AccountsClient) Get 

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

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

Generated from API version 2019-11-01-preview

  • resourceGroupName - The name of the Azure resource group.
  • accountName - The name of the Data Lake Analytics 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/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/datalake-analytics/resource-manager/Microsoft.DataLakeAnalytics/preview/2019-11-01-preview/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-analytics/armdatalakeanalytics"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armdatalakeanalytics.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 = armdatalakeanalytics.Account{
	// 	Name: to.Ptr("test_account"),
	// 	Type: to.Ptr("Microsoft.DataLakeAnalytics/accounts"),
	// 	ID: to.Ptr("/subscriptions/34adfa4f-cedf-4dc0-ba29-b6d1a69ab345/resourceGroups/rgaba12041/providers/Microsoft.DataLakeAnalytics/accounts/testaba15818"),
	// 	Properties: &armdatalakeanalytics.AccountProperties{
	// 		AccountID: to.Ptr("34adfa4f-cedf-4dc0-ba29-b6d1a69ab345"),
	// 		CreationTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-04-14T20:21:56.681Z"); return t}()),
	// 		Endpoint: to.Ptr("test_endpoint"),
	// 		LastModifiedTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-04-14T20:21:56.681Z"); return t}()),
	// 		ProvisioningState: to.Ptr(armdatalakeanalytics.DataLakeAnalyticsAccountStatusSucceeded),
	// 		State: to.Ptr(armdatalakeanalytics.DataLakeAnalyticsAccountStateActive),
	// 		ComputePolicies: []*armdatalakeanalytics.ComputePolicy{
	// 			{
	// 				Name: to.Ptr("test_policy"),
	// 				Type: to.Ptr("test_type"),
	// 				ID: to.Ptr("test_policy_id"),
	// 				Properties: &armdatalakeanalytics.ComputePolicyProperties{
	// 					MaxDegreeOfParallelismPerJob: to.Ptr[int32](1),
	// 					MinPriorityPerJob: to.Ptr[int32](1),
	// 					ObjectID: to.Ptr("34adfa4f-cedf-4dc0-ba29-b6d1a69ab345"),
	// 					ObjectType: to.Ptr(armdatalakeanalytics.AADObjectTypeUser),
	// 				},
	// 		}},
	// 		CurrentTier: to.Ptr(armdatalakeanalytics.TierTypeConsumption),
	// 		DataLakeStoreAccounts: []*armdatalakeanalytics.DataLakeStoreAccountInformation{
	// 			{
	// 				Name: to.Ptr("test_adls"),
	// 				Type: to.Ptr("test_type"),
	// 				ID: to.Ptr("test_adls_id"),
	// 				Properties: &armdatalakeanalytics.DataLakeStoreAccountInformationProperties{
	// 					Suffix: to.Ptr("test_suffix"),
	// 				},
	// 		}},
	// 		DefaultDataLakeStoreAccount: to.Ptr("test_adls"),
	// 		FirewallAllowAzureIPs: to.Ptr(armdatalakeanalytics.FirewallAllowAzureIPsStateEnabled),
	// 		FirewallRules: []*armdatalakeanalytics.FirewallRule{
	// 			{
	// 				Name: to.Ptr("test_rule"),
	// 				Type: to.Ptr("test_type"),
	// 				ID: to.Ptr("test_firewall_id"),
	// 				Properties: &armdatalakeanalytics.FirewallRuleProperties{
	// 					EndIPAddress: to.Ptr("2.2.2.2"),
	// 					StartIPAddress: to.Ptr("1.1.1.1"),
	// 				},
	// 		}},
	// 		FirewallState: to.Ptr(armdatalakeanalytics.FirewallStateEnabled),
	// 		MaxDegreeOfParallelism: to.Ptr[int32](30),
	// 		MaxDegreeOfParallelismPerJob: to.Ptr[int32](1),
	// 		MaxJobCount: to.Ptr[int32](3),
	// 		MinPriorityPerJob: to.Ptr[int32](1),
	// 		NewTier: to.Ptr(armdatalakeanalytics.TierTypeConsumption),
	// 		PublicDataLakeStoreAccounts: []*armdatalakeanalytics.DataLakeStoreAccountInformation{
	// 			{
	// 				Name: to.Ptr("test_adls"),
	// 				Type: to.Ptr("test_type"),
	// 				ID: to.Ptr("test_adls_id"),
	// 				Properties: &armdatalakeanalytics.DataLakeStoreAccountInformationProperties{
	// 					Suffix: to.Ptr("test_suffix"),
	// 				},
	// 		}},
	// 		QueryStoreRetention: to.Ptr[int32](30),
	// 		StorageAccounts: []*armdatalakeanalytics.StorageAccountInformation{
	// 			{
	// 				Name: to.Ptr("test_storage"),
	// 				Type: to.Ptr("test_type"),
	// 				ID: to.Ptr("test_storage_id"),
	// 				Properties: &armdatalakeanalytics.StorageAccountInformationProperties{
	// 					Suffix: to.Ptr("test_suffix"),
	// 				},
	// 		}},
	// 		SystemMaxDegreeOfParallelism: to.Ptr[int32](1),
	// 		SystemMaxJobCount: to.Ptr[int32](1),
	// 	},
	// }
}

Output:

func (*AccountsClient) NewListByResourceGroupPager added in v0.5.0 

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

NewListByResourceGroupPager - Gets the first page of Data Lake Analytics accounts, if any, within a specific resource group. This includes a link to the next page, if any.

Generated from API version 2019-11-01-preview

  • 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/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/datalake-analytics/resource-manager/Microsoft.DataLakeAnalytics/preview/2019-11-01-preview/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-analytics/armdatalakeanalytics"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armdatalakeanalytics.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewAccountsClient().NewListByResourceGroupPager("contosorg", &armdatalakeanalytics.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 = armdatalakeanalytics.AccountListResult{
		// 	Value: []*armdatalakeanalytics.AccountBasic{
		// 		{
		// 			Name: to.Ptr("test_account"),
		// 			Type: to.Ptr("test_type"),
		// 			ID: to.Ptr("34adfa4f-cedf-4dc0-ba29-b6d1a69ab345"),
		// 			Properties: &armdatalakeanalytics.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("test_endpoint"),
		// 				LastModifiedTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-04-14T20:21:56.681Z"); return t}()),
		// 				ProvisioningState: to.Ptr(armdatalakeanalytics.DataLakeAnalyticsAccountStatusSucceeded),
		// 				State: to.Ptr(armdatalakeanalytics.DataLakeAnalyticsAccountStateActive),
		// 			},
		// 	}},
		// }
	}
}

Output:

func (*AccountsClient) NewListPager added in v0.5.0 

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

NewListPager - Gets the first page of Data Lake Analytics accounts, if any, within the current subscription. This includes a link to the next page, if any.

Generated from API version 2019-11-01-preview

  • 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/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/datalake-analytics/resource-manager/Microsoft.DataLakeAnalytics/preview/2019-11-01-preview/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-analytics/armdatalakeanalytics"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armdatalakeanalytics.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewAccountsClient().NewListPager(&armdatalakeanalytics.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 = armdatalakeanalytics.AccountListResult{
		// 	Value: []*armdatalakeanalytics.AccountBasic{
		// 		{
		// 			Name: to.Ptr("test_account"),
		// 			Type: to.Ptr("test_type"),
		// 			ID: to.Ptr("34adfa4f-cedf-4dc0-ba29-b6d1a69ab345"),
		// 			Properties: &armdatalakeanalytics.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("test_endpoint"),
		// 				LastModifiedTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-04-14T20:21:56.681Z"); return t}()),
		// 				ProvisioningState: to.Ptr(armdatalakeanalytics.DataLakeAnalyticsAccountStatusSucceeded),
		// 				State: to.Ptr(armdatalakeanalytics.DataLakeAnalyticsAccountStateActive),
		// 			},
		// 	}},
		// }
	}
}

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 {
	// Parameters supplied to the update Data Lake Analytics account operation.
	Parameters *UpdateDataLakeAnalyticsAccountParameters

	// 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 Analytics account name availability result information.
	NameAvailabilityInformation
}

AccountsClientCheckNameAvailabilityResponse contains the response from method AccountsClient.CheckNameAvailability.

type AccountsClientCreateResponse added in v0.3.0 

type AccountsClientCreateResponse struct {
	// A Data Lake Analytics account object, containing all information associated with the named Data Lake Analytics account.
	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 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 {
	// A Data Lake Analytics account object, containing all information associated with the named Data Lake Analytics account.
	Account
}

AccountsClientGetResponse contains the response from method AccountsClient.Get.

type AccountsClientListByResourceGroupOptions added in v0.3.0 

type AccountsClientListByResourceGroupOptions 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
}

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

type AccountsClientListByResourceGroupResponse added in v0.3.0 

type AccountsClientListByResourceGroupResponse struct {
	// Data Lake Analytics account list information.
	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 Analytics account list information.
	AccountListResult
}

AccountsClientListResponse contains the response from method AccountsClient.NewListPager.

type AccountsClientUpdateResponse added in v0.3.0 

type AccountsClientUpdateResponse struct {
	// A Data Lake Analytics account object, containing all information associated with the named Data Lake Analytics account.
	Account
}

AccountsClientUpdateResponse contains the response from method AccountsClient.BeginUpdate.

type AddDataLakeStoreParameters 

type AddDataLakeStoreParameters struct {
	// The Data Lake Store account properties to use when adding a new Data Lake Store account.
	Properties *AddDataLakeStoreProperties
}

AddDataLakeStoreParameters - The parameters used to add a new Data Lake Store account.

func (AddDataLakeStoreParameters) MarshalJSON added in v0.7.0 

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

MarshalJSON implements the json.Marshaller interface for type AddDataLakeStoreParameters.

func (*AddDataLakeStoreParameters) UnmarshalJSON added in v0.7.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AddDataLakeStoreParameters.

type AddDataLakeStoreProperties 

type AddDataLakeStoreProperties struct {
	// The optional suffix for the Data Lake Store account.
	Suffix *string
}

AddDataLakeStoreProperties - The Data Lake Store account properties to use when adding a new Data Lake Store account.

func (AddDataLakeStoreProperties) MarshalJSON added in v0.7.0 

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

MarshalJSON implements the json.Marshaller interface for type AddDataLakeStoreProperties.

func (*AddDataLakeStoreProperties) UnmarshalJSON added in v0.7.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AddDataLakeStoreProperties.

type AddDataLakeStoreWithAccountParameters 

type AddDataLakeStoreWithAccountParameters struct {
	// REQUIRED; The unique name of the Data Lake Store account to add.
	Name *string

	// The Data Lake Store account properties to use when adding a new Data Lake Store account.
	Properties *AddDataLakeStoreProperties
}

AddDataLakeStoreWithAccountParameters - The parameters used to add a new Data Lake Store account while creating a new Data Lake Analytics account.

func (AddDataLakeStoreWithAccountParameters) MarshalJSON added in v0.7.0 

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

MarshalJSON implements the json.Marshaller interface for type AddDataLakeStoreWithAccountParameters.

func (*AddDataLakeStoreWithAccountParameters) UnmarshalJSON added in v0.7.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AddDataLakeStoreWithAccountParameters.

type AddStorageAccountParameters 

type AddStorageAccountParameters struct {
	// REQUIRED; The Azure Storage account properties to use when adding a new Azure Storage account.
	Properties *AddStorageAccountProperties
}

AddStorageAccountParameters - The parameters used to add a new Azure Storage account.

func (AddStorageAccountParameters) MarshalJSON added in v0.7.0 

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

MarshalJSON implements the json.Marshaller interface for type AddStorageAccountParameters.

func (*AddStorageAccountParameters) UnmarshalJSON added in v0.7.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AddStorageAccountParameters.

type AddStorageAccountProperties 

type AddStorageAccountProperties struct {
	// REQUIRED; The access key associated with this Azure Storage account that will be used to connect to it.
	AccessKey *string

	// The optional suffix for the storage account.
	Suffix *string
}

AddStorageAccountProperties - The Azure Storage account properties to use when adding a new Azure Storage account.

func (AddStorageAccountProperties) MarshalJSON added in v0.7.0 

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

MarshalJSON implements the json.Marshaller interface for type AddStorageAccountProperties.

func (*AddStorageAccountProperties) UnmarshalJSON added in v0.7.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AddStorageAccountProperties.

type AddStorageAccountWithAccountParameters 

type AddStorageAccountWithAccountParameters struct {
	// REQUIRED; The unique name of the Azure Storage account to add.
	Name *string

	// REQUIRED; The Azure Storage account properties to use when adding a new Azure Storage account.
	Properties *AddStorageAccountProperties
}

AddStorageAccountWithAccountParameters - The parameters used to add a new Azure Storage account while creating a new Data Lake Analytics account.

func (AddStorageAccountWithAccountParameters) MarshalJSON added in v0.7.0 

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

MarshalJSON implements the json.Marshaller interface for type AddStorageAccountWithAccountParameters.

func (*AddStorageAccountWithAccountParameters) UnmarshalJSON added in v0.7.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AddStorageAccountWithAccountParameters.

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 Analytics.

func (CapabilityInformation) MarshalJSON added in v0.7.0 

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

MarshalJSON implements the json.Marshaller interface for type CapabilityInformation.

func (*CapabilityInformation) UnmarshalJSON added in v0.7.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 Analytics 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.DataLakeAnalytics/accounts
	Type *CheckNameAvailabilityParametersType
}

CheckNameAvailabilityParameters - Data Lake Analytics account name availability check parameters.

func (CheckNameAvailabilityParameters) MarshalJSON added in v0.7.0 

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

MarshalJSON implements the json.Marshaller interface for type CheckNameAvailabilityParameters.

func (*CheckNameAvailabilityParameters) UnmarshalJSON added in v0.7.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.DataLakeAnalytics/accounts 

const (
	CheckNameAvailabilityParametersTypeMicrosoftDataLakeAnalyticsAccounts CheckNameAvailabilityParametersType = "Microsoft.DataLakeAnalytics/accounts"
)

func PossibleCheckNameAvailabilityParametersTypeValues 

func PossibleCheckNameAvailabilityParametersTypeValues() []CheckNameAvailabilityParametersType

PossibleCheckNameAvailabilityParametersTypeValues returns the possible values for the CheckNameAvailabilityParametersType const type.

type ClientFactory added in v0.7.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 v0.7.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 - Get 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 v0.7.0 

func (c *ClientFactory) NewAccountsClient() *AccountsClient

NewAccountsClient creates a new instance of AccountsClient.

func (*ClientFactory) NewComputePoliciesClient added in v0.7.0 

func (c *ClientFactory) NewComputePoliciesClient() *ComputePoliciesClient

NewComputePoliciesClient creates a new instance of ComputePoliciesClient.

func (*ClientFactory) NewDataLakeStoreAccountsClient added in v0.7.0 

func (c *ClientFactory) NewDataLakeStoreAccountsClient() *DataLakeStoreAccountsClient

NewDataLakeStoreAccountsClient creates a new instance of DataLakeStoreAccountsClient.

func (*ClientFactory) NewFirewallRulesClient added in v0.7.0 

func (c *ClientFactory) NewFirewallRulesClient() *FirewallRulesClient

NewFirewallRulesClient creates a new instance of FirewallRulesClient.

func (*ClientFactory) NewLocationsClient added in v0.7.0 

func (c *ClientFactory) NewLocationsClient() *LocationsClient

NewLocationsClient creates a new instance of LocationsClient.

func (*ClientFactory) NewOperationsClient added in v0.7.0 

func (c *ClientFactory) NewOperationsClient() *OperationsClient

NewOperationsClient creates a new instance of OperationsClient.

func (*ClientFactory) NewStorageAccountsClient added in v0.7.0 

func (c *ClientFactory) NewStorageAccountsClient() *StorageAccountsClient

NewStorageAccountsClient creates a new instance of StorageAccountsClient.

type ComputePoliciesClient 

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

ComputePoliciesClient contains the methods for the ComputePolicies group. Don't use this type directly, use NewComputePoliciesClient() instead.

func NewComputePoliciesClient 

func NewComputePoliciesClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*ComputePoliciesClient, error)

NewComputePoliciesClient creates a new instance of ComputePoliciesClient with the specified values.

  • subscriptionID - Get 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 (*ComputePoliciesClient) CreateOrUpdate 

func (client *ComputePoliciesClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, accountName string, computePolicyName string, parameters CreateOrUpdateComputePolicyParameters, options *ComputePoliciesClientCreateOrUpdateOptions) (ComputePoliciesClientCreateOrUpdateResponse, error)

CreateOrUpdate - Creates or updates the specified compute policy. During update, the compute policy with the specified name will be replaced with this new compute policy. An account supports, at most, 50 policies If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2019-11-01-preview

  • resourceGroupName - The name of the Azure resource group.
  • accountName - The name of the Data Lake Analytics account.
  • computePolicyName - The name of the compute policy to create or update.
  • parameters - Parameters supplied to create or update the compute policy. The max degree of parallelism per job property, min priority per job property, or both must be present.
  • options - ComputePoliciesClientCreateOrUpdateOptions contains the optional parameters for the ComputePoliciesClient.CreateOrUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/datalake-analytics/resource-manager/Microsoft.DataLakeAnalytics/preview/2019-11-01-preview/examples/ComputePolicies_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-analytics/armdatalakeanalytics"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armdatalakeanalytics.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewComputePoliciesClient().CreateOrUpdate(ctx, "contosorg", "contosoadla", "test_policy", armdatalakeanalytics.CreateOrUpdateComputePolicyParameters{
		Properties: &armdatalakeanalytics.CreateOrUpdateComputePolicyProperties{
			MaxDegreeOfParallelismPerJob: to.Ptr[int32](10),
			MinPriorityPerJob:            to.Ptr[int32](30),
			ObjectID:                     to.Ptr("776b9091-8916-4638-87f7-9c989a38da98"),
			ObjectType:                   to.Ptr(armdatalakeanalytics.AADObjectTypeUser),
		},
	}, 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.ComputePolicy = armdatalakeanalytics.ComputePolicy{
	// 	Name: to.Ptr("test_policy"),
	// 	Properties: &armdatalakeanalytics.ComputePolicyProperties{
	// 		MaxDegreeOfParallelismPerJob: to.Ptr[int32](10),
	// 		MinPriorityPerJob: to.Ptr[int32](30),
	// 		ObjectID: to.Ptr("776b9091-8916-4638-87f7-9c989a38da98"),
	// 		ObjectType: to.Ptr(armdatalakeanalytics.AADObjectTypeUser),
	// 	},
	// }
}

Output:

func (*ComputePoliciesClient) Delete 

func (client *ComputePoliciesClient) Delete(ctx context.Context, resourceGroupName string, accountName string, computePolicyName string, options *ComputePoliciesClientDeleteOptions) (ComputePoliciesClientDeleteResponse, error)

Delete - Deletes the specified compute policy from the specified Data Lake Analytics account If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2019-11-01-preview

  • resourceGroupName - The name of the Azure resource group.
  • accountName - The name of the Data Lake Analytics account.
  • computePolicyName - The name of the compute policy to delete.
  • options - ComputePoliciesClientDeleteOptions contains the optional parameters for the ComputePoliciesClient.Delete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/datalake-analytics/resource-manager/Microsoft.DataLakeAnalytics/preview/2019-11-01-preview/examples/ComputePolicies_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-analytics/armdatalakeanalytics"
)

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

Output:

func (*ComputePoliciesClient) Get 

func (client *ComputePoliciesClient) Get(ctx context.Context, resourceGroupName string, accountName string, computePolicyName string, options *ComputePoliciesClientGetOptions) (ComputePoliciesClientGetResponse, error)

Get - Gets the specified Data Lake Analytics compute policy. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2019-11-01-preview

  • resourceGroupName - The name of the Azure resource group.
  • accountName - The name of the Data Lake Analytics account.
  • computePolicyName - The name of the compute policy to retrieve.
  • options - ComputePoliciesClientGetOptions contains the optional parameters for the ComputePoliciesClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/datalake-analytics/resource-manager/Microsoft.DataLakeAnalytics/preview/2019-11-01-preview/examples/ComputePolicies_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-analytics/armdatalakeanalytics"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armdatalakeanalytics.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewComputePoliciesClient().Get(ctx, "contosorg", "contosoadla", "test_policy", 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.ComputePolicy = armdatalakeanalytics.ComputePolicy{
	// 	Name: to.Ptr("test_policy"),
	// 	Properties: &armdatalakeanalytics.ComputePolicyProperties{
	// 		MaxDegreeOfParallelismPerJob: to.Ptr[int32](10),
	// 		MinPriorityPerJob: to.Ptr[int32](30),
	// 		ObjectID: to.Ptr("776b9091-8916-4638-87f7-9c989a38da98"),
	// 		ObjectType: to.Ptr(armdatalakeanalytics.AADObjectTypeUser),
	// 	},
	// }
}

Output:

func (*ComputePoliciesClient) NewListByAccountPager added in v0.5.0 

func (client *ComputePoliciesClient) NewListByAccountPager(resourceGroupName string, accountName string, options *ComputePoliciesClientListByAccountOptions) *runtime.Pager[ComputePoliciesClientListByAccountResponse]

NewListByAccountPager - Lists the Data Lake Analytics compute policies within the specified Data Lake Analytics account. An account supports, at most, 50 policies

Generated from API version 2019-11-01-preview

  • resourceGroupName - The name of the Azure resource group.
  • accountName - The name of the Data Lake Analytics account.
  • options - ComputePoliciesClientListByAccountOptions contains the optional parameters for the ComputePoliciesClient.NewListByAccountPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/datalake-analytics/resource-manager/Microsoft.DataLakeAnalytics/preview/2019-11-01-preview/examples/ComputePolicies_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-analytics/armdatalakeanalytics"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armdatalakeanalytics.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewComputePoliciesClient().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.ComputePolicyListResult = armdatalakeanalytics.ComputePolicyListResult{
		// 	Value: []*armdatalakeanalytics.ComputePolicy{
		// 		{
		// 			Name: to.Ptr("test_policy"),
		// 			Properties: &armdatalakeanalytics.ComputePolicyProperties{
		// 				MaxDegreeOfParallelismPerJob: to.Ptr[int32](10),
		// 				MinPriorityPerJob: to.Ptr[int32](30),
		// 				ObjectID: to.Ptr("776b9091-8916-4638-87f7-9c989a38da98"),
		// 				ObjectType: to.Ptr(armdatalakeanalytics.AADObjectTypeUser),
		// 			},
		// 		},
		// 		{
		// 			Name: to.Ptr("test_policy1"),
		// 			Properties: &armdatalakeanalytics.ComputePolicyProperties{
		// 				MaxDegreeOfParallelismPerJob: to.Ptr[int32](5),
		// 				MinPriorityPerJob: to.Ptr[int32](15),
		// 				ObjectID: to.Ptr("776b9091-8916-4638-87f7-9c989a38da99"),
		// 				ObjectType: to.Ptr(armdatalakeanalytics.AADObjectTypeGroup),
		// 			},
		// 		},
		// 		{
		// 			Name: to.Ptr("test_policy2"),
		// 			Properties: &armdatalakeanalytics.ComputePolicyProperties{
		// 				MaxDegreeOfParallelismPerJob: to.Ptr[int32](20),
		// 				MinPriorityPerJob: to.Ptr[int32](60),
		// 				ObjectID: to.Ptr("776b9091-8916-4638-87f7-9c989a38da97"),
		// 				ObjectType: to.Ptr(armdatalakeanalytics.AADObjectTypeServicePrincipal),
		// 			},
		// 	}},
		// }
	}
}

Output:

func (*ComputePoliciesClient) Update 

func (client *ComputePoliciesClient) Update(ctx context.Context, resourceGroupName string, accountName string, computePolicyName string, options *ComputePoliciesClientUpdateOptions) (ComputePoliciesClientUpdateResponse, error)

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

Generated from API version 2019-11-01-preview

  • resourceGroupName - The name of the Azure resource group.
  • accountName - The name of the Data Lake Analytics account.
  • computePolicyName - The name of the compute policy to update.
  • options - ComputePoliciesClientUpdateOptions contains the optional parameters for the ComputePoliciesClient.Update method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/datalake-analytics/resource-manager/Microsoft.DataLakeAnalytics/preview/2019-11-01-preview/examples/ComputePolicies_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-analytics/armdatalakeanalytics"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armdatalakeanalytics.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewComputePoliciesClient().Update(ctx, "contosorg", "contosoadla", "test_policy", &armdatalakeanalytics.ComputePoliciesClientUpdateOptions{Parameters: &armdatalakeanalytics.UpdateComputePolicyParameters{
		Properties: &armdatalakeanalytics.UpdateComputePolicyProperties{
			MaxDegreeOfParallelismPerJob: to.Ptr[int32](11),
			MinPriorityPerJob:            to.Ptr[int32](31),
		},
	},
	})
	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.ComputePolicy = armdatalakeanalytics.ComputePolicy{
	// 	Name: to.Ptr("test_policy"),
	// 	Properties: &armdatalakeanalytics.ComputePolicyProperties{
	// 		MaxDegreeOfParallelismPerJob: to.Ptr[int32](11),
	// 		MinPriorityPerJob: to.Ptr[int32](31),
	// 		ObjectID: to.Ptr("776b9091-8916-4638-87f7-9c989a38da98"),
	// 		ObjectType: to.Ptr(armdatalakeanalytics.AADObjectTypeUser),
	// 	},
	// }
}

Output:

type ComputePoliciesClientCreateOrUpdateOptions added in v0.3.0 

type ComputePoliciesClientCreateOrUpdateOptions struct {
}

ComputePoliciesClientCreateOrUpdateOptions contains the optional parameters for the ComputePoliciesClient.CreateOrUpdate method.

type ComputePoliciesClientCreateOrUpdateResponse added in v0.3.0 

type ComputePoliciesClientCreateOrUpdateResponse struct {
	// Data Lake Analytics compute policy information.
	ComputePolicy
}

ComputePoliciesClientCreateOrUpdateResponse contains the response from method ComputePoliciesClient.CreateOrUpdate.

type ComputePoliciesClientDeleteOptions added in v0.3.0 

type ComputePoliciesClientDeleteOptions struct {
}

ComputePoliciesClientDeleteOptions contains the optional parameters for the ComputePoliciesClient.Delete method.

type ComputePoliciesClientDeleteResponse added in v0.3.0 

type ComputePoliciesClientDeleteResponse struct {
}

ComputePoliciesClientDeleteResponse contains the response from method ComputePoliciesClient.Delete.

type ComputePoliciesClientGetOptions added in v0.3.0 

type ComputePoliciesClientGetOptions struct {
}

ComputePoliciesClientGetOptions contains the optional parameters for the ComputePoliciesClient.Get method.

type ComputePoliciesClientGetResponse added in v0.3.0 

type ComputePoliciesClientGetResponse struct {
	// Data Lake Analytics compute policy information.
	ComputePolicy
}

ComputePoliciesClientGetResponse contains the response from method ComputePoliciesClient.Get.

type ComputePoliciesClientListByAccountOptions added in v0.3.0 

type ComputePoliciesClientListByAccountOptions struct {
}

ComputePoliciesClientListByAccountOptions contains the optional parameters for the ComputePoliciesClient.NewListByAccountPager method.

type ComputePoliciesClientListByAccountResponse added in v0.3.0 

type ComputePoliciesClientListByAccountResponse struct {
	// The list of compute policies in the account.
	ComputePolicyListResult
}

ComputePoliciesClientListByAccountResponse contains the response from method ComputePoliciesClient.NewListByAccountPager.

type ComputePoliciesClientUpdateOptions added in v0.3.0 

type ComputePoliciesClientUpdateOptions struct {
	// Parameters supplied to update the compute policy.
	Parameters *UpdateComputePolicyParameters
}

ComputePoliciesClientUpdateOptions contains the optional parameters for the ComputePoliciesClient.Update method.

type ComputePoliciesClientUpdateResponse added in v0.3.0 

type ComputePoliciesClientUpdateResponse struct {
	// Data Lake Analytics compute policy information.
	ComputePolicy
}

ComputePoliciesClientUpdateResponse contains the response from method ComputePoliciesClient.Update.

type ComputePolicy 

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

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

	// READ-ONLY; The compute policy properties.
	Properties *ComputePolicyProperties

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

ComputePolicy - Data Lake Analytics compute policy information.

func (ComputePolicy) MarshalJSON added in v0.7.0 

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

MarshalJSON implements the json.Marshaller interface for type ComputePolicy.

func (*ComputePolicy) UnmarshalJSON added in v0.7.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ComputePolicy.

type ComputePolicyListResult 

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

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

ComputePolicyListResult - The list of compute policies in the account.

func (ComputePolicyListResult) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ComputePolicyListResult.

func (*ComputePolicyListResult) UnmarshalJSON added in v0.7.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ComputePolicyListResult.

type ComputePolicyProperties 

type ComputePolicyProperties struct {
	// READ-ONLY; The maximum degree of parallelism per job this user can use to submit jobs.
	MaxDegreeOfParallelismPerJob *int32

	// READ-ONLY; The minimum priority per job this user can use to submit jobs.
	MinPriorityPerJob *int32

	// READ-ONLY; The AAD object identifier for the entity to create a policy for.
	ObjectID *string

	// READ-ONLY; The type of AAD object the object identifier refers to.
	ObjectType *AADObjectType
}

ComputePolicyProperties - The compute policy properties.

func (ComputePolicyProperties) MarshalJSON added in v0.7.0 

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

MarshalJSON implements the json.Marshaller interface for type ComputePolicyProperties.

func (*ComputePolicyProperties) UnmarshalJSON added in v0.7.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ComputePolicyProperties.

type CreateComputePolicyWithAccountParameters 

type CreateComputePolicyWithAccountParameters struct {
	// REQUIRED; The unique name of the compute policy to create.
	Name *string

	// REQUIRED; The compute policy properties to use when creating a new compute policy.
	Properties *CreateOrUpdateComputePolicyProperties
}

CreateComputePolicyWithAccountParameters - The parameters used to create a new compute policy while creating a new Data Lake Analytics account.

func (CreateComputePolicyWithAccountParameters) MarshalJSON added in v0.7.0 

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

MarshalJSON implements the json.Marshaller interface for type CreateComputePolicyWithAccountParameters.

func (*CreateComputePolicyWithAccountParameters) UnmarshalJSON added in v0.7.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type CreateComputePolicyWithAccountParameters.

type CreateDataLakeAnalyticsAccountParameters 

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

	// REQUIRED; The Data Lake Analytics account properties to use for creating.
	Properties *CreateDataLakeAnalyticsAccountProperties

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

CreateDataLakeAnalyticsAccountParameters - The parameters to use for creating a Data Lake Analytics account.

func (CreateDataLakeAnalyticsAccountParameters) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type CreateDataLakeAnalyticsAccountParameters.

func (*CreateDataLakeAnalyticsAccountParameters) UnmarshalJSON added in v0.7.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type CreateDataLakeAnalyticsAccountParameters.

type CreateDataLakeAnalyticsAccountProperties 

type CreateDataLakeAnalyticsAccountProperties struct {
	// REQUIRED; The list of Data Lake Store accounts associated with this account.
	DataLakeStoreAccounts []*AddDataLakeStoreWithAccountParameters

	// REQUIRED; The default Data Lake Store account associated with this account.
	DefaultDataLakeStoreAccount *string

	// The list of compute policies associated with this account.
	ComputePolicies []*CreateComputePolicyWithAccountParameters

	// 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 account.
	FirewallRules []*CreateFirewallRuleWithAccountParameters

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

	// The maximum supported degree of parallelism for this account.
	MaxDegreeOfParallelism *int32

	// The maximum supported degree of parallelism per job for this account.
	MaxDegreeOfParallelismPerJob *int32

	// The maximum supported jobs running under the account at the same time.
	MaxJobCount *int32

	// The minimum supported priority per job for this account.
	MinPriorityPerJob *int32

	// The commitment tier for the next month.
	NewTier *TierType

	// The number of days that job metadata is retained.
	QueryStoreRetention *int32

	// The list of Azure Blob Storage accounts associated with this account.
	StorageAccounts []*AddStorageAccountWithAccountParameters
}

func (CreateDataLakeAnalyticsAccountProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type CreateDataLakeAnalyticsAccountProperties.

func (*CreateDataLakeAnalyticsAccountProperties) UnmarshalJSON added in v0.7.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type CreateDataLakeAnalyticsAccountProperties.

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 Analytics account.

func (CreateFirewallRuleWithAccountParameters) MarshalJSON added in v0.7.0 

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

MarshalJSON implements the json.Marshaller interface for type CreateFirewallRuleWithAccountParameters.

func (*CreateFirewallRuleWithAccountParameters) UnmarshalJSON added in v0.7.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type CreateFirewallRuleWithAccountParameters.

type CreateOrUpdateComputePolicyParameters 

type CreateOrUpdateComputePolicyParameters struct {
	// REQUIRED; The compute policy properties to use when creating a new compute policy.
	Properties *CreateOrUpdateComputePolicyProperties
}

CreateOrUpdateComputePolicyParameters - The parameters used to create a new compute policy.

func (CreateOrUpdateComputePolicyParameters) MarshalJSON added in v0.7.0 

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

MarshalJSON implements the json.Marshaller interface for type CreateOrUpdateComputePolicyParameters.

func (*CreateOrUpdateComputePolicyParameters) UnmarshalJSON added in v0.7.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type CreateOrUpdateComputePolicyParameters.

type CreateOrUpdateComputePolicyProperties 

type CreateOrUpdateComputePolicyProperties struct {
	// REQUIRED; The AAD object identifier for the entity to create a policy for.
	ObjectID *string

	// REQUIRED; The type of AAD object the object identifier refers to.
	ObjectType *AADObjectType

	// The maximum degree of parallelism per job this user can use to submit jobs. This property, the min priority per job property,
	// or both must be passed.
	MaxDegreeOfParallelismPerJob *int32

	// The minimum priority per job this user can use to submit jobs. This property, the max degree of parallelism per job property,
	// or both must be passed.
	MinPriorityPerJob *int32
}

CreateOrUpdateComputePolicyProperties - The compute policy properties to use when creating a new compute policy.

func (CreateOrUpdateComputePolicyProperties) MarshalJSON added in v0.7.0 

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

MarshalJSON implements the json.Marshaller interface for type CreateOrUpdateComputePolicyProperties.

func (*CreateOrUpdateComputePolicyProperties) UnmarshalJSON added in v0.7.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type CreateOrUpdateComputePolicyProperties.

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 v0.7.0 

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

MarshalJSON implements the json.Marshaller interface for type CreateOrUpdateFirewallRuleParameters.

func (*CreateOrUpdateFirewallRuleParameters) UnmarshalJSON added in v0.7.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 v0.7.0 

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

MarshalJSON implements the json.Marshaller interface for type CreateOrUpdateFirewallRuleProperties.

func (*CreateOrUpdateFirewallRuleProperties) UnmarshalJSON added in v0.7.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type CreateOrUpdateFirewallRuleProperties.

type DataLakeAnalyticsAccountState 

type DataLakeAnalyticsAccountState string

DataLakeAnalyticsAccountState - The state of the Data Lake Analytics account. 

const (
	DataLakeAnalyticsAccountStateActive    DataLakeAnalyticsAccountState = "Active"
	DataLakeAnalyticsAccountStateSuspended DataLakeAnalyticsAccountState = "Suspended"
)

func PossibleDataLakeAnalyticsAccountStateValues 

func PossibleDataLakeAnalyticsAccountStateValues() []DataLakeAnalyticsAccountState

PossibleDataLakeAnalyticsAccountStateValues returns the possible values for the DataLakeAnalyticsAccountState const type.

type DataLakeAnalyticsAccountStatus 

type DataLakeAnalyticsAccountStatus string

DataLakeAnalyticsAccountStatus - The provisioning status of the Data Lake Analytics account. 

const (
	DataLakeAnalyticsAccountStatusCanceled   DataLakeAnalyticsAccountStatus = "Canceled"
	DataLakeAnalyticsAccountStatusCreating   DataLakeAnalyticsAccountStatus = "Creating"
	DataLakeAnalyticsAccountStatusDeleted    DataLakeAnalyticsAccountStatus = "Deleted"
	DataLakeAnalyticsAccountStatusDeleting   DataLakeAnalyticsAccountStatus = "Deleting"
	DataLakeAnalyticsAccountStatusFailed     DataLakeAnalyticsAccountStatus = "Failed"
	DataLakeAnalyticsAccountStatusPatching   DataLakeAnalyticsAccountStatus = "Patching"
	DataLakeAnalyticsAccountStatusResuming   DataLakeAnalyticsAccountStatus = "Resuming"
	DataLakeAnalyticsAccountStatusRunning    DataLakeAnalyticsAccountStatus = "Running"
	DataLakeAnalyticsAccountStatusSucceeded  DataLakeAnalyticsAccountStatus = "Succeeded"
	DataLakeAnalyticsAccountStatusSuspending DataLakeAnalyticsAccountStatus = "Suspending"
	DataLakeAnalyticsAccountStatusUndeleting DataLakeAnalyticsAccountStatus = "Undeleting"
)

func PossibleDataLakeAnalyticsAccountStatusValues 

func PossibleDataLakeAnalyticsAccountStatusValues() []DataLakeAnalyticsAccountStatus

PossibleDataLakeAnalyticsAccountStatusValues returns the possible values for the DataLakeAnalyticsAccountStatus const type.

type DataLakeStoreAccountInformation 

type DataLakeStoreAccountInformation struct {
	// The Data Lake Store account properties.
	Properties *DataLakeStoreAccountInformationProperties

	// READ-ONLY; The resource identifier.
	ID *string

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

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

DataLakeStoreAccountInformation - Data Lake Store account information.

func (DataLakeStoreAccountInformation) MarshalJSON added in v0.7.0 

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

MarshalJSON implements the json.Marshaller interface for type DataLakeStoreAccountInformation.

func (*DataLakeStoreAccountInformation) UnmarshalJSON added in v0.7.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type DataLakeStoreAccountInformation.

type DataLakeStoreAccountInformationListResult 

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

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

DataLakeStoreAccountInformationListResult - Data Lake Store account list information.

func (DataLakeStoreAccountInformationListResult) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type DataLakeStoreAccountInformationListResult.

func (*DataLakeStoreAccountInformationListResult) UnmarshalJSON added in v0.7.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type DataLakeStoreAccountInformationListResult.

type DataLakeStoreAccountInformationProperties 

type DataLakeStoreAccountInformationProperties struct {
	// READ-ONLY; The optional suffix for the Data Lake Store account.
	Suffix *string
}

DataLakeStoreAccountInformationProperties - The Data Lake Store account properties.

func (DataLakeStoreAccountInformationProperties) MarshalJSON added in v0.7.0 

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

MarshalJSON implements the json.Marshaller interface for type DataLakeStoreAccountInformationProperties.

func (*DataLakeStoreAccountInformationProperties) UnmarshalJSON added in v0.7.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type DataLakeStoreAccountInformationProperties.

type DataLakeStoreAccountsClient 

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

DataLakeStoreAccountsClient contains the methods for the DataLakeStoreAccounts group. Don't use this type directly, use NewDataLakeStoreAccountsClient() instead.

func NewDataLakeStoreAccountsClient 

func NewDataLakeStoreAccountsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*DataLakeStoreAccountsClient, error)

NewDataLakeStoreAccountsClient creates a new instance of DataLakeStoreAccountsClient with the specified values.

  • subscriptionID - Get 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 (*DataLakeStoreAccountsClient) Add 

func (client *DataLakeStoreAccountsClient) Add(ctx context.Context, resourceGroupName string, accountName string, dataLakeStoreAccountName string, options *DataLakeStoreAccountsClientAddOptions) (DataLakeStoreAccountsClientAddResponse, error)

Add - Updates the specified Data Lake Analytics account to include the additional Data Lake Store account. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2019-11-01-preview

  • resourceGroupName - The name of the Azure resource group.
  • accountName - The name of the Data Lake Analytics account.
  • dataLakeStoreAccountName - The name of the Data Lake Store account to add.
  • options - DataLakeStoreAccountsClientAddOptions contains the optional parameters for the DataLakeStoreAccountsClient.Add method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/datalake-analytics/resource-manager/Microsoft.DataLakeAnalytics/preview/2019-11-01-preview/examples/DataLakeStoreAccounts_Add.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-analytics/armdatalakeanalytics"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armdatalakeanalytics.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	_, err = clientFactory.NewDataLakeStoreAccountsClient().Add(ctx, "contosorg", "contosoadla", "test_adls_account", &armdatalakeanalytics.DataLakeStoreAccountsClientAddOptions{Parameters: &armdatalakeanalytics.AddDataLakeStoreParameters{
		Properties: &armdatalakeanalytics.AddDataLakeStoreProperties{
			Suffix: to.Ptr("test_suffix"),
		},
	},
	})
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
}

Output:

func (*DataLakeStoreAccountsClient) Delete 

func (client *DataLakeStoreAccountsClient) Delete(ctx context.Context, resourceGroupName string, accountName string, dataLakeStoreAccountName string, options *DataLakeStoreAccountsClientDeleteOptions) (DataLakeStoreAccountsClientDeleteResponse, error)

Delete - Updates the Data Lake Analytics account specified to remove the specified Data Lake Store account. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2019-11-01-preview

  • resourceGroupName - The name of the Azure resource group.
  • accountName - The name of the Data Lake Analytics account.
  • dataLakeStoreAccountName - The name of the Data Lake Store account to remove
  • options - DataLakeStoreAccountsClientDeleteOptions contains the optional parameters for the DataLakeStoreAccountsClient.Delete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/datalake-analytics/resource-manager/Microsoft.DataLakeAnalytics/preview/2019-11-01-preview/examples/DataLakeStoreAccounts_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-analytics/armdatalakeanalytics"
)

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

Output:

func (*DataLakeStoreAccountsClient) Get 

func (client *DataLakeStoreAccountsClient) Get(ctx context.Context, resourceGroupName string, accountName string, dataLakeStoreAccountName string, options *DataLakeStoreAccountsClientGetOptions) (DataLakeStoreAccountsClientGetResponse, error)

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

Generated from API version 2019-11-01-preview

  • resourceGroupName - The name of the Azure resource group.
  • accountName - The name of the Data Lake Analytics account.
  • dataLakeStoreAccountName - The name of the Data Lake Store account to retrieve
  • options - DataLakeStoreAccountsClientGetOptions contains the optional parameters for the DataLakeStoreAccountsClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/datalake-analytics/resource-manager/Microsoft.DataLakeAnalytics/preview/2019-11-01-preview/examples/DataLakeStoreAccounts_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-analytics/armdatalakeanalytics"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armdatalakeanalytics.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewDataLakeStoreAccountsClient().Get(ctx, "contosorg", "contosoadla", "test_adls_account", 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.DataLakeStoreAccountInformation = armdatalakeanalytics.DataLakeStoreAccountInformation{
	// 	Name: to.Ptr("test_adls"),
	// 	Type: to.Ptr("test_type"),
	// 	ID: to.Ptr("34adfa4f-cedf-4dc0-ba29-b6d1a69ab345"),
	// 	Properties: &armdatalakeanalytics.DataLakeStoreAccountInformationProperties{
	// 		Suffix: to.Ptr("test_suffix"),
	// 	},
	// }
}

Output:

func (*DataLakeStoreAccountsClient) NewListByAccountPager added in v0.5.0 

func (client *DataLakeStoreAccountsClient) NewListByAccountPager(resourceGroupName string, accountName string, options *DataLakeStoreAccountsClientListByAccountOptions) *runtime.Pager[DataLakeStoreAccountsClientListByAccountResponse]

NewListByAccountPager - Gets the first page of Data Lake Store accounts linked to the specified Data Lake Analytics account. The response includes a link to the next page, if any.

Generated from API version 2019-11-01-preview

  • resourceGroupName - The name of the Azure resource group.
  • accountName - The name of the Data Lake Analytics account.
  • options - DataLakeStoreAccountsClientListByAccountOptions contains the optional parameters for the DataLakeStoreAccountsClient.NewListByAccountPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/datalake-analytics/resource-manager/Microsoft.DataLakeAnalytics/preview/2019-11-01-preview/examples/DataLakeStoreAccounts_ListByAccount.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-analytics/armdatalakeanalytics"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armdatalakeanalytics.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewDataLakeStoreAccountsClient().NewListByAccountPager("contosorg", "contosoadla", &armdatalakeanalytics.DataLakeStoreAccountsClientListByAccountOptions{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.DataLakeStoreAccountInformationListResult = armdatalakeanalytics.DataLakeStoreAccountInformationListResult{
		// 	Value: []*armdatalakeanalytics.DataLakeStoreAccountInformation{
		// 		{
		// 			Name: to.Ptr("test_adls"),
		// 			Type: to.Ptr("test_type"),
		// 			ID: to.Ptr("34adfa4f-cedf-4dc0-ba29-b6d1a69ab345"),
		// 			Properties: &armdatalakeanalytics.DataLakeStoreAccountInformationProperties{
		// 				Suffix: to.Ptr("test_suffix"),
		// 			},
		// 	}},
		// }
	}
}

Output:

type DataLakeStoreAccountsClientAddOptions added in v0.3.0 

type DataLakeStoreAccountsClientAddOptions struct {
	// The details of the Data Lake Store account.
	Parameters *AddDataLakeStoreParameters
}

DataLakeStoreAccountsClientAddOptions contains the optional parameters for the DataLakeStoreAccountsClient.Add method.

type DataLakeStoreAccountsClientAddResponse added in v0.3.0 

type DataLakeStoreAccountsClientAddResponse struct {
}

DataLakeStoreAccountsClientAddResponse contains the response from method DataLakeStoreAccountsClient.Add.

type DataLakeStoreAccountsClientDeleteOptions added in v0.3.0 

type DataLakeStoreAccountsClientDeleteOptions struct {
}

DataLakeStoreAccountsClientDeleteOptions contains the optional parameters for the DataLakeStoreAccountsClient.Delete method.

type DataLakeStoreAccountsClientDeleteResponse added in v0.3.0 

type DataLakeStoreAccountsClientDeleteResponse struct {
}

DataLakeStoreAccountsClientDeleteResponse contains the response from method DataLakeStoreAccountsClient.Delete.

type DataLakeStoreAccountsClientGetOptions added in v0.3.0 

type DataLakeStoreAccountsClientGetOptions struct {
}

DataLakeStoreAccountsClientGetOptions contains the optional parameters for the DataLakeStoreAccountsClient.Get method.

type DataLakeStoreAccountsClientGetResponse added in v0.3.0 

type DataLakeStoreAccountsClientGetResponse struct {
	// Data Lake Store account information.
	DataLakeStoreAccountInformation
}

DataLakeStoreAccountsClientGetResponse contains the response from method DataLakeStoreAccountsClient.Get.

type DataLakeStoreAccountsClientListByAccountOptions added in v0.3.0 

type DataLakeStoreAccountsClientListByAccountOptions 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
}

DataLakeStoreAccountsClientListByAccountOptions contains the optional parameters for the DataLakeStoreAccountsClient.NewListByAccountPager method.

type DataLakeStoreAccountsClientListByAccountResponse added in v0.3.0 

type DataLakeStoreAccountsClientListByAccountResponse struct {
	// Data Lake Store account list information.
	DataLakeStoreAccountInformationListResult
}

DataLakeStoreAccountsClientListByAccountResponse contains the response from method DataLakeStoreAccountsClient.NewListByAccountPager.

type DebugDataAccessLevel 

type DebugDataAccessLevel string

DebugDataAccessLevel - The current state of the DebugDataAccessLevel for this account. 

const (
	DebugDataAccessLevelAll      DebugDataAccessLevel = "All"
	DebugDataAccessLevelCustomer DebugDataAccessLevel = "Customer"
	DebugDataAccessLevelNone     DebugDataAccessLevel = "None"
)

func PossibleDebugDataAccessLevelValues 

func PossibleDebugDataAccessLevelValues() []DebugDataAccessLevel

PossibleDebugDataAccessLevelValues returns the possible values for the DebugDataAccessLevel const type.

type ErrorAdditionalInfo 

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

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

ErrorAdditionalInfo - The resource management error additional info.

func (ErrorAdditionalInfo) MarshalJSON added in v0.7.0 

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

MarshalJSON implements the json.Marshaller interface for type ErrorAdditionalInfo.

func (*ErrorAdditionalInfo) UnmarshalJSON added in v0.7.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ErrorAdditionalInfo.

type ErrorDetail 

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

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

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

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

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

ErrorDetail - The error detail.

func (ErrorDetail) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ErrorDetail.

func (*ErrorDetail) UnmarshalJSON added in v0.7.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ErrorDetail.

type ErrorResponse 

type ErrorResponse struct {
	// The error object.
	Error *ErrorDetail
}

ErrorResponse - Common error response for all Azure Resource Manager APIs to return error details for failed operations. (This also follows the OData error response format.).

func (ErrorResponse) MarshalJSON added in v0.7.0 

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

MarshalJSON implements the json.Marshaller interface for type ErrorResponse.

func (*ErrorResponse) UnmarshalJSON added in v0.7.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ErrorResponse.

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 Analytics firewall rule information.

func (FirewallRule) MarshalJSON added in v0.7.0 

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

MarshalJSON implements the json.Marshaller interface for type FirewallRule.

func (*FirewallRule) UnmarshalJSON added in v0.7.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 Analytics 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 v0.7.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 v0.7.0 

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

MarshalJSON implements the json.Marshaller interface for type FirewallRuleProperties.

func (*FirewallRuleProperties) UnmarshalJSON added in v0.7.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 - Get 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 2019-11-01-preview

  • resourceGroupName - The name of the Azure resource group.
  • accountName - The name of the Data Lake Analytics 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/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/datalake-analytics/resource-manager/Microsoft.DataLakeAnalytics/preview/2019-11-01-preview/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-analytics/armdatalakeanalytics"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armdatalakeanalytics.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", armdatalakeanalytics.CreateOrUpdateFirewallRuleParameters{
		Properties: &armdatalakeanalytics.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 = armdatalakeanalytics.FirewallRule{
	// 	Name: to.Ptr("test_rule"),
	// 	Type: to.Ptr("test_type"),
	// 	ID: to.Ptr("34adfa4f-cedf-4dc0-ba29-b6d1a69ab345"),
	// 	Properties: &armdatalakeanalytics.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 Analytics account If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2019-11-01-preview

  • resourceGroupName - The name of the Azure resource group.
  • accountName - The name of the Data Lake Analytics 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/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/datalake-analytics/resource-manager/Microsoft.DataLakeAnalytics/preview/2019-11-01-preview/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-analytics/armdatalakeanalytics"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armdatalakeanalytics.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 Analytics firewall rule. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2019-11-01-preview

  • resourceGroupName - The name of the Azure resource group.
  • accountName - The name of the Data Lake Analytics 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/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/datalake-analytics/resource-manager/Microsoft.DataLakeAnalytics/preview/2019-11-01-preview/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-analytics/armdatalakeanalytics"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armdatalakeanalytics.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 = armdatalakeanalytics.FirewallRule{
	// 	Name: to.Ptr("test_rule"),
	// 	Type: to.Ptr("test_type"),
	// 	ID: to.Ptr("34adfa4f-cedf-4dc0-ba29-b6d1a69ab345"),
	// 	Properties: &armdatalakeanalytics.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 Analytics firewall rules within the specified Data Lake Analytics account.

Generated from API version 2019-11-01-preview

  • resourceGroupName - The name of the Azure resource group.
  • accountName - The name of the Data Lake Analytics 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/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/datalake-analytics/resource-manager/Microsoft.DataLakeAnalytics/preview/2019-11-01-preview/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-analytics/armdatalakeanalytics"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armdatalakeanalytics.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 = armdatalakeanalytics.FirewallRuleListResult{
		// 	Value: []*armdatalakeanalytics.FirewallRule{
		// 		{
		// 			Name: to.Ptr("test_rule"),
		// 			Type: to.Ptr("test_type"),
		// 			ID: to.Ptr("34adfa4f-cedf-4dc0-ba29-b6d1a69ab345"),
		// 			Properties: &armdatalakeanalytics.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 2019-11-01-preview

  • resourceGroupName - The name of the Azure resource group.
  • accountName - The name of the Data Lake Analytics 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/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/datalake-analytics/resource-manager/Microsoft.DataLakeAnalytics/preview/2019-11-01-preview/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-analytics/armdatalakeanalytics"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armdatalakeanalytics.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", &armdatalakeanalytics.FirewallRulesClientUpdateOptions{Parameters: &armdatalakeanalytics.UpdateFirewallRuleParameters{
		Properties: &armdatalakeanalytics.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 = armdatalakeanalytics.FirewallRule{
	// 	Name: to.Ptr("test_rule"),
	// 	Type: to.Ptr("test_type"),
	// 	ID: to.Ptr("34adfa4f-cedf-4dc0-ba29-b6d1a69ab345"),
	// 	Properties: &armdatalakeanalytics.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 Analytics 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 Analytics 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 Analytics 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 Analytics 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 account. 

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

func PossibleFirewallStateValues 

func PossibleFirewallStateValues() []FirewallState

PossibleFirewallStateValues returns the possible values for the FirewallState const type.

type HiveMetastore 

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

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

	// READ-ONLY; The HiveMetastoreProperties rule properties.
	Properties *HiveMetastoreProperties

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

func (HiveMetastore) MarshalJSON added in v0.7.0 

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

MarshalJSON implements the json.Marshaller interface for type HiveMetastore.

func (*HiveMetastore) UnmarshalJSON added in v0.7.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type HiveMetastore.

type HiveMetastoreListResult 

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

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

HiveMetastoreListResult - Data Lake Analytics HiveMetastore list information.

func (HiveMetastoreListResult) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type HiveMetastoreListResult.

func (*HiveMetastoreListResult) UnmarshalJSON added in v0.7.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type HiveMetastoreListResult.

type HiveMetastoreProperties 

type HiveMetastoreProperties struct {
	// READ-ONLY; The databaseName for the Hive MetaStore
	DatabaseName *string

	// READ-ONLY; The current state of the NestedResource
	NestedResourceProvisioningState *NestedResourceProvisioningState

	// READ-ONLY; The password for the Hive MetaStore
	Password *string

	// READ-ONLY; The runtimeVersion for the Hive MetaStore
	RuntimeVersion *string

	// READ-ONLY; The serverUri for the Hive MetaStore
	ServerURI *string

	// READ-ONLY; The userName for the Hive MetaStore
	UserName *string
}

HiveMetastoreProperties - The HiveMetastore properties.

func (HiveMetastoreProperties) MarshalJSON added in v0.7.0 

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

MarshalJSON implements the json.Marshaller interface for type HiveMetastoreProperties.

func (*HiveMetastoreProperties) UnmarshalJSON added in v0.7.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type HiveMetastoreProperties.

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 - Get 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 Analytics specified by resource location. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2019-11-01-preview

  • 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/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/datalake-analytics/resource-manager/Microsoft.DataLakeAnalytics/preview/2019-11-01-preview/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-analytics/armdatalakeanalytics"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armdatalakeanalytics.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 = armdatalakeanalytics.CapabilityInformation{
	// 	AccountCount: to.Ptr[int32](100),
	// 	MaxAccountCount: to.Ptr[int32](150),
	// 	MigrationState: to.Ptr(false),
	// 	State: to.Ptr(armdatalakeanalytics.SubscriptionStateRegistered),
	// 	SubscriptionID: to.Ptr("34adfa4f-cedf-4dc0-ba29-b6d1a69ab345"),
	// }
}

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 Analytics.
	CapabilityInformation
}

LocationsClientGetCapabilityResponse contains the response from method LocationsClient.GetCapability.

type NameAvailabilityInformation 

type NameAvailabilityInformation struct {
	// READ-ONLY; The message describing why the Data Lake Analytics 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 Analytics account name is available or
	// not.
	NameAvailable *bool

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

NameAvailabilityInformation - Data Lake Analytics account name availability result information.

func (NameAvailabilityInformation) MarshalJSON added in v0.7.0 

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

MarshalJSON implements the json.Marshaller interface for type NameAvailabilityInformation.

func (*NameAvailabilityInformation) UnmarshalJSON added in v0.7.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type NameAvailabilityInformation.

type NestedResourceProvisioningState 

type NestedResourceProvisioningState string

NestedResourceProvisioningState - The current state of the NestedResourceProvisioning for this account. 

const (
	NestedResourceProvisioningStateCanceled  NestedResourceProvisioningState = "Canceled"
	NestedResourceProvisioningStateFailed    NestedResourceProvisioningState = "Failed"
	NestedResourceProvisioningStateSucceeded NestedResourceProvisioningState = "Succeeded"
)

func PossibleNestedResourceProvisioningStateValues 

func PossibleNestedResourceProvisioningStateValues() []NestedResourceProvisioningState

PossibleNestedResourceProvisioningStateValues returns the possible values for the NestedResourceProvisioningState const type.

type Operation 

type Operation struct {
	// READ-ONLY; 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

	// READ-ONLY; The OperationMetaPropertyInfo for the operation.
	Properties *OperationMetaPropertyInfo
}

Operation - An available operation for Data Lake Analytics.

func (Operation) MarshalJSON added in v0.7.0 

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

MarshalJSON implements the json.Marshaller interface for type Operation.

func (*Operation) UnmarshalJSON added in v0.7.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 v0.7.0 

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

MarshalJSON implements the json.Marshaller interface for type OperationDisplay.

func (*OperationDisplay) UnmarshalJSON added in v0.7.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 Analytics.

func (OperationListResult) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type OperationListResult.

func (*OperationListResult) UnmarshalJSON added in v0.7.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type OperationListResult.

type OperationMetaLogSpecification 

type OperationMetaLogSpecification struct {
	// The blobDuration for OperationMetaLogSpecification.
	BlobDuration *string

	// The displayName for OperationMetaLogSpecification.
	DisplayName *string

	// The name for OperationMetaLogSpecification.
	Name *string
}

func (OperationMetaLogSpecification) MarshalJSON added in v0.7.0 

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

MarshalJSON implements the json.Marshaller interface for type OperationMetaLogSpecification.

func (*OperationMetaLogSpecification) UnmarshalJSON added in v0.7.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type OperationMetaLogSpecification.

type OperationMetaMetricAvailabilitiesSpecification 

type OperationMetaMetricAvailabilitiesSpecification struct {
	// The blobDuration for OperationMetaMetricAvailabilitiesSpecification.
	BlobDuration *string

	// The timegrain for OperationMetaMetricAvailabilitiesSpecification.
	TimeGrain *string
}

func (OperationMetaMetricAvailabilitiesSpecification) MarshalJSON added in v0.7.0 

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

MarshalJSON implements the json.Marshaller interface for type OperationMetaMetricAvailabilitiesSpecification.

func (*OperationMetaMetricAvailabilitiesSpecification) UnmarshalJSON added in v0.7.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type OperationMetaMetricAvailabilitiesSpecification.

type OperationMetaMetricSpecification 

type OperationMetaMetricSpecification struct {
	// The aggregationType for OperationMetaMetricSpecification.
	AggregationType *string

	// The availabilities for OperationMetaMetricSpecification.
	Availabilities []*OperationMetaMetricAvailabilitiesSpecification

	// The displayName for OperationMetaMetricSpecification.
	DisplayDescription *string

	// The displayName for OperationMetaMetricSpecification.
	DisplayName *string

	// The name for OperationMetaMetricSpecification.
	Name *string

	// The unit for OperationMetaMetricSpecification.
	Unit *string
}

func (OperationMetaMetricSpecification) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type OperationMetaMetricSpecification.

func (*OperationMetaMetricSpecification) UnmarshalJSON added in v0.7.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type OperationMetaMetricSpecification.

type OperationMetaPropertyInfo 

type OperationMetaPropertyInfo struct {
	// The operations OperationMetaServiceSpecification.
	ServiceSpecification *OperationMetaServiceSpecification
}

func (OperationMetaPropertyInfo) MarshalJSON added in v0.7.0 

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

MarshalJSON implements the json.Marshaller interface for type OperationMetaPropertyInfo.

func (*OperationMetaPropertyInfo) UnmarshalJSON added in v0.7.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type OperationMetaPropertyInfo.

type OperationMetaServiceSpecification 

type OperationMetaServiceSpecification struct {
	// The logSpecifications for OperationMetaServiceSpecification.
	LogSpecifications []*OperationMetaLogSpecification

	// The metricSpecifications for OperationMetaServiceSpecification.
	MetricSpecifications []*OperationMetaMetricSpecification
}

func (OperationMetaServiceSpecification) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type OperationMetaServiceSpecification.

func (*OperationMetaServiceSpecification) UnmarshalJSON added in v0.7.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type OperationMetaServiceSpecification.

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 Analytics REST API operations. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2019-11-01-preview

  • 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/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/datalake-analytics/resource-manager/Microsoft.DataLakeAnalytics/preview/2019-11-01-preview/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-analytics/armdatalakeanalytics"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armdatalakeanalytics.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 = armdatalakeanalytics.OperationListResult{
	// 	Value: []*armdatalakeanalytics.Operation{
	// 		{
	// 			Name: to.Ptr("Microsoft.DataLakeAnalytics/operations/read"),
	// 			Display: &armdatalakeanalytics.OperationDisplay{
	// 				Description: to.Ptr("Get available operations of DataLakeAnalytics."),
	// 				Operation: to.Ptr("Get Available Operations"),
	// 				Provider: to.Ptr("Microsoft DataLakeAnalytics"),
	// 				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 Analytics.
	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 v0.7.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type Resource.

type SasTokenInformation 

type SasTokenInformation struct {
	// READ-ONLY; The access token for the associated Azure Storage Container.
	AccessToken *string
}

SasTokenInformation - SAS token information.

func (SasTokenInformation) MarshalJSON added in v0.7.0 

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

MarshalJSON implements the json.Marshaller interface for type SasTokenInformation.

func (*SasTokenInformation) UnmarshalJSON added in v0.7.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SasTokenInformation.

type SasTokenInformationListResult 

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

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

SasTokenInformationListResult - The SAS response that contains the storage account, container and associated SAS token for connection use.

func (SasTokenInformationListResult) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type SasTokenInformationListResult.

func (*SasTokenInformationListResult) UnmarshalJSON added in v0.7.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SasTokenInformationListResult.

type StorageAccountInformation 

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

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

	// READ-ONLY; The Azure Storage account properties.
	Properties *StorageAccountInformationProperties

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

StorageAccountInformation - Azure Storage account information.

func (StorageAccountInformation) MarshalJSON added in v0.7.0 

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

MarshalJSON implements the json.Marshaller interface for type StorageAccountInformation.

func (*StorageAccountInformation) UnmarshalJSON added in v0.7.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type StorageAccountInformation.

type StorageAccountInformationListResult 

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

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

StorageAccountInformationListResult - Azure Storage account list information.

func (StorageAccountInformationListResult) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type StorageAccountInformationListResult.

func (*StorageAccountInformationListResult) UnmarshalJSON added in v0.7.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type StorageAccountInformationListResult.

type StorageAccountInformationProperties 

type StorageAccountInformationProperties struct {
	// READ-ONLY; The optional suffix for the storage account.
	Suffix *string
}

StorageAccountInformationProperties - The Azure Storage account properties.

func (StorageAccountInformationProperties) MarshalJSON added in v0.7.0 

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

MarshalJSON implements the json.Marshaller interface for type StorageAccountInformationProperties.

func (*StorageAccountInformationProperties) UnmarshalJSON added in v0.7.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type StorageAccountInformationProperties.

type StorageAccountsClient 

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

StorageAccountsClient contains the methods for the StorageAccounts group. Don't use this type directly, use NewStorageAccountsClient() instead.

func NewStorageAccountsClient 

func NewStorageAccountsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*StorageAccountsClient, error)

NewStorageAccountsClient creates a new instance of StorageAccountsClient with the specified values.

  • subscriptionID - Get 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 (*StorageAccountsClient) Add 

func (client *StorageAccountsClient) Add(ctx context.Context, resourceGroupName string, accountName string, storageAccountName string, parameters AddStorageAccountParameters, options *StorageAccountsClientAddOptions) (StorageAccountsClientAddResponse, error)

Add - Updates the specified Data Lake Analytics account to add an Azure Storage account. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2019-11-01-preview

  • resourceGroupName - The name of the Azure resource group.
  • accountName - The name of the Data Lake Analytics account.
  • storageAccountName - The name of the Azure Storage account to add
  • parameters - The parameters containing the access key and optional suffix for the Azure Storage Account.
  • options - StorageAccountsClientAddOptions contains the optional parameters for the StorageAccountsClient.Add method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/datalake-analytics/resource-manager/Microsoft.DataLakeAnalytics/preview/2019-11-01-preview/examples/StorageAccounts_Add.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-analytics/armdatalakeanalytics"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armdatalakeanalytics.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	_, err = clientFactory.NewStorageAccountsClient().Add(ctx, "contosorg", "contosoadla", "test_storage", armdatalakeanalytics.AddStorageAccountParameters{
		Properties: &armdatalakeanalytics.AddStorageAccountProperties{
			AccessKey: to.Ptr("34adfa4f-cedf-4dc0-ba29-b6d1a69ab346"),
			Suffix:    to.Ptr("test_suffix"),
		},
	}, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
}

Output:

func (*StorageAccountsClient) Delete 

func (client *StorageAccountsClient) Delete(ctx context.Context, resourceGroupName string, accountName string, storageAccountName string, options *StorageAccountsClientDeleteOptions) (StorageAccountsClientDeleteResponse, error)

Delete - Updates the specified Data Lake Analytics account to remove an Azure Storage account. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2019-11-01-preview

  • resourceGroupName - The name of the Azure resource group.
  • accountName - The name of the Data Lake Analytics account.
  • storageAccountName - The name of the Azure Storage account to remove
  • options - StorageAccountsClientDeleteOptions contains the optional parameters for the StorageAccountsClient.Delete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/datalake-analytics/resource-manager/Microsoft.DataLakeAnalytics/preview/2019-11-01-preview/examples/StorageAccounts_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-analytics/armdatalakeanalytics"
)

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

Output:

func (*StorageAccountsClient) Get 

func (client *StorageAccountsClient) Get(ctx context.Context, resourceGroupName string, accountName string, storageAccountName string, options *StorageAccountsClientGetOptions) (StorageAccountsClientGetResponse, error)

Get - Gets the specified Azure Storage account linked to the given Data Lake Analytics account. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2019-11-01-preview

  • resourceGroupName - The name of the Azure resource group.
  • accountName - The name of the Data Lake Analytics account.
  • storageAccountName - The name of the Azure Storage account for which to retrieve the details.
  • options - StorageAccountsClientGetOptions contains the optional parameters for the StorageAccountsClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/datalake-analytics/resource-manager/Microsoft.DataLakeAnalytics/preview/2019-11-01-preview/examples/StorageAccounts_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-analytics/armdatalakeanalytics"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armdatalakeanalytics.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewStorageAccountsClient().Get(ctx, "contosorg", "contosoadla", "test_storage", 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.StorageAccountInformation = armdatalakeanalytics.StorageAccountInformation{
	// 	Name: to.Ptr("test_storage"),
	// 	Type: to.Ptr("test_type"),
	// 	ID: to.Ptr("34adfa4f-cedf-4dc0-ba29-b6d1a69ab345"),
	// 	Properties: &armdatalakeanalytics.StorageAccountInformationProperties{
	// 		Suffix: to.Ptr("test_suffix"),
	// 	},
	// }
}

Output:

func (*StorageAccountsClient) GetStorageContainer 

func (client *StorageAccountsClient) GetStorageContainer(ctx context.Context, resourceGroupName string, accountName string, storageAccountName string, containerName string, options *StorageAccountsClientGetStorageContainerOptions) (StorageAccountsClientGetStorageContainerResponse, error)

GetStorageContainer - Gets the specified Azure Storage container associated with the given Data Lake Analytics and Azure Storage accounts. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2019-11-01-preview

  • resourceGroupName - The name of the Azure resource group.
  • accountName - The name of the Data Lake Analytics account.
  • storageAccountName - The name of the Azure storage account from which to retrieve the blob container.
  • containerName - The name of the Azure storage container to retrieve
  • options - StorageAccountsClientGetStorageContainerOptions contains the optional parameters for the StorageAccountsClient.GetStorageContainer method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/datalake-analytics/resource-manager/Microsoft.DataLakeAnalytics/preview/2019-11-01-preview/examples/StorageAccounts_GetStorageContainer.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-analytics/armdatalakeanalytics"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armdatalakeanalytics.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewStorageAccountsClient().GetStorageContainer(ctx, "contosorg", "contosoadla", "test_storage", "test_container", 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.StorageContainer = armdatalakeanalytics.StorageContainer{
	// 	Name: to.Ptr("test_storage"),
	// 	Type: to.Ptr("test_type"),
	// 	ID: to.Ptr("34adfa4f-cedf-4dc0-ba29-b6d1a69ab345"),
	// 	Properties: &armdatalakeanalytics.StorageContainerProperties{
	// 		LastModifiedTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-04-14T20:21:56.681Z"); return t}()),
	// 	},
	// }
}

Output:

func (*StorageAccountsClient) NewListByAccountPager added in v0.5.0 

func (client *StorageAccountsClient) NewListByAccountPager(resourceGroupName string, accountName string, options *StorageAccountsClientListByAccountOptions) *runtime.Pager[StorageAccountsClientListByAccountResponse]

NewListByAccountPager - Gets the first page of Azure Storage accounts, if any, linked to the specified Data Lake Analytics account. The response includes a link to the next page, if any.

Generated from API version 2019-11-01-preview

  • resourceGroupName - The name of the Azure resource group.
  • accountName - The name of the Data Lake Analytics account.
  • options - StorageAccountsClientListByAccountOptions contains the optional parameters for the StorageAccountsClient.NewListByAccountPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/datalake-analytics/resource-manager/Microsoft.DataLakeAnalytics/preview/2019-11-01-preview/examples/StorageAccounts_ListByAccount.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-analytics/armdatalakeanalytics"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armdatalakeanalytics.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewStorageAccountsClient().NewListByAccountPager("contosorg", "contosoadla", &armdatalakeanalytics.StorageAccountsClientListByAccountOptions{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.StorageAccountInformationListResult = armdatalakeanalytics.StorageAccountInformationListResult{
		// 	Value: []*armdatalakeanalytics.StorageAccountInformation{
		// 		{
		// 			Name: to.Ptr("test_storage"),
		// 			Type: to.Ptr("test_type"),
		// 			ID: to.Ptr("34adfa4f-cedf-4dc0-ba29-b6d1a69ab345"),
		// 			Properties: &armdatalakeanalytics.StorageAccountInformationProperties{
		// 				Suffix: to.Ptr("test_suffix"),
		// 			},
		// 	}},
		// }
	}
}

Output:

func (*StorageAccountsClient) NewListSasTokensPager added in v0.5.0 

func (client *StorageAccountsClient) NewListSasTokensPager(resourceGroupName string, accountName string, storageAccountName string, containerName string, options *StorageAccountsClientListSasTokensOptions) *runtime.Pager[StorageAccountsClientListSasTokensResponse]

NewListSasTokensPager - Gets the SAS token associated with the specified Data Lake Analytics and Azure Storage account and container combination.

Generated from API version 2019-11-01-preview

  • resourceGroupName - The name of the Azure resource group.
  • accountName - The name of the Data Lake Analytics account.
  • storageAccountName - The name of the Azure storage account for which the SAS token is being requested.
  • containerName - The name of the Azure storage container for which the SAS token is being requested.
  • options - StorageAccountsClientListSasTokensOptions contains the optional parameters for the StorageAccountsClient.NewListSasTokensPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/datalake-analytics/resource-manager/Microsoft.DataLakeAnalytics/preview/2019-11-01-preview/examples/StorageAccounts_ListSasTokens.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-analytics/armdatalakeanalytics"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armdatalakeanalytics.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewStorageAccountsClient().NewListSasTokensPager("contosorg", "contosoadla", "test_storage", "test_container", 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.SasTokenInformationListResult = armdatalakeanalytics.SasTokenInformationListResult{
		// 	Value: []*armdatalakeanalytics.SasTokenInformation{
		// 		{
		// 			AccessToken: to.Ptr("34adfa4f-cedf-4dc0-ba29-b6d1a69ab346"),
		// 	}},
		// }
	}
}

Output:

func (*StorageAccountsClient) NewListStorageContainersPager added in v0.5.0 

func (client *StorageAccountsClient) NewListStorageContainersPager(resourceGroupName string, accountName string, storageAccountName string, options *StorageAccountsClientListStorageContainersOptions) *runtime.Pager[StorageAccountsClientListStorageContainersResponse]

NewListStorageContainersPager - Lists the Azure Storage containers, if any, associated with the specified Data Lake Analytics and Azure Storage account combination. The response includes a link to the next page of results, if any.

Generated from API version 2019-11-01-preview

  • resourceGroupName - The name of the Azure resource group.
  • accountName - The name of the Data Lake Analytics account.
  • storageAccountName - The name of the Azure storage account from which to list blob containers.
  • options - StorageAccountsClientListStorageContainersOptions contains the optional parameters for the StorageAccountsClient.NewListStorageContainersPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/datalake-analytics/resource-manager/Microsoft.DataLakeAnalytics/preview/2019-11-01-preview/examples/StorageAccounts_ListStorageContainers.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-analytics/armdatalakeanalytics"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armdatalakeanalytics.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewStorageAccountsClient().NewListStorageContainersPager("contosorg", "contosoadla", "test_storage", 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.StorageContainerListResult = armdatalakeanalytics.StorageContainerListResult{
		// 	Value: []*armdatalakeanalytics.StorageContainer{
		// 		{
		// 			Name: to.Ptr("test_storage"),
		// 			Type: to.Ptr("test_type"),
		// 			ID: to.Ptr("34adfa4f-cedf-4dc0-ba29-b6d1a69ab345"),
		// 			Properties: &armdatalakeanalytics.StorageContainerProperties{
		// 				LastModifiedTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-04-14T20:21:56.681Z"); return t}()),
		// 			},
		// 	}},
		// }
	}
}

Output:

func (*StorageAccountsClient) Update 

func (client *StorageAccountsClient) Update(ctx context.Context, resourceGroupName string, accountName string, storageAccountName string, options *StorageAccountsClientUpdateOptions) (StorageAccountsClientUpdateResponse, error)

Update - Updates the Data Lake Analytics account to replace Azure Storage blob account details, such as the access key and/or suffix. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2019-11-01-preview

  • resourceGroupName - The name of the Azure resource group.
  • accountName - The name of the Data Lake Analytics account.
  • storageAccountName - The Azure Storage account to modify
  • options - StorageAccountsClientUpdateOptions contains the optional parameters for the StorageAccountsClient.Update method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/datalake-analytics/resource-manager/Microsoft.DataLakeAnalytics/preview/2019-11-01-preview/examples/StorageAccounts_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-analytics/armdatalakeanalytics"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armdatalakeanalytics.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	_, err = clientFactory.NewStorageAccountsClient().Update(ctx, "contosorg", "contosoadla", "test_storage", &armdatalakeanalytics.StorageAccountsClientUpdateOptions{Parameters: &armdatalakeanalytics.UpdateStorageAccountParameters{
		Properties: &armdatalakeanalytics.UpdateStorageAccountProperties{
			AccessKey: to.Ptr("34adfa4f-cedf-4dc0-ba29-b6d1a69ab346"),
			Suffix:    to.Ptr("test_suffix"),
		},
	},
	})
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
}

Output:

type StorageAccountsClientAddOptions added in v0.3.0 

type StorageAccountsClientAddOptions struct {
}

StorageAccountsClientAddOptions contains the optional parameters for the StorageAccountsClient.Add method.

type StorageAccountsClientAddResponse added in v0.3.0 

type StorageAccountsClientAddResponse struct {
}

StorageAccountsClientAddResponse contains the response from method StorageAccountsClient.Add.

type StorageAccountsClientDeleteOptions added in v0.3.0 

type StorageAccountsClientDeleteOptions struct {
}

StorageAccountsClientDeleteOptions contains the optional parameters for the StorageAccountsClient.Delete method.

type StorageAccountsClientDeleteResponse added in v0.3.0 

type StorageAccountsClientDeleteResponse struct {
}

StorageAccountsClientDeleteResponse contains the response from method StorageAccountsClient.Delete.

type StorageAccountsClientGetOptions added in v0.3.0 

type StorageAccountsClientGetOptions struct {
}

StorageAccountsClientGetOptions contains the optional parameters for the StorageAccountsClient.Get method.

type StorageAccountsClientGetResponse added in v0.3.0 

type StorageAccountsClientGetResponse struct {
	// Azure Storage account information.
	StorageAccountInformation
}

StorageAccountsClientGetResponse contains the response from method StorageAccountsClient.Get.

type StorageAccountsClientGetStorageContainerOptions added in v0.3.0 

type StorageAccountsClientGetStorageContainerOptions struct {
}

StorageAccountsClientGetStorageContainerOptions contains the optional parameters for the StorageAccountsClient.GetStorageContainer method.

type StorageAccountsClientGetStorageContainerResponse added in v0.3.0 

type StorageAccountsClientGetStorageContainerResponse struct {
	// Azure Storage blob container information.
	StorageContainer
}

StorageAccountsClientGetStorageContainerResponse contains the response from method StorageAccountsClient.GetStorageContainer.

type StorageAccountsClientListByAccountOptions added in v0.3.0 

type StorageAccountsClientListByAccountOptions 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

	// The 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
}

StorageAccountsClientListByAccountOptions contains the optional parameters for the StorageAccountsClient.NewListByAccountPager method.

type StorageAccountsClientListByAccountResponse added in v0.3.0 

type StorageAccountsClientListByAccountResponse struct {
	// Azure Storage account list information.
	StorageAccountInformationListResult
}

StorageAccountsClientListByAccountResponse contains the response from method StorageAccountsClient.NewListByAccountPager.

type StorageAccountsClientListSasTokensOptions added in v0.3.0 

type StorageAccountsClientListSasTokensOptions struct {
}

StorageAccountsClientListSasTokensOptions contains the optional parameters for the StorageAccountsClient.NewListSasTokensPager method.

type StorageAccountsClientListSasTokensResponse added in v0.3.0 

type StorageAccountsClientListSasTokensResponse struct {
	// The SAS response that contains the storage account, container and associated SAS token for connection use.
	SasTokenInformationListResult
}

StorageAccountsClientListSasTokensResponse contains the response from method StorageAccountsClient.NewListSasTokensPager.

type StorageAccountsClientListStorageContainersOptions added in v0.3.0 

type StorageAccountsClientListStorageContainersOptions struct {
}

StorageAccountsClientListStorageContainersOptions contains the optional parameters for the StorageAccountsClient.NewListStorageContainersPager method.

type StorageAccountsClientListStorageContainersResponse added in v0.3.0 

type StorageAccountsClientListStorageContainersResponse struct {
	// The list of blob containers associated with the storage account attached to the Data Lake Analytics account.
	StorageContainerListResult
}

StorageAccountsClientListStorageContainersResponse contains the response from method StorageAccountsClient.NewListStorageContainersPager.

type StorageAccountsClientUpdateOptions added in v0.3.0 

type StorageAccountsClientUpdateOptions struct {
	// The parameters containing the access key and suffix to update the storage account with, if any. Passing nothing results
	// in no change.
	Parameters *UpdateStorageAccountParameters
}

StorageAccountsClientUpdateOptions contains the optional parameters for the StorageAccountsClient.Update method.

type StorageAccountsClientUpdateResponse added in v0.3.0 

type StorageAccountsClientUpdateResponse struct {
}

StorageAccountsClientUpdateResponse contains the response from method StorageAccountsClient.Update.

type StorageContainer 

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

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

	// READ-ONLY; The properties of the blob container.
	Properties *StorageContainerProperties

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

StorageContainer - Azure Storage blob container information.

func (StorageContainer) MarshalJSON added in v0.7.0 

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

MarshalJSON implements the json.Marshaller interface for type StorageContainer.

func (*StorageContainer) UnmarshalJSON added in v0.7.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type StorageContainer.

type StorageContainerListResult 

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

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

StorageContainerListResult - The list of blob containers associated with the storage account attached to the Data Lake Analytics account.

func (StorageContainerListResult) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type StorageContainerListResult.

func (*StorageContainerListResult) UnmarshalJSON added in v0.7.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type StorageContainerListResult.

type StorageContainerProperties 

type StorageContainerProperties struct {
	// READ-ONLY; The last modified time of the blob container.
	LastModifiedTime *time.Time
}

StorageContainerProperties - Azure Storage blob container properties information.

func (StorageContainerProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type StorageContainerProperties.

func (*StorageContainerProperties) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type StorageContainerProperties.

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 v0.7.0 

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

MarshalJSON implements the json.Marshaller interface for type SubResource.

func (*SubResource) UnmarshalJSON added in v0.7.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 for the next month. 

const (
	TierTypeCommitment100000AUHours TierType = "Commitment_100000AUHours"
	TierTypeCommitment10000AUHours  TierType = "Commitment_10000AUHours"
	TierTypeCommitment1000AUHours   TierType = "Commitment_1000AUHours"
	TierTypeCommitment100AUHours    TierType = "Commitment_100AUHours"
	TierTypeCommitment500000AUHours TierType = "Commitment_500000AUHours"
	TierTypeCommitment50000AUHours  TierType = "Commitment_50000AUHours"
	TierTypeCommitment5000AUHours   TierType = "Commitment_5000AUHours"
	TierTypeCommitment500AUHours    TierType = "Commitment_500AUHours"
	TierTypeConsumption             TierType = "Consumption"
)

func PossibleTierTypeValues 

func PossibleTierTypeValues() []TierType

PossibleTierTypeValues returns the possible values for the TierType const type.

type UpdateComputePolicyParameters 

type UpdateComputePolicyParameters struct {
	// The compute policy properties to use when updating a compute policy.
	Properties *UpdateComputePolicyProperties
}

UpdateComputePolicyParameters - The parameters used to update a compute policy.

func (UpdateComputePolicyParameters) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type UpdateComputePolicyParameters.

func (*UpdateComputePolicyParameters) UnmarshalJSON added in v0.7.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type UpdateComputePolicyParameters.

type UpdateComputePolicyProperties 

type UpdateComputePolicyProperties struct {
	// The maximum degree of parallelism per job this user can use to submit jobs. This property, the min priority per job property,
	// or both must be passed.
	MaxDegreeOfParallelismPerJob *int32

	// The minimum priority per job this user can use to submit jobs. This property, the max degree of parallelism per job property,
	// or both must be passed.
	MinPriorityPerJob *int32

	// The AAD object identifier for the entity to create a policy for.
	ObjectID *string

	// The type of AAD object the object identifier refers to.
	ObjectType *AADObjectType
}

UpdateComputePolicyProperties - The compute policy properties to use when updating a compute policy.

func (UpdateComputePolicyProperties) MarshalJSON added in v0.7.0 

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

MarshalJSON implements the json.Marshaller interface for type UpdateComputePolicyProperties.

func (*UpdateComputePolicyProperties) UnmarshalJSON added in v0.7.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type UpdateComputePolicyProperties.

type UpdateComputePolicyWithAccountParameters 

type UpdateComputePolicyWithAccountParameters struct {
	// REQUIRED; The unique name of the compute policy to update.
	Name *string

	// The compute policy properties to use when updating a compute policy.
	Properties *UpdateComputePolicyProperties
}

UpdateComputePolicyWithAccountParameters - The parameters used to update a compute policy while updating a Data Lake Analytics account.

func (UpdateComputePolicyWithAccountParameters) MarshalJSON added in v0.7.0 

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

MarshalJSON implements the json.Marshaller interface for type UpdateComputePolicyWithAccountParameters.

func (*UpdateComputePolicyWithAccountParameters) UnmarshalJSON added in v0.7.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type UpdateComputePolicyWithAccountParameters.

type UpdateDataLakeAnalyticsAccountParameters 

type UpdateDataLakeAnalyticsAccountParameters struct {
	// The properties that can be updated in an existing Data Lake Analytics account.
	Properties *UpdateDataLakeAnalyticsAccountProperties

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

UpdateDataLakeAnalyticsAccountParameters - The parameters that can be used to update an existing Data Lake Analytics account.

func (UpdateDataLakeAnalyticsAccountParameters) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type UpdateDataLakeAnalyticsAccountParameters.

func (*UpdateDataLakeAnalyticsAccountParameters) UnmarshalJSON added in v0.7.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type UpdateDataLakeAnalyticsAccountParameters.

type UpdateDataLakeAnalyticsAccountProperties 

type UpdateDataLakeAnalyticsAccountProperties struct {
	// The list of compute policies associated with this account.
	ComputePolicies []*UpdateComputePolicyWithAccountParameters

	// The list of Data Lake Store accounts associated with this account.
	DataLakeStoreAccounts []*UpdateDataLakeStoreWithAccountParameters

	// 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 account.
	FirewallRules []*UpdateFirewallRuleWithAccountParameters

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

	// The maximum supported degree of parallelism for this account.
	MaxDegreeOfParallelism *int32

	// The maximum supported degree of parallelism per job for this account.
	MaxDegreeOfParallelismPerJob *int32

	// The maximum supported jobs running under the account at the same time.
	MaxJobCount *int32

	// The minimum supported priority per job for this account.
	MinPriorityPerJob *int32

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

	// The number of days that job metadata is retained.
	QueryStoreRetention *int32

	// The list of Azure Blob storage accounts associated with this account.
	StorageAccounts []*UpdateStorageAccountWithAccountParameters
}

UpdateDataLakeAnalyticsAccountProperties - The properties to update that are associated with an underlying Data Lake Analytics account.

func (UpdateDataLakeAnalyticsAccountProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type UpdateDataLakeAnalyticsAccountProperties.

func (*UpdateDataLakeAnalyticsAccountProperties) UnmarshalJSON added in v0.7.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type UpdateDataLakeAnalyticsAccountProperties.

type UpdateDataLakeStoreProperties 

type UpdateDataLakeStoreProperties struct {
	// The optional suffix for the Data Lake Store account.
	Suffix *string
}

UpdateDataLakeStoreProperties - The Data Lake Store account properties to use when updating a Data Lake Store account.

func (UpdateDataLakeStoreProperties) MarshalJSON added in v0.7.0 

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

MarshalJSON implements the json.Marshaller interface for type UpdateDataLakeStoreProperties.

func (*UpdateDataLakeStoreProperties) UnmarshalJSON added in v0.7.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type UpdateDataLakeStoreProperties.

type UpdateDataLakeStoreWithAccountParameters 

type UpdateDataLakeStoreWithAccountParameters struct {
	// REQUIRED; The unique name of the Data Lake Store account to update.
	Name *string

	// The Data Lake Store account properties to use when updating a Data Lake Store account.
	Properties *UpdateDataLakeStoreProperties
}

UpdateDataLakeStoreWithAccountParameters - The parameters used to update a Data Lake Store account while updating a Data Lake Analytics account.

func (UpdateDataLakeStoreWithAccountParameters) MarshalJSON added in v0.7.0 

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

MarshalJSON implements the json.Marshaller interface for type UpdateDataLakeStoreWithAccountParameters.

func (*UpdateDataLakeStoreWithAccountParameters) UnmarshalJSON added in v0.7.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type UpdateDataLakeStoreWithAccountParameters.

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 v0.7.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 v0.7.0 

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

MarshalJSON implements the json.Marshaller interface for type UpdateFirewallRuleProperties.

func (*UpdateFirewallRuleProperties) UnmarshalJSON added in v0.7.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 Analytics account.

func (UpdateFirewallRuleWithAccountParameters) MarshalJSON added in v0.7.0 

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

MarshalJSON implements the json.Marshaller interface for type UpdateFirewallRuleWithAccountParameters.

func (*UpdateFirewallRuleWithAccountParameters) UnmarshalJSON added in v0.7.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type UpdateFirewallRuleWithAccountParameters.

type UpdateStorageAccountParameters 

type UpdateStorageAccountParameters struct {
	// The Azure Storage account properties to use when updating an Azure Storage account.
	Properties *UpdateStorageAccountProperties
}

UpdateStorageAccountParameters - The parameters used to update an Azure Storage account.

func (UpdateStorageAccountParameters) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type UpdateStorageAccountParameters.

func (*UpdateStorageAccountParameters) UnmarshalJSON added in v0.7.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type UpdateStorageAccountParameters.

type UpdateStorageAccountProperties 

type UpdateStorageAccountProperties struct {
	// The updated access key associated with this Azure Storage account that will be used to connect to it.
	AccessKey *string

	// The optional suffix for the storage account.
	Suffix *string
}

UpdateStorageAccountProperties - The Azure Storage account properties to use when updating an Azure Storage account.

func (UpdateStorageAccountProperties) MarshalJSON added in v0.7.0 

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

MarshalJSON implements the json.Marshaller interface for type UpdateStorageAccountProperties.

func (*UpdateStorageAccountProperties) UnmarshalJSON added in v0.7.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type UpdateStorageAccountProperties.

type UpdateStorageAccountWithAccountParameters 

type UpdateStorageAccountWithAccountParameters struct {
	// REQUIRED; The unique name of the Azure Storage account to update.
	Name *string

	// The Azure Storage account properties to use when updating an Azure Storage account.
	Properties *UpdateStorageAccountProperties
}

UpdateStorageAccountWithAccountParameters - The parameters used to update an Azure Storage account while updating a Data Lake Analytics account.

func (UpdateStorageAccountWithAccountParameters) MarshalJSON added in v0.7.0 

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

MarshalJSON implements the json.Marshaller interface for type UpdateStorageAccountWithAccountParameters.

func (*UpdateStorageAccountWithAccountParameters) UnmarshalJSON added in v0.7.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type UpdateStorageAccountWithAccountParameters.

type VirtualNetworkRule 

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

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

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

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

VirtualNetworkRule - Data Lake Analytics VirtualNetwork Rule information.

func (VirtualNetworkRule) MarshalJSON added in v0.7.0 

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

MarshalJSON implements the json.Marshaller interface for type VirtualNetworkRule.

func (*VirtualNetworkRule) UnmarshalJSON added in v0.7.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 Analytics VirtualNetwork 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 v0.7.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

	// READ-ONLY; The current state of the VirtualNetwork Rule
	VirtualNetworkRuleState *VirtualNetworkRuleState
}

VirtualNetworkRuleProperties - The VirtualNetwork Rule properties.

func (VirtualNetworkRuleProperties) MarshalJSON added in v0.7.0 

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

MarshalJSON implements the json.Marshaller interface for type VirtualNetworkRuleProperties.

func (*VirtualNetworkRuleProperties) UnmarshalJSON added in v0.7.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type VirtualNetworkRuleProperties.

type VirtualNetworkRuleState 

type VirtualNetworkRuleState string

VirtualNetworkRuleState - The current state of the VirtualNetworkRule for this account. 

const (
	VirtualNetworkRuleStateActive               VirtualNetworkRuleState = "Active"
	VirtualNetworkRuleStateFailed               VirtualNetworkRuleState = "Failed"
	VirtualNetworkRuleStateNetworkSourceDeleted VirtualNetworkRuleState = "NetworkSourceDeleted"
)

func PossibleVirtualNetworkRuleStateValues 

func PossibleVirtualNetworkRuleStateValues() []VirtualNetworkRuleState

PossibleVirtualNetworkRuleStateValues returns the possible values for the VirtualNetworkRuleState const type.

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

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