diff --git a/services/extendedlocation/mgmt/2021-08-15/extendedlocation/CHANGELOG.md b/services/extendedlocation/mgmt/2021-08-15/extendedlocation/CHANGELOG.md index 52911e4cc5e4..a1ecf841edb0 100644 --- a/services/extendedlocation/mgmt/2021-08-15/extendedlocation/CHANGELOG.md +++ b/services/extendedlocation/mgmt/2021-08-15/extendedlocation/CHANGELOG.md @@ -1,2 +1,2 @@ -# Change History +# Unreleased diff --git a/services/extendedlocation/mgmt/2021-08-15/extendedlocation/_meta.json b/services/extendedlocation/mgmt/2021-08-15/extendedlocation/_meta.json index fc63ee3f220a..9763dbe572b1 100644 --- a/services/extendedlocation/mgmt/2021-08-15/extendedlocation/_meta.json +++ b/services/extendedlocation/mgmt/2021-08-15/extendedlocation/_meta.json @@ -1,5 +1,5 @@ { - "commit": "41bc4891ee06e2225365cb153e88a5749330da99", + "commit": "e81add1be9dcbab8bb549b0a3da6e5a80a72185b", "readme": "/_/azure-rest-api-specs/specification/extendedlocation/resource-manager/readme.md", "tag": "package-2021-08-15", "use": "@microsoft.azure/autorest.go@2.1.187", diff --git a/services/preview/extendedlocation/mgmt/2021-03-15-preview/extendedlocation/CHANGELOG.md b/services/preview/extendedlocation/mgmt/2021-03-15-preview/extendedlocation/CHANGELOG.md index 52911e4cc5e4..a1ecf841edb0 100644 --- a/services/preview/extendedlocation/mgmt/2021-03-15-preview/extendedlocation/CHANGELOG.md +++ b/services/preview/extendedlocation/mgmt/2021-03-15-preview/extendedlocation/CHANGELOG.md @@ -1,2 +1,2 @@ -# Change History +# Unreleased diff --git a/services/preview/extendedlocation/mgmt/2021-03-15-preview/extendedlocation/_meta.json b/services/preview/extendedlocation/mgmt/2021-03-15-preview/extendedlocation/_meta.json index 207b7fc3abad..4a5e3b74c8fd 100644 --- a/services/preview/extendedlocation/mgmt/2021-03-15-preview/extendedlocation/_meta.json +++ b/services/preview/extendedlocation/mgmt/2021-03-15-preview/extendedlocation/_meta.json @@ -1,5 +1,5 @@ { - "commit": "c2ea3a3ccd14293b4bd1d17e684ef9129f0dc604", + "commit": "e81add1be9dcbab8bb549b0a3da6e5a80a72185b", "readme": "/_/azure-rest-api-specs/specification/extendedlocation/resource-manager/readme.md", "tag": "package-2021-03-15-preview", "use": "@microsoft.azure/autorest.go@2.1.187", diff --git a/services/preview/extendedlocation/mgmt/2021-03-15-preview/extendedlocation/customlocations.go b/services/preview/extendedlocation/mgmt/2021-03-15-preview/extendedlocation/customlocations.go index b0924b34f91b..7fadbd33a89d 100644 --- a/services/preview/extendedlocation/mgmt/2021-03-15-preview/extendedlocation/customlocations.go +++ b/services/preview/extendedlocation/mgmt/2021-03-15-preview/extendedlocation/customlocations.go @@ -52,8 +52,7 @@ func (client CustomLocationsClient) CreateOrUpdate(ctx context.Context, resource Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, {TargetValue: resourceGroupName, Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, - {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}, - {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}}, + {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}}}, {TargetValue: resourceName, Constraints: []validation.Constraint{{Target: "resourceName", Name: validation.MaxLength, Rule: 63, Chain: nil}, {Target: "resourceName", Name: validation.MinLength, Rule: 1, Chain: nil}, @@ -148,8 +147,7 @@ func (client CustomLocationsClient) Delete(ctx context.Context, resourceGroupNam Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, {TargetValue: resourceGroupName, Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, - {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}, - {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}}, + {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}}}, {TargetValue: resourceName, Constraints: []validation.Constraint{{Target: "resourceName", Name: validation.MaxLength, Rule: 63, Chain: nil}, {Target: "resourceName", Name: validation.MinLength, Rule: 1, Chain: nil}, @@ -240,8 +238,7 @@ func (client CustomLocationsClient) Get(ctx context.Context, resourceGroupName s Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, {TargetValue: resourceGroupName, Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, - {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}, - {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}}, + {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}}}, {TargetValue: resourceName, Constraints: []validation.Constraint{{Target: "resourceName", Name: validation.MaxLength, Rule: 63, Chain: nil}, {Target: "resourceName", Name: validation.MinLength, Rule: 1, Chain: nil}, @@ -330,8 +327,7 @@ func (client CustomLocationsClient) ListByResourceGroup(ctx context.Context, res Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, {TargetValue: resourceGroupName, Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, - {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}, - {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}}}); err != nil { + {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}}}}); err != nil { return result, validation.NewError("extendedlocation.CustomLocationsClient", "ListByResourceGroup", err.Error()) } @@ -577,8 +573,7 @@ func (client CustomLocationsClient) ListEnabledResourceTypes(ctx context.Context Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, {TargetValue: resourceGroupName, Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, - {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}, - {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}}, + {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}}}, {TargetValue: resourceName, Constraints: []validation.Constraint{{Target: "resourceName", Name: validation.MaxLength, Rule: 63, Chain: nil}, {Target: "resourceName", Name: validation.MinLength, Rule: 1, Chain: nil}, @@ -819,8 +814,7 @@ func (client CustomLocationsClient) Update(ctx context.Context, resourceGroupNam Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, {TargetValue: resourceGroupName, Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, - {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}, - {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}}, + {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}}}, {TargetValue: resourceName, Constraints: []validation.Constraint{{Target: "resourceName", Name: validation.MaxLength, Rule: 63, Chain: nil}, {Target: "resourceName", Name: validation.MinLength, Rule: 1, Chain: nil}, diff --git a/services/preview/extendedlocation/mgmt/2021-08-31-preview/extendedlocation/CHANGELOG.md b/services/preview/extendedlocation/mgmt/2021-08-31-preview/extendedlocation/CHANGELOG.md new file mode 100644 index 000000000000..a1ecf841edb0 --- /dev/null +++ b/services/preview/extendedlocation/mgmt/2021-08-31-preview/extendedlocation/CHANGELOG.md @@ -0,0 +1,2 @@ +# Unreleased + diff --git a/services/preview/extendedlocation/mgmt/2021-08-31-preview/extendedlocation/_meta.json b/services/preview/extendedlocation/mgmt/2021-08-31-preview/extendedlocation/_meta.json new file mode 100644 index 000000000000..0f26a78a5ad7 --- /dev/null +++ b/services/preview/extendedlocation/mgmt/2021-08-31-preview/extendedlocation/_meta.json @@ -0,0 +1,11 @@ +{ + "commit": "e81add1be9dcbab8bb549b0a3da6e5a80a72185b", + "readme": "/_/azure-rest-api-specs/specification/extendedlocation/resource-manager/readme.md", + "tag": "package-2021-08-31-preview", + "use": "@microsoft.azure/autorest.go@2.1.187", + "repository_url": "https://github.com/Azure/azure-rest-api-specs.git", + "autorest_command": "autorest --use=@microsoft.azure/autorest.go@2.1.187 --tag=package-2021-08-31-preview --go-sdk-folder=/_/azure-sdk-for-go --go --verbose --use-onever --version=2.0.4421 --go.license-header=MICROSOFT_MIT_NO_VERSION /_/azure-rest-api-specs/specification/extendedlocation/resource-manager/readme.md", + "additional_properties": { + "additional_options": "--go --verbose --use-onever --version=2.0.4421 --go.license-header=MICROSOFT_MIT_NO_VERSION" + } +} \ No newline at end of file diff --git a/services/preview/extendedlocation/mgmt/2021-08-31-preview/extendedlocation/client.go b/services/preview/extendedlocation/mgmt/2021-08-31-preview/extendedlocation/client.go new file mode 100644 index 000000000000..6319f5e57629 --- /dev/null +++ b/services/preview/extendedlocation/mgmt/2021-08-31-preview/extendedlocation/client.go @@ -0,0 +1,41 @@ +// Package extendedlocation implements the Azure ARM Extendedlocation service API version 2021-08-31-preview. +// +// The customLocations Rest API spec. +package extendedlocation + +// Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT License. See License.txt in the project root for license information. +// +// Code generated by Microsoft (R) AutoRest Code Generator. +// Changes may cause incorrect behavior and will be lost if the code is regenerated. + +import ( + "github.com/Azure/go-autorest/autorest" +) + +const ( + // DefaultBaseURI is the default URI used for the service Extendedlocation + DefaultBaseURI = "https://management.azure.com" +) + +// BaseClient is the base client for Extendedlocation. +type BaseClient struct { + autorest.Client + BaseURI string + SubscriptionID string +} + +// New creates an instance of the BaseClient client. +func New(subscriptionID string) BaseClient { + return NewWithBaseURI(DefaultBaseURI, subscriptionID) +} + +// NewWithBaseURI creates an instance of the BaseClient client using a custom endpoint. Use this when interacting with +// an Azure cloud that uses a non-standard base URI (sovereign clouds, Azure stack). +func NewWithBaseURI(baseURI string, subscriptionID string) BaseClient { + return BaseClient{ + Client: autorest.NewClientWithUserAgent(UserAgent()), + BaseURI: baseURI, + SubscriptionID: subscriptionID, + } +} diff --git a/services/preview/extendedlocation/mgmt/2021-08-31-preview/extendedlocation/customlocations.go b/services/preview/extendedlocation/mgmt/2021-08-31-preview/extendedlocation/customlocations.go new file mode 100644 index 000000000000..18f88b9099df --- /dev/null +++ b/services/preview/extendedlocation/mgmt/2021-08-31-preview/extendedlocation/customlocations.go @@ -0,0 +1,979 @@ +package extendedlocation + +// Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT License. See License.txt in the project root for license information. +// +// Code generated by Microsoft (R) AutoRest Code Generator. +// Changes may cause incorrect behavior and will be lost if the code is regenerated. + +import ( + "context" + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/autorest/validation" + "github.com/Azure/go-autorest/tracing" + "net/http" +) + +// CustomLocationsClient is the the customLocations Rest API spec. +type CustomLocationsClient struct { + BaseClient +} + +// NewCustomLocationsClient creates an instance of the CustomLocationsClient client. +func NewCustomLocationsClient(subscriptionID string) CustomLocationsClient { + return NewCustomLocationsClientWithBaseURI(DefaultBaseURI, subscriptionID) +} + +// NewCustomLocationsClientWithBaseURI creates an instance of the CustomLocationsClient client using a custom endpoint. +// Use this when interacting with an Azure cloud that uses a non-standard base URI (sovereign clouds, Azure stack). +func NewCustomLocationsClientWithBaseURI(baseURI string, subscriptionID string) CustomLocationsClient { + return CustomLocationsClient{NewWithBaseURI(baseURI, subscriptionID)} +} + +// CreateOrUpdate creates or updates a Custom Location in the specified Subscription and Resource Group +// Parameters: +// resourceGroupName - the name of the resource group. The name is case insensitive. +// resourceName - custom Locations name. +// parameters - parameters supplied to create or update a Custom Location. +func (client CustomLocationsClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, resourceName string, parameters CustomLocation) (result CustomLocationsCreateOrUpdateFuture, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/CustomLocationsClient.CreateOrUpdate") + defer func() { + sc := -1 + if result.FutureAPI != nil && result.FutureAPI.Response() != nil { + sc = result.FutureAPI.Response().StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } + if err := validation.Validate([]validation.Validation{ + {TargetValue: client.SubscriptionID, + Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, + {TargetValue: resourceGroupName, + Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, + {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}}}, + {TargetValue: resourceName, + Constraints: []validation.Constraint{{Target: "resourceName", Name: validation.MaxLength, Rule: 63, Chain: nil}, + {Target: "resourceName", Name: validation.MinLength, Rule: 1, Chain: nil}, + {Target: "resourceName", Name: validation.Pattern, Rule: `^[a-zA-Z0-9]$|^[a-zA-Z0-9][-_a-zA-Z0-9]{0,61}[a-zA-Z0-9]$`, Chain: nil}}}}); err != nil { + return result, validation.NewError("extendedlocation.CustomLocationsClient", "CreateOrUpdate", err.Error()) + } + + req, err := client.CreateOrUpdatePreparer(ctx, resourceGroupName, resourceName, parameters) + if err != nil { + err = autorest.NewErrorWithError(err, "extendedlocation.CustomLocationsClient", "CreateOrUpdate", nil, "Failure preparing request") + return + } + + result, err = client.CreateOrUpdateSender(req) + if err != nil { + err = autorest.NewErrorWithError(err, "extendedlocation.CustomLocationsClient", "CreateOrUpdate", result.Response(), "Failure sending request") + return + } + + return +} + +// CreateOrUpdatePreparer prepares the CreateOrUpdate request. +func (client CustomLocationsClient) CreateOrUpdatePreparer(ctx context.Context, resourceGroupName string, resourceName string, parameters CustomLocation) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "resourceGroupName": autorest.Encode("path", resourceGroupName), + "resourceName": autorest.Encode("path", resourceName), + "subscriptionId": autorest.Encode("path", client.SubscriptionID), + } + + const APIVersion = "2021-08-31-preview" + queryParameters := map[string]interface{}{ + "api-version": APIVersion, + } + + parameters.SystemData = nil + preparer := autorest.CreatePreparer( + autorest.AsContentType("application/json; charset=utf-8"), + autorest.AsPut(), + autorest.WithBaseURL(client.BaseURI), + autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ExtendedLocation/customLocations/{resourceName}", pathParameters), + autorest.WithJSON(parameters), + autorest.WithQueryParameters(queryParameters)) + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the +// http.Response Body if it receives an error. +func (client CustomLocationsClient) CreateOrUpdateSender(req *http.Request) (future CustomLocationsCreateOrUpdateFuture, err error) { + var resp *http.Response + future.FutureAPI = &azure.Future{} + resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) + if err != nil { + return + } + var azf azure.Future + azf, err = azure.NewFutureFromResponse(resp) + future.FutureAPI = &azf + future.Result = future.result + return +} + +// CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always +// closes the http.Response Body. +func (client CustomLocationsClient) CreateOrUpdateResponder(resp *http.Response) (result CustomLocation, err error) { + err = autorest.Respond( + resp, + azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusCreated), + autorest.ByUnmarshallingJSON(&result), + autorest.ByClosing()) + result.Response = autorest.Response{Response: resp} + return +} + +// Delete deletes the Custom Location with the specified Resource Name, Resource Group, and Subscription Id. +// Parameters: +// resourceGroupName - the name of the resource group. The name is case insensitive. +// resourceName - custom Locations name. +func (client CustomLocationsClient) Delete(ctx context.Context, resourceGroupName string, resourceName string) (result CustomLocationsDeleteFuture, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/CustomLocationsClient.Delete") + defer func() { + sc := -1 + if result.FutureAPI != nil && result.FutureAPI.Response() != nil { + sc = result.FutureAPI.Response().StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } + if err := validation.Validate([]validation.Validation{ + {TargetValue: client.SubscriptionID, + Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, + {TargetValue: resourceGroupName, + Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, + {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}}}, + {TargetValue: resourceName, + Constraints: []validation.Constraint{{Target: "resourceName", Name: validation.MaxLength, Rule: 63, Chain: nil}, + {Target: "resourceName", Name: validation.MinLength, Rule: 1, Chain: nil}, + {Target: "resourceName", Name: validation.Pattern, Rule: `^[a-zA-Z0-9]$|^[a-zA-Z0-9][-_a-zA-Z0-9]{0,61}[a-zA-Z0-9]$`, Chain: nil}}}}); err != nil { + return result, validation.NewError("extendedlocation.CustomLocationsClient", "Delete", err.Error()) + } + + req, err := client.DeletePreparer(ctx, resourceGroupName, resourceName) + if err != nil { + err = autorest.NewErrorWithError(err, "extendedlocation.CustomLocationsClient", "Delete", nil, "Failure preparing request") + return + } + + result, err = client.DeleteSender(req) + if err != nil { + err = autorest.NewErrorWithError(err, "extendedlocation.CustomLocationsClient", "Delete", result.Response(), "Failure sending request") + return + } + + return +} + +// DeletePreparer prepares the Delete request. +func (client CustomLocationsClient) DeletePreparer(ctx context.Context, resourceGroupName string, resourceName string) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "resourceGroupName": autorest.Encode("path", resourceGroupName), + "resourceName": autorest.Encode("path", resourceName), + "subscriptionId": autorest.Encode("path", client.SubscriptionID), + } + + const APIVersion = "2021-08-31-preview" + queryParameters := map[string]interface{}{ + "api-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsDelete(), + autorest.WithBaseURL(client.BaseURI), + autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ExtendedLocation/customLocations/{resourceName}", pathParameters), + autorest.WithQueryParameters(queryParameters)) + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// DeleteSender sends the Delete request. The method will close the +// http.Response Body if it receives an error. +func (client CustomLocationsClient) DeleteSender(req *http.Request) (future CustomLocationsDeleteFuture, err error) { + var resp *http.Response + future.FutureAPI = &azure.Future{} + resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) + if err != nil { + return + } + var azf azure.Future + azf, err = azure.NewFutureFromResponse(resp) + future.FutureAPI = &azf + future.Result = future.result + return +} + +// DeleteResponder handles the response to the Delete request. The method always +// closes the http.Response Body. +func (client CustomLocationsClient) DeleteResponder(resp *http.Response) (result autorest.Response, err error) { + err = autorest.Respond( + resp, + azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent), + autorest.ByClosing()) + result.Response = resp + return +} + +// FindTargetResourceGroup returns the target resource group associated with the resource sync rules of the Custom +// Location that match the rules passed in with the Find Target Resource Group Request. +// Parameters: +// resourceGroupName - the name of the resource group. The name is case insensitive. +// resourceName - custom Locations name. +// parameters - parameters of the find target resource group request. +func (client CustomLocationsClient) FindTargetResourceGroup(ctx context.Context, resourceGroupName string, resourceName string, parameters CustomLocationFindTargetResourceGroupProperties) (result CustomLocationFindTargetResourceGroupResult, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/CustomLocationsClient.FindTargetResourceGroup") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } + if err := validation.Validate([]validation.Validation{ + {TargetValue: client.SubscriptionID, + Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, + {TargetValue: resourceGroupName, + Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, + {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}}}, + {TargetValue: resourceName, + Constraints: []validation.Constraint{{Target: "resourceName", Name: validation.MaxLength, Rule: 63, Chain: nil}, + {Target: "resourceName", Name: validation.MinLength, Rule: 1, Chain: nil}, + {Target: "resourceName", Name: validation.Pattern, Rule: `^[a-zA-Z0-9]$|^[a-zA-Z0-9][-_a-zA-Z0-9]{0,61}[a-zA-Z0-9]$`, Chain: nil}}}}); err != nil { + return result, validation.NewError("extendedlocation.CustomLocationsClient", "FindTargetResourceGroup", err.Error()) + } + + req, err := client.FindTargetResourceGroupPreparer(ctx, resourceGroupName, resourceName, parameters) + if err != nil { + err = autorest.NewErrorWithError(err, "extendedlocation.CustomLocationsClient", "FindTargetResourceGroup", nil, "Failure preparing request") + return + } + + resp, err := client.FindTargetResourceGroupSender(req) + if err != nil { + result.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "extendedlocation.CustomLocationsClient", "FindTargetResourceGroup", resp, "Failure sending request") + return + } + + result, err = client.FindTargetResourceGroupResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "extendedlocation.CustomLocationsClient", "FindTargetResourceGroup", resp, "Failure responding to request") + return + } + + return +} + +// FindTargetResourceGroupPreparer prepares the FindTargetResourceGroup request. +func (client CustomLocationsClient) FindTargetResourceGroupPreparer(ctx context.Context, resourceGroupName string, resourceName string, parameters CustomLocationFindTargetResourceGroupProperties) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "resourceGroupName": autorest.Encode("path", resourceGroupName), + "resourceName": autorest.Encode("path", resourceName), + "subscriptionId": autorest.Encode("path", client.SubscriptionID), + } + + const APIVersion = "2021-08-31-preview" + queryParameters := map[string]interface{}{ + "api-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsContentType("application/json; charset=utf-8"), + autorest.AsPost(), + autorest.WithBaseURL(client.BaseURI), + autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ExtendedLocation/customLocations/{resourceName}/findTargetResourceGroup", pathParameters), + autorest.WithJSON(parameters), + autorest.WithQueryParameters(queryParameters)) + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// FindTargetResourceGroupSender sends the FindTargetResourceGroup request. The method will close the +// http.Response Body if it receives an error. +func (client CustomLocationsClient) FindTargetResourceGroupSender(req *http.Request) (*http.Response, error) { + return client.Send(req, azure.DoRetryWithRegistration(client.Client)) +} + +// FindTargetResourceGroupResponder handles the response to the FindTargetResourceGroup request. The method always +// closes the http.Response Body. +func (client CustomLocationsClient) FindTargetResourceGroupResponder(resp *http.Response) (result CustomLocationFindTargetResourceGroupResult, err error) { + err = autorest.Respond( + resp, + azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNoContent), + autorest.ByUnmarshallingJSON(&result), + autorest.ByClosing()) + result.Response = autorest.Response{Response: resp} + return +} + +// Get gets the details of the customLocation with a specified resource group and name. +// Parameters: +// resourceGroupName - the name of the resource group. The name is case insensitive. +// resourceName - custom Locations name. +func (client CustomLocationsClient) Get(ctx context.Context, resourceGroupName string, resourceName string) (result CustomLocation, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/CustomLocationsClient.Get") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } + if err := validation.Validate([]validation.Validation{ + {TargetValue: client.SubscriptionID, + Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, + {TargetValue: resourceGroupName, + Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, + {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}}}, + {TargetValue: resourceName, + Constraints: []validation.Constraint{{Target: "resourceName", Name: validation.MaxLength, Rule: 63, Chain: nil}, + {Target: "resourceName", Name: validation.MinLength, Rule: 1, Chain: nil}, + {Target: "resourceName", Name: validation.Pattern, Rule: `^[a-zA-Z0-9]$|^[a-zA-Z0-9][-_a-zA-Z0-9]{0,61}[a-zA-Z0-9]$`, Chain: nil}}}}); err != nil { + return result, validation.NewError("extendedlocation.CustomLocationsClient", "Get", err.Error()) + } + + req, err := client.GetPreparer(ctx, resourceGroupName, resourceName) + if err != nil { + err = autorest.NewErrorWithError(err, "extendedlocation.CustomLocationsClient", "Get", nil, "Failure preparing request") + return + } + + resp, err := client.GetSender(req) + if err != nil { + result.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "extendedlocation.CustomLocationsClient", "Get", resp, "Failure sending request") + return + } + + result, err = client.GetResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "extendedlocation.CustomLocationsClient", "Get", resp, "Failure responding to request") + return + } + + return +} + +// GetPreparer prepares the Get request. +func (client CustomLocationsClient) GetPreparer(ctx context.Context, resourceGroupName string, resourceName string) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "resourceGroupName": autorest.Encode("path", resourceGroupName), + "resourceName": autorest.Encode("path", resourceName), + "subscriptionId": autorest.Encode("path", client.SubscriptionID), + } + + const APIVersion = "2021-08-31-preview" + queryParameters := map[string]interface{}{ + "api-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsGet(), + autorest.WithBaseURL(client.BaseURI), + autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ExtendedLocation/customLocations/{resourceName}", pathParameters), + autorest.WithQueryParameters(queryParameters)) + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// GetSender sends the Get request. The method will close the +// http.Response Body if it receives an error. +func (client CustomLocationsClient) GetSender(req *http.Request) (*http.Response, error) { + return client.Send(req, azure.DoRetryWithRegistration(client.Client)) +} + +// GetResponder handles the response to the Get request. The method always +// closes the http.Response Body. +func (client CustomLocationsClient) GetResponder(resp *http.Response) (result CustomLocation, err error) { + err = autorest.Respond( + resp, + azure.WithErrorUnlessStatusCode(http.StatusOK), + autorest.ByUnmarshallingJSON(&result), + autorest.ByClosing()) + result.Response = autorest.Response{Response: resp} + return +} + +// ListByResourceGroup gets a list of Custom Locations in the specified subscription and resource group. The operation +// returns properties of each Custom Location. +// Parameters: +// resourceGroupName - the name of the resource group. The name is case insensitive. +func (client CustomLocationsClient) ListByResourceGroup(ctx context.Context, resourceGroupName string) (result CustomLocationListResultPage, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/CustomLocationsClient.ListByResourceGroup") + defer func() { + sc := -1 + if result.cllr.Response.Response != nil { + sc = result.cllr.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } + if err := validation.Validate([]validation.Validation{ + {TargetValue: client.SubscriptionID, + Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, + {TargetValue: resourceGroupName, + Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, + {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}}}}); err != nil { + return result, validation.NewError("extendedlocation.CustomLocationsClient", "ListByResourceGroup", err.Error()) + } + + result.fn = client.listByResourceGroupNextResults + req, err := client.ListByResourceGroupPreparer(ctx, resourceGroupName) + if err != nil { + err = autorest.NewErrorWithError(err, "extendedlocation.CustomLocationsClient", "ListByResourceGroup", nil, "Failure preparing request") + return + } + + resp, err := client.ListByResourceGroupSender(req) + if err != nil { + result.cllr.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "extendedlocation.CustomLocationsClient", "ListByResourceGroup", resp, "Failure sending request") + return + } + + result.cllr, err = client.ListByResourceGroupResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "extendedlocation.CustomLocationsClient", "ListByResourceGroup", resp, "Failure responding to request") + return + } + if result.cllr.hasNextLink() && result.cllr.IsEmpty() { + err = result.NextWithContext(ctx) + return + } + + return +} + +// ListByResourceGroupPreparer prepares the ListByResourceGroup request. +func (client CustomLocationsClient) ListByResourceGroupPreparer(ctx context.Context, resourceGroupName string) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "resourceGroupName": autorest.Encode("path", resourceGroupName), + "subscriptionId": autorest.Encode("path", client.SubscriptionID), + } + + const APIVersion = "2021-08-31-preview" + queryParameters := map[string]interface{}{ + "api-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsGet(), + autorest.WithBaseURL(client.BaseURI), + autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ExtendedLocation/customLocations", pathParameters), + autorest.WithQueryParameters(queryParameters)) + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// ListByResourceGroupSender sends the ListByResourceGroup request. The method will close the +// http.Response Body if it receives an error. +func (client CustomLocationsClient) ListByResourceGroupSender(req *http.Request) (*http.Response, error) { + return client.Send(req, azure.DoRetryWithRegistration(client.Client)) +} + +// ListByResourceGroupResponder handles the response to the ListByResourceGroup request. The method always +// closes the http.Response Body. +func (client CustomLocationsClient) ListByResourceGroupResponder(resp *http.Response) (result CustomLocationListResult, err error) { + err = autorest.Respond( + resp, + azure.WithErrorUnlessStatusCode(http.StatusOK), + autorest.ByUnmarshallingJSON(&result), + autorest.ByClosing()) + result.Response = autorest.Response{Response: resp} + return +} + +// listByResourceGroupNextResults retrieves the next set of results, if any. +func (client CustomLocationsClient) listByResourceGroupNextResults(ctx context.Context, lastResults CustomLocationListResult) (result CustomLocationListResult, err error) { + req, err := lastResults.customLocationListResultPreparer(ctx) + if err != nil { + return result, autorest.NewErrorWithError(err, "extendedlocation.CustomLocationsClient", "listByResourceGroupNextResults", nil, "Failure preparing next results request") + } + if req == nil { + return + } + resp, err := client.ListByResourceGroupSender(req) + if err != nil { + result.Response = autorest.Response{Response: resp} + return result, autorest.NewErrorWithError(err, "extendedlocation.CustomLocationsClient", "listByResourceGroupNextResults", resp, "Failure sending next results request") + } + result, err = client.ListByResourceGroupResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "extendedlocation.CustomLocationsClient", "listByResourceGroupNextResults", resp, "Failure responding to next results request") + } + return +} + +// ListByResourceGroupComplete enumerates all values, automatically crossing page boundaries as required. +func (client CustomLocationsClient) ListByResourceGroupComplete(ctx context.Context, resourceGroupName string) (result CustomLocationListResultIterator, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/CustomLocationsClient.ListByResourceGroup") + defer func() { + sc := -1 + if result.Response().Response.Response != nil { + sc = result.page.Response().Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } + result.page, err = client.ListByResourceGroup(ctx, resourceGroupName) + return +} + +// ListBySubscription gets a list of Custom Locations in the specified subscription. The operation returns properties +// of each Custom Location +func (client CustomLocationsClient) ListBySubscription(ctx context.Context) (result CustomLocationListResultPage, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/CustomLocationsClient.ListBySubscription") + defer func() { + sc := -1 + if result.cllr.Response.Response != nil { + sc = result.cllr.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } + if err := validation.Validate([]validation.Validation{ + {TargetValue: client.SubscriptionID, + Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}}); err != nil { + return result, validation.NewError("extendedlocation.CustomLocationsClient", "ListBySubscription", err.Error()) + } + + result.fn = client.listBySubscriptionNextResults + req, err := client.ListBySubscriptionPreparer(ctx) + if err != nil { + err = autorest.NewErrorWithError(err, "extendedlocation.CustomLocationsClient", "ListBySubscription", nil, "Failure preparing request") + return + } + + resp, err := client.ListBySubscriptionSender(req) + if err != nil { + result.cllr.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "extendedlocation.CustomLocationsClient", "ListBySubscription", resp, "Failure sending request") + return + } + + result.cllr, err = client.ListBySubscriptionResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "extendedlocation.CustomLocationsClient", "ListBySubscription", resp, "Failure responding to request") + return + } + if result.cllr.hasNextLink() && result.cllr.IsEmpty() { + err = result.NextWithContext(ctx) + return + } + + return +} + +// ListBySubscriptionPreparer prepares the ListBySubscription request. +func (client CustomLocationsClient) ListBySubscriptionPreparer(ctx context.Context) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "subscriptionId": autorest.Encode("path", client.SubscriptionID), + } + + const APIVersion = "2021-08-31-preview" + queryParameters := map[string]interface{}{ + "api-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsGet(), + autorest.WithBaseURL(client.BaseURI), + autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.ExtendedLocation/customLocations", pathParameters), + autorest.WithQueryParameters(queryParameters)) + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// ListBySubscriptionSender sends the ListBySubscription request. The method will close the +// http.Response Body if it receives an error. +func (client CustomLocationsClient) ListBySubscriptionSender(req *http.Request) (*http.Response, error) { + return client.Send(req, azure.DoRetryWithRegistration(client.Client)) +} + +// ListBySubscriptionResponder handles the response to the ListBySubscription request. The method always +// closes the http.Response Body. +func (client CustomLocationsClient) ListBySubscriptionResponder(resp *http.Response) (result CustomLocationListResult, err error) { + err = autorest.Respond( + resp, + azure.WithErrorUnlessStatusCode(http.StatusOK), + autorest.ByUnmarshallingJSON(&result), + autorest.ByClosing()) + result.Response = autorest.Response{Response: resp} + return +} + +// listBySubscriptionNextResults retrieves the next set of results, if any. +func (client CustomLocationsClient) listBySubscriptionNextResults(ctx context.Context, lastResults CustomLocationListResult) (result CustomLocationListResult, err error) { + req, err := lastResults.customLocationListResultPreparer(ctx) + if err != nil { + return result, autorest.NewErrorWithError(err, "extendedlocation.CustomLocationsClient", "listBySubscriptionNextResults", nil, "Failure preparing next results request") + } + if req == nil { + return + } + resp, err := client.ListBySubscriptionSender(req) + if err != nil { + result.Response = autorest.Response{Response: resp} + return result, autorest.NewErrorWithError(err, "extendedlocation.CustomLocationsClient", "listBySubscriptionNextResults", resp, "Failure sending next results request") + } + result, err = client.ListBySubscriptionResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "extendedlocation.CustomLocationsClient", "listBySubscriptionNextResults", resp, "Failure responding to next results request") + } + return +} + +// ListBySubscriptionComplete enumerates all values, automatically crossing page boundaries as required. +func (client CustomLocationsClient) ListBySubscriptionComplete(ctx context.Context) (result CustomLocationListResultIterator, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/CustomLocationsClient.ListBySubscription") + defer func() { + sc := -1 + if result.Response().Response.Response != nil { + sc = result.page.Response().Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } + result.page, err = client.ListBySubscription(ctx) + return +} + +// ListEnabledResourceTypes gets the list of the Enabled Resource Types. +// Parameters: +// resourceGroupName - the name of the resource group. The name is case insensitive. +// resourceName - custom Locations name. +func (client CustomLocationsClient) ListEnabledResourceTypes(ctx context.Context, resourceGroupName string, resourceName string) (result EnabledResourceTypesListResultPage, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/CustomLocationsClient.ListEnabledResourceTypes") + defer func() { + sc := -1 + if result.ertlr.Response.Response != nil { + sc = result.ertlr.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } + if err := validation.Validate([]validation.Validation{ + {TargetValue: client.SubscriptionID, + Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, + {TargetValue: resourceGroupName, + Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, + {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}}}, + {TargetValue: resourceName, + Constraints: []validation.Constraint{{Target: "resourceName", Name: validation.MaxLength, Rule: 63, Chain: nil}, + {Target: "resourceName", Name: validation.MinLength, Rule: 1, Chain: nil}, + {Target: "resourceName", Name: validation.Pattern, Rule: `^[a-zA-Z0-9]$|^[a-zA-Z0-9][-_a-zA-Z0-9]{0,61}[a-zA-Z0-9]$`, Chain: nil}}}}); err != nil { + return result, validation.NewError("extendedlocation.CustomLocationsClient", "ListEnabledResourceTypes", err.Error()) + } + + result.fn = client.listEnabledResourceTypesNextResults + req, err := client.ListEnabledResourceTypesPreparer(ctx, resourceGroupName, resourceName) + if err != nil { + err = autorest.NewErrorWithError(err, "extendedlocation.CustomLocationsClient", "ListEnabledResourceTypes", nil, "Failure preparing request") + return + } + + resp, err := client.ListEnabledResourceTypesSender(req) + if err != nil { + result.ertlr.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "extendedlocation.CustomLocationsClient", "ListEnabledResourceTypes", resp, "Failure sending request") + return + } + + result.ertlr, err = client.ListEnabledResourceTypesResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "extendedlocation.CustomLocationsClient", "ListEnabledResourceTypes", resp, "Failure responding to request") + return + } + if result.ertlr.hasNextLink() && result.ertlr.IsEmpty() { + err = result.NextWithContext(ctx) + return + } + + return +} + +// ListEnabledResourceTypesPreparer prepares the ListEnabledResourceTypes request. +func (client CustomLocationsClient) ListEnabledResourceTypesPreparer(ctx context.Context, resourceGroupName string, resourceName string) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "resourceGroupName": autorest.Encode("path", resourceGroupName), + "resourceName": autorest.Encode("path", resourceName), + "subscriptionId": autorest.Encode("path", client.SubscriptionID), + } + + const APIVersion = "2021-08-31-preview" + queryParameters := map[string]interface{}{ + "api-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsGet(), + autorest.WithBaseURL(client.BaseURI), + autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ExtendedLocation/customLocations/{resourceName}/enabledResourceTypes", pathParameters), + autorest.WithQueryParameters(queryParameters)) + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// ListEnabledResourceTypesSender sends the ListEnabledResourceTypes request. The method will close the +// http.Response Body if it receives an error. +func (client CustomLocationsClient) ListEnabledResourceTypesSender(req *http.Request) (*http.Response, error) { + return client.Send(req, azure.DoRetryWithRegistration(client.Client)) +} + +// ListEnabledResourceTypesResponder handles the response to the ListEnabledResourceTypes request. The method always +// closes the http.Response Body. +func (client CustomLocationsClient) ListEnabledResourceTypesResponder(resp *http.Response) (result EnabledResourceTypesListResult, err error) { + err = autorest.Respond( + resp, + azure.WithErrorUnlessStatusCode(http.StatusOK), + autorest.ByUnmarshallingJSON(&result), + autorest.ByClosing()) + result.Response = autorest.Response{Response: resp} + return +} + +// listEnabledResourceTypesNextResults retrieves the next set of results, if any. +func (client CustomLocationsClient) listEnabledResourceTypesNextResults(ctx context.Context, lastResults EnabledResourceTypesListResult) (result EnabledResourceTypesListResult, err error) { + req, err := lastResults.enabledResourceTypesListResultPreparer(ctx) + if err != nil { + return result, autorest.NewErrorWithError(err, "extendedlocation.CustomLocationsClient", "listEnabledResourceTypesNextResults", nil, "Failure preparing next results request") + } + if req == nil { + return + } + resp, err := client.ListEnabledResourceTypesSender(req) + if err != nil { + result.Response = autorest.Response{Response: resp} + return result, autorest.NewErrorWithError(err, "extendedlocation.CustomLocationsClient", "listEnabledResourceTypesNextResults", resp, "Failure sending next results request") + } + result, err = client.ListEnabledResourceTypesResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "extendedlocation.CustomLocationsClient", "listEnabledResourceTypesNextResults", resp, "Failure responding to next results request") + } + return +} + +// ListEnabledResourceTypesComplete enumerates all values, automatically crossing page boundaries as required. +func (client CustomLocationsClient) ListEnabledResourceTypesComplete(ctx context.Context, resourceGroupName string, resourceName string) (result EnabledResourceTypesListResultIterator, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/CustomLocationsClient.ListEnabledResourceTypes") + defer func() { + sc := -1 + if result.Response().Response.Response != nil { + sc = result.page.Response().Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } + result.page, err = client.ListEnabledResourceTypes(ctx, resourceGroupName, resourceName) + return +} + +// ListOperations lists all available Custom Locations operations. +func (client CustomLocationsClient) ListOperations(ctx context.Context) (result CustomLocationOperationsListPage, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/CustomLocationsClient.ListOperations") + defer func() { + sc := -1 + if result.clol.Response.Response != nil { + sc = result.clol.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } + result.fn = client.listOperationsNextResults + req, err := client.ListOperationsPreparer(ctx) + if err != nil { + err = autorest.NewErrorWithError(err, "extendedlocation.CustomLocationsClient", "ListOperations", nil, "Failure preparing request") + return + } + + resp, err := client.ListOperationsSender(req) + if err != nil { + result.clol.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "extendedlocation.CustomLocationsClient", "ListOperations", resp, "Failure sending request") + return + } + + result.clol, err = client.ListOperationsResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "extendedlocation.CustomLocationsClient", "ListOperations", resp, "Failure responding to request") + return + } + if result.clol.hasNextLink() && result.clol.IsEmpty() { + err = result.NextWithContext(ctx) + return + } + + return +} + +// ListOperationsPreparer prepares the ListOperations request. +func (client CustomLocationsClient) ListOperationsPreparer(ctx context.Context) (*http.Request, error) { + const APIVersion = "2021-08-31-preview" + queryParameters := map[string]interface{}{ + "api-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsGet(), + autorest.WithBaseURL(client.BaseURI), + autorest.WithPath("/providers/Microsoft.ExtendedLocation/operations"), + autorest.WithQueryParameters(queryParameters)) + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// ListOperationsSender sends the ListOperations request. The method will close the +// http.Response Body if it receives an error. +func (client CustomLocationsClient) ListOperationsSender(req *http.Request) (*http.Response, error) { + return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) +} + +// ListOperationsResponder handles the response to the ListOperations request. The method always +// closes the http.Response Body. +func (client CustomLocationsClient) ListOperationsResponder(resp *http.Response) (result CustomLocationOperationsList, err error) { + err = autorest.Respond( + resp, + azure.WithErrorUnlessStatusCode(http.StatusOK), + autorest.ByUnmarshallingJSON(&result), + autorest.ByClosing()) + result.Response = autorest.Response{Response: resp} + return +} + +// listOperationsNextResults retrieves the next set of results, if any. +func (client CustomLocationsClient) listOperationsNextResults(ctx context.Context, lastResults CustomLocationOperationsList) (result CustomLocationOperationsList, err error) { + req, err := lastResults.customLocationOperationsListPreparer(ctx) + if err != nil { + return result, autorest.NewErrorWithError(err, "extendedlocation.CustomLocationsClient", "listOperationsNextResults", nil, "Failure preparing next results request") + } + if req == nil { + return + } + resp, err := client.ListOperationsSender(req) + if err != nil { + result.Response = autorest.Response{Response: resp} + return result, autorest.NewErrorWithError(err, "extendedlocation.CustomLocationsClient", "listOperationsNextResults", resp, "Failure sending next results request") + } + result, err = client.ListOperationsResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "extendedlocation.CustomLocationsClient", "listOperationsNextResults", resp, "Failure responding to next results request") + } + return +} + +// ListOperationsComplete enumerates all values, automatically crossing page boundaries as required. +func (client CustomLocationsClient) ListOperationsComplete(ctx context.Context) (result CustomLocationOperationsListIterator, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/CustomLocationsClient.ListOperations") + defer func() { + sc := -1 + if result.Response().Response.Response != nil { + sc = result.page.Response().Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } + result.page, err = client.ListOperations(ctx) + return +} + +// Update updates a Custom Location with the specified Resource Name in the specified Resource Group and Subscription. +// Parameters: +// resourceGroupName - the name of the resource group. The name is case insensitive. +// resourceName - custom Locations name. +// parameters - the updatable fields of an existing Custom Location. +func (client CustomLocationsClient) Update(ctx context.Context, resourceGroupName string, resourceName string, parameters PatchableCustomLocations) (result CustomLocation, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/CustomLocationsClient.Update") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } + if err := validation.Validate([]validation.Validation{ + {TargetValue: client.SubscriptionID, + Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, + {TargetValue: resourceGroupName, + Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, + {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}}}, + {TargetValue: resourceName, + Constraints: []validation.Constraint{{Target: "resourceName", Name: validation.MaxLength, Rule: 63, Chain: nil}, + {Target: "resourceName", Name: validation.MinLength, Rule: 1, Chain: nil}, + {Target: "resourceName", Name: validation.Pattern, Rule: `^[a-zA-Z0-9]$|^[a-zA-Z0-9][-_a-zA-Z0-9]{0,61}[a-zA-Z0-9]$`, Chain: nil}}}}); err != nil { + return result, validation.NewError("extendedlocation.CustomLocationsClient", "Update", err.Error()) + } + + req, err := client.UpdatePreparer(ctx, resourceGroupName, resourceName, parameters) + if err != nil { + err = autorest.NewErrorWithError(err, "extendedlocation.CustomLocationsClient", "Update", nil, "Failure preparing request") + return + } + + resp, err := client.UpdateSender(req) + if err != nil { + result.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "extendedlocation.CustomLocationsClient", "Update", resp, "Failure sending request") + return + } + + result, err = client.UpdateResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "extendedlocation.CustomLocationsClient", "Update", resp, "Failure responding to request") + return + } + + return +} + +// UpdatePreparer prepares the Update request. +func (client CustomLocationsClient) UpdatePreparer(ctx context.Context, resourceGroupName string, resourceName string, parameters PatchableCustomLocations) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "resourceGroupName": autorest.Encode("path", resourceGroupName), + "resourceName": autorest.Encode("path", resourceName), + "subscriptionId": autorest.Encode("path", client.SubscriptionID), + } + + const APIVersion = "2021-08-31-preview" + queryParameters := map[string]interface{}{ + "api-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsContentType("application/json; charset=utf-8"), + autorest.AsPatch(), + autorest.WithBaseURL(client.BaseURI), + autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ExtendedLocation/customLocations/{resourceName}", pathParameters), + autorest.WithJSON(parameters), + autorest.WithQueryParameters(queryParameters)) + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// UpdateSender sends the Update request. The method will close the +// http.Response Body if it receives an error. +func (client CustomLocationsClient) UpdateSender(req *http.Request) (*http.Response, error) { + return client.Send(req, azure.DoRetryWithRegistration(client.Client)) +} + +// UpdateResponder handles the response to the Update request. The method always +// closes the http.Response Body. +func (client CustomLocationsClient) UpdateResponder(resp *http.Response) (result CustomLocation, err error) { + err = autorest.Respond( + resp, + azure.WithErrorUnlessStatusCode(http.StatusOK), + autorest.ByUnmarshallingJSON(&result), + autorest.ByClosing()) + result.Response = autorest.Response{Response: resp} + return +} diff --git a/services/preview/extendedlocation/mgmt/2021-08-31-preview/extendedlocation/enums.go b/services/preview/extendedlocation/mgmt/2021-08-31-preview/extendedlocation/enums.go new file mode 100644 index 000000000000..1e1ad4c6496a --- /dev/null +++ b/services/preview/extendedlocation/mgmt/2021-08-31-preview/extendedlocation/enums.go @@ -0,0 +1,54 @@ +package extendedlocation + +// Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT License. See License.txt in the project root for license information. +// +// Code generated by Microsoft (R) AutoRest Code Generator. +// Changes may cause incorrect behavior and will be lost if the code is regenerated. + +// CreatedByType enumerates the values for created by type. +type CreatedByType string + +const ( + // Application ... + Application CreatedByType = "Application" + // Key ... + Key CreatedByType = "Key" + // ManagedIdentity ... + ManagedIdentity CreatedByType = "ManagedIdentity" + // User ... + User CreatedByType = "User" +) + +// PossibleCreatedByTypeValues returns an array of possible values for the CreatedByType const type. +func PossibleCreatedByTypeValues() []CreatedByType { + return []CreatedByType{Application, Key, ManagedIdentity, User} +} + +// HostType enumerates the values for host type. +type HostType string + +const ( + // Kubernetes ... + Kubernetes HostType = "Kubernetes" +) + +// PossibleHostTypeValues returns an array of possible values for the HostType const type. +func PossibleHostTypeValues() []HostType { + return []HostType{Kubernetes} +} + +// ResourceIdentityType enumerates the values for resource identity type. +type ResourceIdentityType string + +const ( + // None ... + None ResourceIdentityType = "None" + // SystemAssigned ... + SystemAssigned ResourceIdentityType = "SystemAssigned" +) + +// PossibleResourceIdentityTypeValues returns an array of possible values for the ResourceIdentityType const type. +func PossibleResourceIdentityTypeValues() []ResourceIdentityType { + return []ResourceIdentityType{None, SystemAssigned} +} diff --git a/services/preview/extendedlocation/mgmt/2021-08-31-preview/extendedlocation/extendedlocationapi/interfaces.go b/services/preview/extendedlocation/mgmt/2021-08-31-preview/extendedlocation/extendedlocationapi/interfaces.go new file mode 100644 index 000000000000..08d45b286859 --- /dev/null +++ b/services/preview/extendedlocation/mgmt/2021-08-31-preview/extendedlocation/extendedlocationapi/interfaces.go @@ -0,0 +1,44 @@ +package extendedlocationapi + +// Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT License. See License.txt in the project root for license information. +// +// Code generated by Microsoft (R) AutoRest Code Generator. +// Changes may cause incorrect behavior and will be lost if the code is regenerated. + +import ( + "context" + "github.com/Azure/azure-sdk-for-go/services/preview/extendedlocation/mgmt/2021-08-31-preview/extendedlocation" + "github.com/Azure/go-autorest/autorest" +) + +// CustomLocationsClientAPI contains the set of methods on the CustomLocationsClient type. +type CustomLocationsClientAPI interface { + CreateOrUpdate(ctx context.Context, resourceGroupName string, resourceName string, parameters extendedlocation.CustomLocation) (result extendedlocation.CustomLocationsCreateOrUpdateFuture, err error) + Delete(ctx context.Context, resourceGroupName string, resourceName string) (result extendedlocation.CustomLocationsDeleteFuture, err error) + FindTargetResourceGroup(ctx context.Context, resourceGroupName string, resourceName string, parameters extendedlocation.CustomLocationFindTargetResourceGroupProperties) (result extendedlocation.CustomLocationFindTargetResourceGroupResult, err error) + Get(ctx context.Context, resourceGroupName string, resourceName string) (result extendedlocation.CustomLocation, err error) + ListByResourceGroup(ctx context.Context, resourceGroupName string) (result extendedlocation.CustomLocationListResultPage, err error) + ListByResourceGroupComplete(ctx context.Context, resourceGroupName string) (result extendedlocation.CustomLocationListResultIterator, err error) + ListBySubscription(ctx context.Context) (result extendedlocation.CustomLocationListResultPage, err error) + ListBySubscriptionComplete(ctx context.Context) (result extendedlocation.CustomLocationListResultIterator, err error) + ListEnabledResourceTypes(ctx context.Context, resourceGroupName string, resourceName string) (result extendedlocation.EnabledResourceTypesListResultPage, err error) + ListEnabledResourceTypesComplete(ctx context.Context, resourceGroupName string, resourceName string) (result extendedlocation.EnabledResourceTypesListResultIterator, err error) + ListOperations(ctx context.Context) (result extendedlocation.CustomLocationOperationsListPage, err error) + ListOperationsComplete(ctx context.Context) (result extendedlocation.CustomLocationOperationsListIterator, err error) + Update(ctx context.Context, resourceGroupName string, resourceName string, parameters extendedlocation.PatchableCustomLocations) (result extendedlocation.CustomLocation, err error) +} + +var _ CustomLocationsClientAPI = (*extendedlocation.CustomLocationsClient)(nil) + +// ResourceSyncRulesClientAPI contains the set of methods on the ResourceSyncRulesClient type. +type ResourceSyncRulesClientAPI interface { + CreateOrUpdate(ctx context.Context, resourceGroupName string, resourceName string, childResourceName string, parameters extendedlocation.ResourceSyncRule) (result extendedlocation.ResourceSyncRulesCreateOrUpdateFuture, err error) + Delete(ctx context.Context, resourceGroupName string, resourceName string, childResourceName string) (result autorest.Response, err error) + Get(ctx context.Context, resourceGroupName string, resourceName string, childResourceName string) (result extendedlocation.ResourceSyncRule, err error) + ListByCustomLocationID(ctx context.Context, resourceGroupName string, resourceName string) (result extendedlocation.ResourceSyncRuleListResultPage, err error) + ListByCustomLocationIDComplete(ctx context.Context, resourceGroupName string, resourceName string) (result extendedlocation.ResourceSyncRuleListResultIterator, err error) + Update(ctx context.Context, resourceGroupName string, resourceName string, childResourceName string, parameters extendedlocation.PatchableResourceSyncRule) (result extendedlocation.ResourceSyncRulesUpdateFuture, err error) +} + +var _ ResourceSyncRulesClientAPI = (*extendedlocation.ResourceSyncRulesClient)(nil) diff --git a/services/preview/extendedlocation/mgmt/2021-08-31-preview/extendedlocation/models.go b/services/preview/extendedlocation/mgmt/2021-08-31-preview/extendedlocation/models.go new file mode 100644 index 000000000000..e20d9160f540 --- /dev/null +++ b/services/preview/extendedlocation/mgmt/2021-08-31-preview/extendedlocation/models.go @@ -0,0 +1,1673 @@ +package extendedlocation + +// Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT License. See License.txt in the project root for license information. +// +// Code generated by Microsoft (R) AutoRest Code Generator. +// Changes may cause incorrect behavior and will be lost if the code is regenerated. + +import ( + "context" + "encoding/json" + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/autorest/date" + "github.com/Azure/go-autorest/autorest/to" + "github.com/Azure/go-autorest/tracing" + "net/http" +) + +// The package's fully qualified name. +const fqdn = "github.com/Azure/azure-sdk-for-go/services/preview/extendedlocation/mgmt/2021-08-31-preview/extendedlocation" + +// AzureEntityResource the resource model definition for an Azure Resource Manager resource with an etag. +type AzureEntityResource struct { + // Etag - READ-ONLY; Resource Etag. + Etag *string `json:"etag,omitempty"` + // ID - READ-ONLY; Fully qualified resource ID for the resource. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName} + ID *string `json:"id,omitempty"` + // Name - READ-ONLY; The name of the resource + Name *string `json:"name,omitempty"` + // Type - READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts" + Type *string `json:"type,omitempty"` +} + +// MarshalJSON is the custom marshaler for AzureEntityResource. +func (aer AzureEntityResource) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + return json.Marshal(objectMap) +} + +// CustomLocation custom Locations definition. +type CustomLocation struct { + autorest.Response `json:"-"` + // Identity - Identity for the resource. + Identity *Identity `json:"identity,omitempty"` + // CustomLocationProperties - The set of properties specific to a Custom Location + *CustomLocationProperties `json:"properties,omitempty"` + // SystemData - READ-ONLY; Metadata pertaining to creation and last modification of the resource + SystemData *SystemData `json:"systemData,omitempty"` + // Tags - Resource tags. + Tags map[string]*string `json:"tags"` + // Location - The geo-location where the resource lives + Location *string `json:"location,omitempty"` + // ID - READ-ONLY; Fully qualified resource ID for the resource. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName} + ID *string `json:"id,omitempty"` + // Name - READ-ONLY; The name of the resource + Name *string `json:"name,omitempty"` + // Type - READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts" + Type *string `json:"type,omitempty"` +} + +// MarshalJSON is the custom marshaler for CustomLocation. +func (cl CustomLocation) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + if cl.Identity != nil { + objectMap["identity"] = cl.Identity + } + if cl.CustomLocationProperties != nil { + objectMap["properties"] = cl.CustomLocationProperties + } + if cl.Tags != nil { + objectMap["tags"] = cl.Tags + } + if cl.Location != nil { + objectMap["location"] = cl.Location + } + return json.Marshal(objectMap) +} + +// UnmarshalJSON is the custom unmarshaler for CustomLocation struct. +func (cl *CustomLocation) UnmarshalJSON(body []byte) error { + var m map[string]*json.RawMessage + err := json.Unmarshal(body, &m) + if err != nil { + return err + } + for k, v := range m { + switch k { + case "identity": + if v != nil { + var identity Identity + err = json.Unmarshal(*v, &identity) + if err != nil { + return err + } + cl.Identity = &identity + } + case "properties": + if v != nil { + var customLocationProperties CustomLocationProperties + err = json.Unmarshal(*v, &customLocationProperties) + if err != nil { + return err + } + cl.CustomLocationProperties = &customLocationProperties + } + case "systemData": + if v != nil { + var systemData SystemData + err = json.Unmarshal(*v, &systemData) + if err != nil { + return err + } + cl.SystemData = &systemData + } + case "tags": + if v != nil { + var tags map[string]*string + err = json.Unmarshal(*v, &tags) + if err != nil { + return err + } + cl.Tags = tags + } + case "location": + if v != nil { + var location string + err = json.Unmarshal(*v, &location) + if err != nil { + return err + } + cl.Location = &location + } + case "id": + if v != nil { + var ID string + err = json.Unmarshal(*v, &ID) + if err != nil { + return err + } + cl.ID = &ID + } + case "name": + if v != nil { + var name string + err = json.Unmarshal(*v, &name) + if err != nil { + return err + } + cl.Name = &name + } + case "type": + if v != nil { + var typeVar string + err = json.Unmarshal(*v, &typeVar) + if err != nil { + return err + } + cl.Type = &typeVar + } + } + } + + return nil +} + +// CustomLocationFindTargetResourceGroupProperties the Find Target Resource Group operation request. +type CustomLocationFindTargetResourceGroupProperties struct { + // Labels - Labels of the custom resource, this is a map of {key,value} pairs. + Labels map[string]*string `json:"labels"` +} + +// MarshalJSON is the custom marshaler for CustomLocationFindTargetResourceGroupProperties. +func (clftrgp CustomLocationFindTargetResourceGroupProperties) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + if clftrgp.Labels != nil { + objectMap["labels"] = clftrgp.Labels + } + return json.Marshal(objectMap) +} + +// CustomLocationFindTargetResourceGroupResult the Find Target Resource Group operation response. +type CustomLocationFindTargetResourceGroupResult struct { + autorest.Response `json:"-"` + // MatchedResourceSyncRule - READ-ONLY; The matching resource sync rule is the particular resource sync rule that matched the match expressions and labels and had lowest priority. This is the rule responsible for mapping the target resource to the target resource group. + MatchedResourceSyncRule *string `json:"matchedResourceSyncRule,omitempty"` + // TargetResourceGroup - READ-ONLY; The target resource group of matching resource sync rule. The labels from the request will be used to find out matching resource sync rule against the selector property of the resource sync rule. The one with highest priority will be returned if there are multiple matching rules. + TargetResourceGroup *string `json:"targetResourceGroup,omitempty"` +} + +// MarshalJSON is the custom marshaler for CustomLocationFindTargetResourceGroupResult. +func (clftrgr CustomLocationFindTargetResourceGroupResult) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + return json.Marshal(objectMap) +} + +// CustomLocationListResult the List Custom Locations operation response. +type CustomLocationListResult struct { + autorest.Response `json:"-"` + // NextLink - READ-ONLY; The URL to use for getting the next set of results. + NextLink *string `json:"nextLink,omitempty"` + // Value - READ-ONLY; The list of Custom Locations. + Value *[]CustomLocation `json:"value,omitempty"` +} + +// MarshalJSON is the custom marshaler for CustomLocationListResult. +func (cllr CustomLocationListResult) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + return json.Marshal(objectMap) +} + +// CustomLocationListResultIterator provides access to a complete listing of CustomLocation values. +type CustomLocationListResultIterator struct { + i int + page CustomLocationListResultPage +} + +// NextWithContext advances to the next value. If there was an error making +// the request the iterator does not advance and the error is returned. +func (iter *CustomLocationListResultIterator) NextWithContext(ctx context.Context) (err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/CustomLocationListResultIterator.NextWithContext") + defer func() { + sc := -1 + if iter.Response().Response.Response != nil { + sc = iter.Response().Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } + iter.i++ + if iter.i < len(iter.page.Values()) { + return nil + } + err = iter.page.NextWithContext(ctx) + if err != nil { + iter.i-- + return err + } + iter.i = 0 + return nil +} + +// Next advances to the next value. If there was an error making +// the request the iterator does not advance and the error is returned. +// Deprecated: Use NextWithContext() instead. +func (iter *CustomLocationListResultIterator) Next() error { + return iter.NextWithContext(context.Background()) +} + +// NotDone returns true if the enumeration should be started or is not yet complete. +func (iter CustomLocationListResultIterator) NotDone() bool { + return iter.page.NotDone() && iter.i < len(iter.page.Values()) +} + +// Response returns the raw server response from the last page request. +func (iter CustomLocationListResultIterator) Response() CustomLocationListResult { + return iter.page.Response() +} + +// Value returns the current value or a zero-initialized value if the +// iterator has advanced beyond the end of the collection. +func (iter CustomLocationListResultIterator) Value() CustomLocation { + if !iter.page.NotDone() { + return CustomLocation{} + } + return iter.page.Values()[iter.i] +} + +// Creates a new instance of the CustomLocationListResultIterator type. +func NewCustomLocationListResultIterator(page CustomLocationListResultPage) CustomLocationListResultIterator { + return CustomLocationListResultIterator{page: page} +} + +// IsEmpty returns true if the ListResult contains no values. +func (cllr CustomLocationListResult) IsEmpty() bool { + return cllr.Value == nil || len(*cllr.Value) == 0 +} + +// hasNextLink returns true if the NextLink is not empty. +func (cllr CustomLocationListResult) hasNextLink() bool { + return cllr.NextLink != nil && len(*cllr.NextLink) != 0 +} + +// customLocationListResultPreparer prepares a request to retrieve the next set of results. +// It returns nil if no more results exist. +func (cllr CustomLocationListResult) customLocationListResultPreparer(ctx context.Context) (*http.Request, error) { + if !cllr.hasNextLink() { + return nil, nil + } + return autorest.Prepare((&http.Request{}).WithContext(ctx), + autorest.AsJSON(), + autorest.AsGet(), + autorest.WithBaseURL(to.String(cllr.NextLink))) +} + +// CustomLocationListResultPage contains a page of CustomLocation values. +type CustomLocationListResultPage struct { + fn func(context.Context, CustomLocationListResult) (CustomLocationListResult, error) + cllr CustomLocationListResult +} + +// NextWithContext advances to the next page of values. If there was an error making +// the request the page does not advance and the error is returned. +func (page *CustomLocationListResultPage) NextWithContext(ctx context.Context) (err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/CustomLocationListResultPage.NextWithContext") + defer func() { + sc := -1 + if page.Response().Response.Response != nil { + sc = page.Response().Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } + for { + next, err := page.fn(ctx, page.cllr) + if err != nil { + return err + } + page.cllr = next + if !next.hasNextLink() || !next.IsEmpty() { + break + } + } + return nil +} + +// Next advances to the next page of values. If there was an error making +// the request the page does not advance and the error is returned. +// Deprecated: Use NextWithContext() instead. +func (page *CustomLocationListResultPage) Next() error { + return page.NextWithContext(context.Background()) +} + +// NotDone returns true if the page enumeration should be started or is not yet complete. +func (page CustomLocationListResultPage) NotDone() bool { + return !page.cllr.IsEmpty() +} + +// Response returns the raw server response from the last page request. +func (page CustomLocationListResultPage) Response() CustomLocationListResult { + return page.cllr +} + +// Values returns the slice of values for the current page or nil if there are no values. +func (page CustomLocationListResultPage) Values() []CustomLocation { + if page.cllr.IsEmpty() { + return nil + } + return *page.cllr.Value +} + +// Creates a new instance of the CustomLocationListResultPage type. +func NewCustomLocationListResultPage(cur CustomLocationListResult, getNextPage func(context.Context, CustomLocationListResult) (CustomLocationListResult, error)) CustomLocationListResultPage { + return CustomLocationListResultPage{ + fn: getNextPage, + cllr: cur, + } +} + +// CustomLocationOperation custom Locations operation. +type CustomLocationOperation struct { + // CustomLocationOperationValueDisplay - Describes the properties of a Custom Locations Operation Value Display. + *CustomLocationOperationValueDisplay `json:"display,omitempty"` + // IsDataAction - READ-ONLY; Is this Operation a data plane operation + IsDataAction *bool `json:"isDataAction,omitempty"` + // Name - READ-ONLY; The name of the compute operation. + Name *string `json:"name,omitempty"` + // Origin - READ-ONLY; The origin of the compute operation. + Origin *string `json:"origin,omitempty"` +} + +// MarshalJSON is the custom marshaler for CustomLocationOperation. +func (clo CustomLocationOperation) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + if clo.CustomLocationOperationValueDisplay != nil { + objectMap["display"] = clo.CustomLocationOperationValueDisplay + } + return json.Marshal(objectMap) +} + +// UnmarshalJSON is the custom unmarshaler for CustomLocationOperation struct. +func (clo *CustomLocationOperation) UnmarshalJSON(body []byte) error { + var m map[string]*json.RawMessage + err := json.Unmarshal(body, &m) + if err != nil { + return err + } + for k, v := range m { + switch k { + case "display": + if v != nil { + var customLocationOperationValueDisplay CustomLocationOperationValueDisplay + err = json.Unmarshal(*v, &customLocationOperationValueDisplay) + if err != nil { + return err + } + clo.CustomLocationOperationValueDisplay = &customLocationOperationValueDisplay + } + case "isDataAction": + if v != nil { + var isDataAction bool + err = json.Unmarshal(*v, &isDataAction) + if err != nil { + return err + } + clo.IsDataAction = &isDataAction + } + case "name": + if v != nil { + var name string + err = json.Unmarshal(*v, &name) + if err != nil { + return err + } + clo.Name = &name + } + case "origin": + if v != nil { + var origin string + err = json.Unmarshal(*v, &origin) + if err != nil { + return err + } + clo.Origin = &origin + } + } + } + + return nil +} + +// CustomLocationOperationsList lists of Custom Locations operations. +type CustomLocationOperationsList struct { + autorest.Response `json:"-"` + // NextLink - Next page of operations. + NextLink *string `json:"nextLink,omitempty"` + // Value - Array of customLocationOperation + Value *[]CustomLocationOperation `json:"value,omitempty"` +} + +// CustomLocationOperationsListIterator provides access to a complete listing of CustomLocationOperation +// values. +type CustomLocationOperationsListIterator struct { + i int + page CustomLocationOperationsListPage +} + +// NextWithContext advances to the next value. If there was an error making +// the request the iterator does not advance and the error is returned. +func (iter *CustomLocationOperationsListIterator) NextWithContext(ctx context.Context) (err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/CustomLocationOperationsListIterator.NextWithContext") + defer func() { + sc := -1 + if iter.Response().Response.Response != nil { + sc = iter.Response().Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } + iter.i++ + if iter.i < len(iter.page.Values()) { + return nil + } + err = iter.page.NextWithContext(ctx) + if err != nil { + iter.i-- + return err + } + iter.i = 0 + return nil +} + +// Next advances to the next value. If there was an error making +// the request the iterator does not advance and the error is returned. +// Deprecated: Use NextWithContext() instead. +func (iter *CustomLocationOperationsListIterator) Next() error { + return iter.NextWithContext(context.Background()) +} + +// NotDone returns true if the enumeration should be started or is not yet complete. +func (iter CustomLocationOperationsListIterator) NotDone() bool { + return iter.page.NotDone() && iter.i < len(iter.page.Values()) +} + +// Response returns the raw server response from the last page request. +func (iter CustomLocationOperationsListIterator) Response() CustomLocationOperationsList { + return iter.page.Response() +} + +// Value returns the current value or a zero-initialized value if the +// iterator has advanced beyond the end of the collection. +func (iter CustomLocationOperationsListIterator) Value() CustomLocationOperation { + if !iter.page.NotDone() { + return CustomLocationOperation{} + } + return iter.page.Values()[iter.i] +} + +// Creates a new instance of the CustomLocationOperationsListIterator type. +func NewCustomLocationOperationsListIterator(page CustomLocationOperationsListPage) CustomLocationOperationsListIterator { + return CustomLocationOperationsListIterator{page: page} +} + +// IsEmpty returns true if the ListResult contains no values. +func (clol CustomLocationOperationsList) IsEmpty() bool { + return clol.Value == nil || len(*clol.Value) == 0 +} + +// hasNextLink returns true if the NextLink is not empty. +func (clol CustomLocationOperationsList) hasNextLink() bool { + return clol.NextLink != nil && len(*clol.NextLink) != 0 +} + +// customLocationOperationsListPreparer prepares a request to retrieve the next set of results. +// It returns nil if no more results exist. +func (clol CustomLocationOperationsList) customLocationOperationsListPreparer(ctx context.Context) (*http.Request, error) { + if !clol.hasNextLink() { + return nil, nil + } + return autorest.Prepare((&http.Request{}).WithContext(ctx), + autorest.AsJSON(), + autorest.AsGet(), + autorest.WithBaseURL(to.String(clol.NextLink))) +} + +// CustomLocationOperationsListPage contains a page of CustomLocationOperation values. +type CustomLocationOperationsListPage struct { + fn func(context.Context, CustomLocationOperationsList) (CustomLocationOperationsList, error) + clol CustomLocationOperationsList +} + +// NextWithContext advances to the next page of values. If there was an error making +// the request the page does not advance and the error is returned. +func (page *CustomLocationOperationsListPage) NextWithContext(ctx context.Context) (err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/CustomLocationOperationsListPage.NextWithContext") + defer func() { + sc := -1 + if page.Response().Response.Response != nil { + sc = page.Response().Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } + for { + next, err := page.fn(ctx, page.clol) + if err != nil { + return err + } + page.clol = next + if !next.hasNextLink() || !next.IsEmpty() { + break + } + } + return nil +} + +// Next advances to the next page of values. If there was an error making +// the request the page does not advance and the error is returned. +// Deprecated: Use NextWithContext() instead. +func (page *CustomLocationOperationsListPage) Next() error { + return page.NextWithContext(context.Background()) +} + +// NotDone returns true if the page enumeration should be started or is not yet complete. +func (page CustomLocationOperationsListPage) NotDone() bool { + return !page.clol.IsEmpty() +} + +// Response returns the raw server response from the last page request. +func (page CustomLocationOperationsListPage) Response() CustomLocationOperationsList { + return page.clol +} + +// Values returns the slice of values for the current page or nil if there are no values. +func (page CustomLocationOperationsListPage) Values() []CustomLocationOperation { + if page.clol.IsEmpty() { + return nil + } + return *page.clol.Value +} + +// Creates a new instance of the CustomLocationOperationsListPage type. +func NewCustomLocationOperationsListPage(cur CustomLocationOperationsList, getNextPage func(context.Context, CustomLocationOperationsList) (CustomLocationOperationsList, error)) CustomLocationOperationsListPage { + return CustomLocationOperationsListPage{ + fn: getNextPage, + clol: cur, + } +} + +// CustomLocationOperationValueDisplay describes the properties of a Custom Locations Operation Value +// Display. +type CustomLocationOperationValueDisplay struct { + // Description - READ-ONLY; The description of the operation. + Description *string `json:"description,omitempty"` + // Operation - READ-ONLY; The display name of the compute operation. + Operation *string `json:"operation,omitempty"` + // Provider - READ-ONLY; The resource provider for the operation. + Provider *string `json:"provider,omitempty"` + // Resource - READ-ONLY; The display name of the resource the operation applies to. + Resource *string `json:"resource,omitempty"` +} + +// MarshalJSON is the custom marshaler for CustomLocationOperationValueDisplay. +func (clovd CustomLocationOperationValueDisplay) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + return json.Marshal(objectMap) +} + +// CustomLocationProperties properties for a custom location. +type CustomLocationProperties struct { + // Authentication - This is optional input that contains the authentication that should be used to generate the namespace. + Authentication *CustomLocationPropertiesAuthentication `json:"authentication,omitempty"` + // ClusterExtensionIds - Contains the reference to the add-on that contains charts to deploy CRDs and operators. + ClusterExtensionIds *[]string `json:"clusterExtensionIds,omitempty"` + // DisplayName - Display name for the Custom Locations location. + DisplayName *string `json:"displayName,omitempty"` + // HostResourceID - Connected Cluster or AKS Cluster. The Custom Locations RP will perform a checkAccess API for listAdminCredentials permissions. + HostResourceID *string `json:"hostResourceId,omitempty"` + // HostType - Type of host the Custom Locations is referencing (Kubernetes, etc...). Possible values include: 'Kubernetes' + HostType HostType `json:"hostType,omitempty"` + // Namespace - Kubernetes namespace that will be created on the specified cluster. + Namespace *string `json:"namespace,omitempty"` + // ProvisioningState - Provisioning State for the Custom Location. + ProvisioningState *string `json:"provisioningState,omitempty"` +} + +// CustomLocationPropertiesAuthentication this is optional input that contains the authentication that +// should be used to generate the namespace. +type CustomLocationPropertiesAuthentication struct { + // Type - The type of the Custom Locations authentication + Type *string `json:"type,omitempty"` + // Value - The kubeconfig value. + Value *string `json:"value,omitempty"` +} + +// CustomLocationsCreateOrUpdateFuture an abstraction for monitoring and retrieving the results of a +// long-running operation. +type CustomLocationsCreateOrUpdateFuture struct { + azure.FutureAPI + // Result returns the result of the asynchronous operation. + // If the operation has not completed it will return an error. + Result func(CustomLocationsClient) (CustomLocation, error) +} + +// UnmarshalJSON is the custom unmarshaller for CreateFuture. +func (future *CustomLocationsCreateOrUpdateFuture) UnmarshalJSON(body []byte) error { + var azFuture azure.Future + if err := json.Unmarshal(body, &azFuture); err != nil { + return err + } + future.FutureAPI = &azFuture + future.Result = future.result + return nil +} + +// result is the default implementation for CustomLocationsCreateOrUpdateFuture.Result. +func (future *CustomLocationsCreateOrUpdateFuture) result(client CustomLocationsClient) (cl CustomLocation, err error) { + var done bool + done, err = future.DoneWithContext(context.Background(), client) + if err != nil { + err = autorest.NewErrorWithError(err, "extendedlocation.CustomLocationsCreateOrUpdateFuture", "Result", future.Response(), "Polling failure") + return + } + if !done { + cl.Response.Response = future.Response() + err = azure.NewAsyncOpIncompleteError("extendedlocation.CustomLocationsCreateOrUpdateFuture") + return + } + sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) + if cl.Response.Response, err = future.GetResult(sender); err == nil && cl.Response.Response.StatusCode != http.StatusNoContent { + cl, err = client.CreateOrUpdateResponder(cl.Response.Response) + if err != nil { + err = autorest.NewErrorWithError(err, "extendedlocation.CustomLocationsCreateOrUpdateFuture", "Result", cl.Response.Response, "Failure responding to request") + } + } + return +} + +// CustomLocationsDeleteFuture an abstraction for monitoring and retrieving the results of a long-running +// operation. +type CustomLocationsDeleteFuture struct { + azure.FutureAPI + // Result returns the result of the asynchronous operation. + // If the operation has not completed it will return an error. + Result func(CustomLocationsClient) (autorest.Response, error) +} + +// UnmarshalJSON is the custom unmarshaller for CreateFuture. +func (future *CustomLocationsDeleteFuture) UnmarshalJSON(body []byte) error { + var azFuture azure.Future + if err := json.Unmarshal(body, &azFuture); err != nil { + return err + } + future.FutureAPI = &azFuture + future.Result = future.result + return nil +} + +// result is the default implementation for CustomLocationsDeleteFuture.Result. +func (future *CustomLocationsDeleteFuture) result(client CustomLocationsClient) (ar autorest.Response, err error) { + var done bool + done, err = future.DoneWithContext(context.Background(), client) + if err != nil { + err = autorest.NewErrorWithError(err, "extendedlocation.CustomLocationsDeleteFuture", "Result", future.Response(), "Polling failure") + return + } + if !done { + ar.Response = future.Response() + err = azure.NewAsyncOpIncompleteError("extendedlocation.CustomLocationsDeleteFuture") + return + } + ar.Response = future.Response() + return +} + +// EnabledResourceType enabledResourceType definition. +type EnabledResourceType struct { + // EnabledResourceTypeProperties - The set of properties for EnabledResourceType specific to a Custom Location + *EnabledResourceTypeProperties `json:"properties,omitempty"` + // SystemData - READ-ONLY; Metadata pertaining to creation and last modification of the resource + SystemData *SystemData `json:"systemData,omitempty"` + // ID - READ-ONLY; Fully qualified resource ID for the resource. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName} + ID *string `json:"id,omitempty"` + // Name - READ-ONLY; The name of the resource + Name *string `json:"name,omitempty"` + // Type - READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts" + Type *string `json:"type,omitempty"` +} + +// MarshalJSON is the custom marshaler for EnabledResourceType. +func (ert EnabledResourceType) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + if ert.EnabledResourceTypeProperties != nil { + objectMap["properties"] = ert.EnabledResourceTypeProperties + } + return json.Marshal(objectMap) +} + +// UnmarshalJSON is the custom unmarshaler for EnabledResourceType struct. +func (ert *EnabledResourceType) UnmarshalJSON(body []byte) error { + var m map[string]*json.RawMessage + err := json.Unmarshal(body, &m) + if err != nil { + return err + } + for k, v := range m { + switch k { + case "properties": + if v != nil { + var enabledResourceTypeProperties EnabledResourceTypeProperties + err = json.Unmarshal(*v, &enabledResourceTypeProperties) + if err != nil { + return err + } + ert.EnabledResourceTypeProperties = &enabledResourceTypeProperties + } + case "systemData": + if v != nil { + var systemData SystemData + err = json.Unmarshal(*v, &systemData) + if err != nil { + return err + } + ert.SystemData = &systemData + } + case "id": + if v != nil { + var ID string + err = json.Unmarshal(*v, &ID) + if err != nil { + return err + } + ert.ID = &ID + } + case "name": + if v != nil { + var name string + err = json.Unmarshal(*v, &name) + if err != nil { + return err + } + ert.Name = &name + } + case "type": + if v != nil { + var typeVar string + err = json.Unmarshal(*v, &typeVar) + if err != nil { + return err + } + ert.Type = &typeVar + } + } + } + + return nil +} + +// EnabledResourceTypeProperties properties for EnabledResourceType of a custom location. +type EnabledResourceTypeProperties struct { + // ClusterExtensionID - Cluster Extension ID + ClusterExtensionID *string `json:"clusterExtensionId,omitempty"` + // ExtensionType - Cluster Extension Type + ExtensionType *string `json:"extensionType,omitempty"` + // TypesMetadata - Metadata of the Resource Type + TypesMetadata *[]EnabledResourceTypePropertiesTypesMetadataItem `json:"typesMetadata,omitempty"` +} + +// EnabledResourceTypePropertiesTypesMetadataItem metadata of the Resource Type. +type EnabledResourceTypePropertiesTypesMetadataItem struct { + // APIVersion - Api Version of Resource Type + APIVersion *string `json:"apiVersion,omitempty"` + // ResourceProviderNamespace - Resource Provider Namespace of Resource Type + ResourceProviderNamespace *string `json:"resourceProviderNamespace,omitempty"` + // ResourceType - Resource Type + ResourceType *string `json:"resourceType,omitempty"` +} + +// EnabledResourceTypesListResult list of EnabledResourceTypes definition. +type EnabledResourceTypesListResult struct { + autorest.Response `json:"-"` + // NextLink - READ-ONLY; The URL to use for getting the next set of results. + NextLink *string `json:"nextLink,omitempty"` + // Value - READ-ONLY; The list of EnabledResourceTypes available for a customLocation. + Value *[]EnabledResourceType `json:"value,omitempty"` +} + +// MarshalJSON is the custom marshaler for EnabledResourceTypesListResult. +func (ertlr EnabledResourceTypesListResult) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + return json.Marshal(objectMap) +} + +// EnabledResourceTypesListResultIterator provides access to a complete listing of EnabledResourceType +// values. +type EnabledResourceTypesListResultIterator struct { + i int + page EnabledResourceTypesListResultPage +} + +// NextWithContext advances to the next value. If there was an error making +// the request the iterator does not advance and the error is returned. +func (iter *EnabledResourceTypesListResultIterator) NextWithContext(ctx context.Context) (err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/EnabledResourceTypesListResultIterator.NextWithContext") + defer func() { + sc := -1 + if iter.Response().Response.Response != nil { + sc = iter.Response().Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } + iter.i++ + if iter.i < len(iter.page.Values()) { + return nil + } + err = iter.page.NextWithContext(ctx) + if err != nil { + iter.i-- + return err + } + iter.i = 0 + return nil +} + +// Next advances to the next value. If there was an error making +// the request the iterator does not advance and the error is returned. +// Deprecated: Use NextWithContext() instead. +func (iter *EnabledResourceTypesListResultIterator) Next() error { + return iter.NextWithContext(context.Background()) +} + +// NotDone returns true if the enumeration should be started or is not yet complete. +func (iter EnabledResourceTypesListResultIterator) NotDone() bool { + return iter.page.NotDone() && iter.i < len(iter.page.Values()) +} + +// Response returns the raw server response from the last page request. +func (iter EnabledResourceTypesListResultIterator) Response() EnabledResourceTypesListResult { + return iter.page.Response() +} + +// Value returns the current value or a zero-initialized value if the +// iterator has advanced beyond the end of the collection. +func (iter EnabledResourceTypesListResultIterator) Value() EnabledResourceType { + if !iter.page.NotDone() { + return EnabledResourceType{} + } + return iter.page.Values()[iter.i] +} + +// Creates a new instance of the EnabledResourceTypesListResultIterator type. +func NewEnabledResourceTypesListResultIterator(page EnabledResourceTypesListResultPage) EnabledResourceTypesListResultIterator { + return EnabledResourceTypesListResultIterator{page: page} +} + +// IsEmpty returns true if the ListResult contains no values. +func (ertlr EnabledResourceTypesListResult) IsEmpty() bool { + return ertlr.Value == nil || len(*ertlr.Value) == 0 +} + +// hasNextLink returns true if the NextLink is not empty. +func (ertlr EnabledResourceTypesListResult) hasNextLink() bool { + return ertlr.NextLink != nil && len(*ertlr.NextLink) != 0 +} + +// enabledResourceTypesListResultPreparer prepares a request to retrieve the next set of results. +// It returns nil if no more results exist. +func (ertlr EnabledResourceTypesListResult) enabledResourceTypesListResultPreparer(ctx context.Context) (*http.Request, error) { + if !ertlr.hasNextLink() { + return nil, nil + } + return autorest.Prepare((&http.Request{}).WithContext(ctx), + autorest.AsJSON(), + autorest.AsGet(), + autorest.WithBaseURL(to.String(ertlr.NextLink))) +} + +// EnabledResourceTypesListResultPage contains a page of EnabledResourceType values. +type EnabledResourceTypesListResultPage struct { + fn func(context.Context, EnabledResourceTypesListResult) (EnabledResourceTypesListResult, error) + ertlr EnabledResourceTypesListResult +} + +// NextWithContext advances to the next page of values. If there was an error making +// the request the page does not advance and the error is returned. +func (page *EnabledResourceTypesListResultPage) NextWithContext(ctx context.Context) (err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/EnabledResourceTypesListResultPage.NextWithContext") + defer func() { + sc := -1 + if page.Response().Response.Response != nil { + sc = page.Response().Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } + for { + next, err := page.fn(ctx, page.ertlr) + if err != nil { + return err + } + page.ertlr = next + if !next.hasNextLink() || !next.IsEmpty() { + break + } + } + return nil +} + +// Next advances to the next page of values. If there was an error making +// the request the page does not advance and the error is returned. +// Deprecated: Use NextWithContext() instead. +func (page *EnabledResourceTypesListResultPage) Next() error { + return page.NextWithContext(context.Background()) +} + +// NotDone returns true if the page enumeration should be started or is not yet complete. +func (page EnabledResourceTypesListResultPage) NotDone() bool { + return !page.ertlr.IsEmpty() +} + +// Response returns the raw server response from the last page request. +func (page EnabledResourceTypesListResultPage) Response() EnabledResourceTypesListResult { + return page.ertlr +} + +// Values returns the slice of values for the current page or nil if there are no values. +func (page EnabledResourceTypesListResultPage) Values() []EnabledResourceType { + if page.ertlr.IsEmpty() { + return nil + } + return *page.ertlr.Value +} + +// Creates a new instance of the EnabledResourceTypesListResultPage type. +func NewEnabledResourceTypesListResultPage(cur EnabledResourceTypesListResult, getNextPage func(context.Context, EnabledResourceTypesListResult) (EnabledResourceTypesListResult, error)) EnabledResourceTypesListResultPage { + return EnabledResourceTypesListResultPage{ + fn: getNextPage, + ertlr: cur, + } +} + +// ErrorAdditionalInfo the resource management error additional info. +type ErrorAdditionalInfo struct { + // Type - READ-ONLY; The additional info type. + Type *string `json:"type,omitempty"` + // Info - READ-ONLY; The additional info. + Info interface{} `json:"info,omitempty"` +} + +// MarshalJSON is the custom marshaler for ErrorAdditionalInfo. +func (eai ErrorAdditionalInfo) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + return json.Marshal(objectMap) +} + +// ErrorDetail the error detail. +type ErrorDetail struct { + // Code - READ-ONLY; The error code. + Code *string `json:"code,omitempty"` + // Message - READ-ONLY; The error message. + Message *string `json:"message,omitempty"` + // Target - READ-ONLY; The error target. + Target *string `json:"target,omitempty"` + // Details - READ-ONLY; The error details. + Details *[]ErrorDetail `json:"details,omitempty"` + // AdditionalInfo - READ-ONLY; The error additional info. + AdditionalInfo *[]ErrorAdditionalInfo `json:"additionalInfo,omitempty"` +} + +// MarshalJSON is the custom marshaler for ErrorDetail. +func (ed ErrorDetail) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + return json.Marshal(objectMap) +} + +// 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.). +type ErrorResponse struct { + // Error - The error object. + Error *ErrorDetail `json:"error,omitempty"` +} + +// Identity identity for the resource. +type Identity struct { + // PrincipalID - READ-ONLY; The principal ID of resource identity. + PrincipalID *string `json:"principalId,omitempty"` + // TenantID - READ-ONLY; The tenant ID of resource. + TenantID *string `json:"tenantId,omitempty"` + // Type - The identity type. Possible values include: 'SystemAssigned', 'None' + Type ResourceIdentityType `json:"type,omitempty"` +} + +// MarshalJSON is the custom marshaler for Identity. +func (i Identity) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + if i.Type != "" { + objectMap["type"] = i.Type + } + return json.Marshal(objectMap) +} + +// MatchExpressionsProperties resource Sync Rules matchExpression property definition. +type MatchExpressionsProperties struct { + // Key - Key is the label key that the selector applies to. + Key *string `json:"key,omitempty"` + // Operator - The Operator field represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist. + Operator *string `json:"operator,omitempty"` + // Values - The label value + Values *[]string `json:"values,omitempty"` +} + +// PatchableCustomLocations the Custom Locations patchable resource definition. +type PatchableCustomLocations struct { + // Identity - Identity for the resource. + Identity *Identity `json:"identity,omitempty"` + // CustomLocationProperties - The Custom Locations patchable properties. + *CustomLocationProperties `json:"properties,omitempty"` + // Tags - Resource tags + Tags map[string]*string `json:"tags"` +} + +// MarshalJSON is the custom marshaler for PatchableCustomLocations. +func (pcl PatchableCustomLocations) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + if pcl.Identity != nil { + objectMap["identity"] = pcl.Identity + } + if pcl.CustomLocationProperties != nil { + objectMap["properties"] = pcl.CustomLocationProperties + } + if pcl.Tags != nil { + objectMap["tags"] = pcl.Tags + } + return json.Marshal(objectMap) +} + +// UnmarshalJSON is the custom unmarshaler for PatchableCustomLocations struct. +func (pcl *PatchableCustomLocations) UnmarshalJSON(body []byte) error { + var m map[string]*json.RawMessage + err := json.Unmarshal(body, &m) + if err != nil { + return err + } + for k, v := range m { + switch k { + case "identity": + if v != nil { + var identity Identity + err = json.Unmarshal(*v, &identity) + if err != nil { + return err + } + pcl.Identity = &identity + } + case "properties": + if v != nil { + var customLocationProperties CustomLocationProperties + err = json.Unmarshal(*v, &customLocationProperties) + if err != nil { + return err + } + pcl.CustomLocationProperties = &customLocationProperties + } + case "tags": + if v != nil { + var tags map[string]*string + err = json.Unmarshal(*v, &tags) + if err != nil { + return err + } + pcl.Tags = tags + } + } + } + + return nil +} + +// PatchableResourceSyncRule the Resource Sync Rules patchable resource definition. +type PatchableResourceSyncRule struct { + // ResourceSyncRuleProperties - The Resource Sync Rules patchable properties. + *ResourceSyncRuleProperties `json:"properties,omitempty"` + // Tags - Resource tags + Tags map[string]*string `json:"tags"` +} + +// MarshalJSON is the custom marshaler for PatchableResourceSyncRule. +func (prsr PatchableResourceSyncRule) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + if prsr.ResourceSyncRuleProperties != nil { + objectMap["properties"] = prsr.ResourceSyncRuleProperties + } + if prsr.Tags != nil { + objectMap["tags"] = prsr.Tags + } + return json.Marshal(objectMap) +} + +// UnmarshalJSON is the custom unmarshaler for PatchableResourceSyncRule struct. +func (prsr *PatchableResourceSyncRule) UnmarshalJSON(body []byte) error { + var m map[string]*json.RawMessage + err := json.Unmarshal(body, &m) + if err != nil { + return err + } + for k, v := range m { + switch k { + case "properties": + if v != nil { + var resourceSyncRuleProperties ResourceSyncRuleProperties + err = json.Unmarshal(*v, &resourceSyncRuleProperties) + if err != nil { + return err + } + prsr.ResourceSyncRuleProperties = &resourceSyncRuleProperties + } + case "tags": + if v != nil { + var tags map[string]*string + err = json.Unmarshal(*v, &tags) + if err != nil { + return err + } + prsr.Tags = tags + } + } + } + + return nil +} + +// ProxyResource the resource model definition for a Azure Resource Manager proxy resource. It will not +// have tags and a location +type ProxyResource struct { + // ID - READ-ONLY; Fully qualified resource ID for the resource. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName} + ID *string `json:"id,omitempty"` + // Name - READ-ONLY; The name of the resource + Name *string `json:"name,omitempty"` + // Type - READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts" + Type *string `json:"type,omitempty"` +} + +// MarshalJSON is the custom marshaler for ProxyResource. +func (pr ProxyResource) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + return json.Marshal(objectMap) +} + +// Resource common fields that are returned in the response for all Azure Resource Manager resources +type Resource struct { + // ID - READ-ONLY; Fully qualified resource ID for the resource. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName} + ID *string `json:"id,omitempty"` + // Name - READ-ONLY; The name of the resource + Name *string `json:"name,omitempty"` + // Type - READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts" + Type *string `json:"type,omitempty"` +} + +// MarshalJSON is the custom marshaler for Resource. +func (r Resource) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + return json.Marshal(objectMap) +} + +// ResourceSyncRule resource Sync Rules definition. +type ResourceSyncRule struct { + autorest.Response `json:"-"` + // ResourceSyncRuleProperties - The set of properties specific to a Resource Sync Rule + *ResourceSyncRuleProperties `json:"properties,omitempty"` + // SystemData - READ-ONLY; Metadata pertaining to creation and last modification of the resource + SystemData *SystemData `json:"systemData,omitempty"` + // Tags - Resource tags. + Tags map[string]*string `json:"tags"` + // Location - The geo-location where the resource lives + Location *string `json:"location,omitempty"` + // ID - READ-ONLY; Fully qualified resource ID for the resource. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName} + ID *string `json:"id,omitempty"` + // Name - READ-ONLY; The name of the resource + Name *string `json:"name,omitempty"` + // Type - READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts" + Type *string `json:"type,omitempty"` +} + +// MarshalJSON is the custom marshaler for ResourceSyncRule. +func (rsr ResourceSyncRule) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + if rsr.ResourceSyncRuleProperties != nil { + objectMap["properties"] = rsr.ResourceSyncRuleProperties + } + if rsr.Tags != nil { + objectMap["tags"] = rsr.Tags + } + if rsr.Location != nil { + objectMap["location"] = rsr.Location + } + return json.Marshal(objectMap) +} + +// UnmarshalJSON is the custom unmarshaler for ResourceSyncRule struct. +func (rsr *ResourceSyncRule) UnmarshalJSON(body []byte) error { + var m map[string]*json.RawMessage + err := json.Unmarshal(body, &m) + if err != nil { + return err + } + for k, v := range m { + switch k { + case "properties": + if v != nil { + var resourceSyncRuleProperties ResourceSyncRuleProperties + err = json.Unmarshal(*v, &resourceSyncRuleProperties) + if err != nil { + return err + } + rsr.ResourceSyncRuleProperties = &resourceSyncRuleProperties + } + case "systemData": + if v != nil { + var systemData SystemData + err = json.Unmarshal(*v, &systemData) + if err != nil { + return err + } + rsr.SystemData = &systemData + } + case "tags": + if v != nil { + var tags map[string]*string + err = json.Unmarshal(*v, &tags) + if err != nil { + return err + } + rsr.Tags = tags + } + case "location": + if v != nil { + var location string + err = json.Unmarshal(*v, &location) + if err != nil { + return err + } + rsr.Location = &location + } + case "id": + if v != nil { + var ID string + err = json.Unmarshal(*v, &ID) + if err != nil { + return err + } + rsr.ID = &ID + } + case "name": + if v != nil { + var name string + err = json.Unmarshal(*v, &name) + if err != nil { + return err + } + rsr.Name = &name + } + case "type": + if v != nil { + var typeVar string + err = json.Unmarshal(*v, &typeVar) + if err != nil { + return err + } + rsr.Type = &typeVar + } + } + } + + return nil +} + +// ResourceSyncRuleListResult the List Resource Sync Rules operation response. +type ResourceSyncRuleListResult struct { + autorest.Response `json:"-"` + // NextLink - READ-ONLY; The URL to use for getting the next set of results. + NextLink *string `json:"nextLink,omitempty"` + // Value - READ-ONLY; The list of Resource Sync Rules. + Value *[]ResourceSyncRule `json:"value,omitempty"` +} + +// MarshalJSON is the custom marshaler for ResourceSyncRuleListResult. +func (rsrlr ResourceSyncRuleListResult) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + return json.Marshal(objectMap) +} + +// ResourceSyncRuleListResultIterator provides access to a complete listing of ResourceSyncRule values. +type ResourceSyncRuleListResultIterator struct { + i int + page ResourceSyncRuleListResultPage +} + +// NextWithContext advances to the next value. If there was an error making +// the request the iterator does not advance and the error is returned. +func (iter *ResourceSyncRuleListResultIterator) NextWithContext(ctx context.Context) (err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ResourceSyncRuleListResultIterator.NextWithContext") + defer func() { + sc := -1 + if iter.Response().Response.Response != nil { + sc = iter.Response().Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } + iter.i++ + if iter.i < len(iter.page.Values()) { + return nil + } + err = iter.page.NextWithContext(ctx) + if err != nil { + iter.i-- + return err + } + iter.i = 0 + return nil +} + +// Next advances to the next value. If there was an error making +// the request the iterator does not advance and the error is returned. +// Deprecated: Use NextWithContext() instead. +func (iter *ResourceSyncRuleListResultIterator) Next() error { + return iter.NextWithContext(context.Background()) +} + +// NotDone returns true if the enumeration should be started or is not yet complete. +func (iter ResourceSyncRuleListResultIterator) NotDone() bool { + return iter.page.NotDone() && iter.i < len(iter.page.Values()) +} + +// Response returns the raw server response from the last page request. +func (iter ResourceSyncRuleListResultIterator) Response() ResourceSyncRuleListResult { + return iter.page.Response() +} + +// Value returns the current value or a zero-initialized value if the +// iterator has advanced beyond the end of the collection. +func (iter ResourceSyncRuleListResultIterator) Value() ResourceSyncRule { + if !iter.page.NotDone() { + return ResourceSyncRule{} + } + return iter.page.Values()[iter.i] +} + +// Creates a new instance of the ResourceSyncRuleListResultIterator type. +func NewResourceSyncRuleListResultIterator(page ResourceSyncRuleListResultPage) ResourceSyncRuleListResultIterator { + return ResourceSyncRuleListResultIterator{page: page} +} + +// IsEmpty returns true if the ListResult contains no values. +func (rsrlr ResourceSyncRuleListResult) IsEmpty() bool { + return rsrlr.Value == nil || len(*rsrlr.Value) == 0 +} + +// hasNextLink returns true if the NextLink is not empty. +func (rsrlr ResourceSyncRuleListResult) hasNextLink() bool { + return rsrlr.NextLink != nil && len(*rsrlr.NextLink) != 0 +} + +// resourceSyncRuleListResultPreparer prepares a request to retrieve the next set of results. +// It returns nil if no more results exist. +func (rsrlr ResourceSyncRuleListResult) resourceSyncRuleListResultPreparer(ctx context.Context) (*http.Request, error) { + if !rsrlr.hasNextLink() { + return nil, nil + } + return autorest.Prepare((&http.Request{}).WithContext(ctx), + autorest.AsJSON(), + autorest.AsGet(), + autorest.WithBaseURL(to.String(rsrlr.NextLink))) +} + +// ResourceSyncRuleListResultPage contains a page of ResourceSyncRule values. +type ResourceSyncRuleListResultPage struct { + fn func(context.Context, ResourceSyncRuleListResult) (ResourceSyncRuleListResult, error) + rsrlr ResourceSyncRuleListResult +} + +// NextWithContext advances to the next page of values. If there was an error making +// the request the page does not advance and the error is returned. +func (page *ResourceSyncRuleListResultPage) NextWithContext(ctx context.Context) (err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ResourceSyncRuleListResultPage.NextWithContext") + defer func() { + sc := -1 + if page.Response().Response.Response != nil { + sc = page.Response().Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } + for { + next, err := page.fn(ctx, page.rsrlr) + if err != nil { + return err + } + page.rsrlr = next + if !next.hasNextLink() || !next.IsEmpty() { + break + } + } + return nil +} + +// Next advances to the next page of values. If there was an error making +// the request the page does not advance and the error is returned. +// Deprecated: Use NextWithContext() instead. +func (page *ResourceSyncRuleListResultPage) Next() error { + return page.NextWithContext(context.Background()) +} + +// NotDone returns true if the page enumeration should be started or is not yet complete. +func (page ResourceSyncRuleListResultPage) NotDone() bool { + return !page.rsrlr.IsEmpty() +} + +// Response returns the raw server response from the last page request. +func (page ResourceSyncRuleListResultPage) Response() ResourceSyncRuleListResult { + return page.rsrlr +} + +// Values returns the slice of values for the current page or nil if there are no values. +func (page ResourceSyncRuleListResultPage) Values() []ResourceSyncRule { + if page.rsrlr.IsEmpty() { + return nil + } + return *page.rsrlr.Value +} + +// Creates a new instance of the ResourceSyncRuleListResultPage type. +func NewResourceSyncRuleListResultPage(cur ResourceSyncRuleListResult, getNextPage func(context.Context, ResourceSyncRuleListResult) (ResourceSyncRuleListResult, error)) ResourceSyncRuleListResultPage { + return ResourceSyncRuleListResultPage{ + fn: getNextPage, + rsrlr: cur, + } +} + +// ResourceSyncRuleProperties properties for a resource sync rule. For an unmapped custom resource, its +// labels will be used to find out matching resource sync rules using the selector property of the resource +// sync rule. If this resource sync rule has highest priority among all matching rules, then the unmapped +// custom resource will be projected to the target resource group associated with this resource sync rule. +type ResourceSyncRuleProperties struct { + // Priority - Priority represents a priority of the Resource Sync Rule + Priority *int32 `json:"priority,omitempty"` + // ProvisioningState - READ-ONLY; Provisioning State for the Resource Sync Rule. + ProvisioningState *string `json:"provisioningState,omitempty"` + // Selector - A label selector is composed of two parts, matchLabels and matchExpressions. The first part, matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is 'key', the operator is 'In', and the values array contains only 'value'. The second part, matchExpressions is a list of resource selector requirements. Valid operators include In, NotIn, Exists, and DoesNotExist. The values set must be non-empty in the case of In and NotIn. The values set must be empty in the case of Exists and DoesNotExist. All of the requirements, from both matchLabels and matchExpressions must all be satisfied in order to match. + Selector *ResourceSyncRulePropertiesSelector `json:"selector,omitempty"` + // TargetResourceGroup - For an unmapped custom resource, its labels will be used to find matching resource sync rules. If this resource sync rule is one of the matching rules with highest priority, then the unmapped custom resource will be projected to the target resource group associated with this resource sync rule. The user creating this resource sync rule should have write permissions on the target resource group and this write permission will be validated when creating the resource sync rule. + TargetResourceGroup *string `json:"targetResourceGroup,omitempty"` +} + +// MarshalJSON is the custom marshaler for ResourceSyncRuleProperties. +func (rsrp ResourceSyncRuleProperties) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + if rsrp.Priority != nil { + objectMap["priority"] = rsrp.Priority + } + if rsrp.Selector != nil { + objectMap["selector"] = rsrp.Selector + } + if rsrp.TargetResourceGroup != nil { + objectMap["targetResourceGroup"] = rsrp.TargetResourceGroup + } + return json.Marshal(objectMap) +} + +// ResourceSyncRulePropertiesSelector a label selector is composed of two parts, matchLabels and +// matchExpressions. The first part, matchLabels is a map of {key,value} pairs. A single {key,value} in the +// matchLabels map is equivalent to an element of matchExpressions, whose key field is 'key', the operator +// is 'In', and the values array contains only 'value'. The second part, matchExpressions is a list of +// resource selector requirements. Valid operators include In, NotIn, Exists, and DoesNotExist. The values +// set must be non-empty in the case of In and NotIn. The values set must be empty in the case of Exists +// and DoesNotExist. All of the requirements, from both matchLabels and matchExpressions must all be +// satisfied in order to match. +type ResourceSyncRulePropertiesSelector struct { + // MatchExpressions - MatchExpressions is a list of resource selector requirements. Valid operators include In, NotIn, Exists, and DoesNotExist. The values set must be non-empty in the case of In and NotIn. The values set must be empty in the case of Exists and DoesNotExist. + MatchExpressions *[]MatchExpressionsProperties `json:"matchExpressions,omitempty"` + // MatchLabels - MatchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is 'key', the operator is 'In', and the values array contains only 'value'. + MatchLabels map[string]*string `json:"matchLabels"` +} + +// MarshalJSON is the custom marshaler for ResourceSyncRulePropertiesSelector. +func (rsrp ResourceSyncRulePropertiesSelector) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + if rsrp.MatchExpressions != nil { + objectMap["matchExpressions"] = rsrp.MatchExpressions + } + if rsrp.MatchLabels != nil { + objectMap["matchLabels"] = rsrp.MatchLabels + } + return json.Marshal(objectMap) +} + +// ResourceSyncRulesCreateOrUpdateFuture an abstraction for monitoring and retrieving the results of a +// long-running operation. +type ResourceSyncRulesCreateOrUpdateFuture struct { + azure.FutureAPI + // Result returns the result of the asynchronous operation. + // If the operation has not completed it will return an error. + Result func(ResourceSyncRulesClient) (ResourceSyncRule, error) +} + +// UnmarshalJSON is the custom unmarshaller for CreateFuture. +func (future *ResourceSyncRulesCreateOrUpdateFuture) UnmarshalJSON(body []byte) error { + var azFuture azure.Future + if err := json.Unmarshal(body, &azFuture); err != nil { + return err + } + future.FutureAPI = &azFuture + future.Result = future.result + return nil +} + +// result is the default implementation for ResourceSyncRulesCreateOrUpdateFuture.Result. +func (future *ResourceSyncRulesCreateOrUpdateFuture) result(client ResourceSyncRulesClient) (rsr ResourceSyncRule, err error) { + var done bool + done, err = future.DoneWithContext(context.Background(), client) + if err != nil { + err = autorest.NewErrorWithError(err, "extendedlocation.ResourceSyncRulesCreateOrUpdateFuture", "Result", future.Response(), "Polling failure") + return + } + if !done { + rsr.Response.Response = future.Response() + err = azure.NewAsyncOpIncompleteError("extendedlocation.ResourceSyncRulesCreateOrUpdateFuture") + return + } + sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) + if rsr.Response.Response, err = future.GetResult(sender); err == nil && rsr.Response.Response.StatusCode != http.StatusNoContent { + rsr, err = client.CreateOrUpdateResponder(rsr.Response.Response) + if err != nil { + err = autorest.NewErrorWithError(err, "extendedlocation.ResourceSyncRulesCreateOrUpdateFuture", "Result", rsr.Response.Response, "Failure responding to request") + } + } + return +} + +// ResourceSyncRulesUpdateFuture an abstraction for monitoring and retrieving the results of a long-running +// operation. +type ResourceSyncRulesUpdateFuture struct { + azure.FutureAPI + // Result returns the result of the asynchronous operation. + // If the operation has not completed it will return an error. + Result func(ResourceSyncRulesClient) (ResourceSyncRule, error) +} + +// UnmarshalJSON is the custom unmarshaller for CreateFuture. +func (future *ResourceSyncRulesUpdateFuture) UnmarshalJSON(body []byte) error { + var azFuture azure.Future + if err := json.Unmarshal(body, &azFuture); err != nil { + return err + } + future.FutureAPI = &azFuture + future.Result = future.result + return nil +} + +// result is the default implementation for ResourceSyncRulesUpdateFuture.Result. +func (future *ResourceSyncRulesUpdateFuture) result(client ResourceSyncRulesClient) (rsr ResourceSyncRule, err error) { + var done bool + done, err = future.DoneWithContext(context.Background(), client) + if err != nil { + err = autorest.NewErrorWithError(err, "extendedlocation.ResourceSyncRulesUpdateFuture", "Result", future.Response(), "Polling failure") + return + } + if !done { + rsr.Response.Response = future.Response() + err = azure.NewAsyncOpIncompleteError("extendedlocation.ResourceSyncRulesUpdateFuture") + return + } + sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) + if rsr.Response.Response, err = future.GetResult(sender); err == nil && rsr.Response.Response.StatusCode != http.StatusNoContent { + rsr, err = client.UpdateResponder(rsr.Response.Response) + if err != nil { + err = autorest.NewErrorWithError(err, "extendedlocation.ResourceSyncRulesUpdateFuture", "Result", rsr.Response.Response, "Failure responding to request") + } + } + return +} + +// SystemData metadata pertaining to creation and last modification of the resource. +type SystemData struct { + // CreatedBy - The identity that created the resource. + CreatedBy *string `json:"createdBy,omitempty"` + // CreatedByType - The type of identity that created the resource. Possible values include: 'User', 'Application', 'ManagedIdentity', 'Key' + CreatedByType CreatedByType `json:"createdByType,omitempty"` + // CreatedAt - The timestamp of resource creation (UTC). + CreatedAt *date.Time `json:"createdAt,omitempty"` + // LastModifiedBy - The identity that last modified the resource. + LastModifiedBy *string `json:"lastModifiedBy,omitempty"` + // LastModifiedByType - The type of identity that last modified the resource. Possible values include: 'User', 'Application', 'ManagedIdentity', 'Key' + LastModifiedByType CreatedByType `json:"lastModifiedByType,omitempty"` + // LastModifiedAt - The timestamp of resource last modification (UTC) + LastModifiedAt *date.Time `json:"lastModifiedAt,omitempty"` +} + +// TrackedResource the resource model definition for an Azure Resource Manager tracked top level resource +// which has 'tags' and a 'location' +type TrackedResource struct { + // Tags - Resource tags. + Tags map[string]*string `json:"tags"` + // Location - The geo-location where the resource lives + Location *string `json:"location,omitempty"` + // ID - READ-ONLY; Fully qualified resource ID for the resource. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName} + ID *string `json:"id,omitempty"` + // Name - READ-ONLY; The name of the resource + Name *string `json:"name,omitempty"` + // Type - READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts" + Type *string `json:"type,omitempty"` +} + +// MarshalJSON is the custom marshaler for TrackedResource. +func (tr TrackedResource) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + if tr.Tags != nil { + objectMap["tags"] = tr.Tags + } + if tr.Location != nil { + objectMap["location"] = tr.Location + } + return json.Marshal(objectMap) +} diff --git a/services/preview/extendedlocation/mgmt/2021-08-31-preview/extendedlocation/resourcesyncrules.go b/services/preview/extendedlocation/mgmt/2021-08-31-preview/extendedlocation/resourcesyncrules.go new file mode 100644 index 000000000000..79f48647d96d --- /dev/null +++ b/services/preview/extendedlocation/mgmt/2021-08-31-preview/extendedlocation/resourcesyncrules.go @@ -0,0 +1,561 @@ +package extendedlocation + +// Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT License. See License.txt in the project root for license information. +// +// Code generated by Microsoft (R) AutoRest Code Generator. +// Changes may cause incorrect behavior and will be lost if the code is regenerated. + +import ( + "context" + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/autorest/validation" + "github.com/Azure/go-autorest/tracing" + "net/http" +) + +// ResourceSyncRulesClient is the the customLocations Rest API spec. +type ResourceSyncRulesClient struct { + BaseClient +} + +// NewResourceSyncRulesClient creates an instance of the ResourceSyncRulesClient client. +func NewResourceSyncRulesClient(subscriptionID string) ResourceSyncRulesClient { + return NewResourceSyncRulesClientWithBaseURI(DefaultBaseURI, subscriptionID) +} + +// NewResourceSyncRulesClientWithBaseURI creates an instance of the ResourceSyncRulesClient client using a custom +// endpoint. Use this when interacting with an Azure cloud that uses a non-standard base URI (sovereign clouds, Azure +// stack). +func NewResourceSyncRulesClientWithBaseURI(baseURI string, subscriptionID string) ResourceSyncRulesClient { + return ResourceSyncRulesClient{NewWithBaseURI(baseURI, subscriptionID)} +} + +// CreateOrUpdate creates or updates a Resource Sync Rule in the parent Custom Location, Subscription Id and Resource +// Group +// Parameters: +// resourceGroupName - the name of the resource group. The name is case insensitive. +// resourceName - custom Locations name. +// childResourceName - resource Sync Rule name. +// parameters - parameters supplied to create or update a Resource Sync Rule. +func (client ResourceSyncRulesClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, resourceName string, childResourceName string, parameters ResourceSyncRule) (result ResourceSyncRulesCreateOrUpdateFuture, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ResourceSyncRulesClient.CreateOrUpdate") + defer func() { + sc := -1 + if result.FutureAPI != nil && result.FutureAPI.Response() != nil { + sc = result.FutureAPI.Response().StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } + if err := validation.Validate([]validation.Validation{ + {TargetValue: client.SubscriptionID, + Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, + {TargetValue: resourceGroupName, + Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, + {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}}}, + {TargetValue: resourceName, + Constraints: []validation.Constraint{{Target: "resourceName", Name: validation.MaxLength, Rule: 63, Chain: nil}, + {Target: "resourceName", Name: validation.MinLength, Rule: 1, Chain: nil}, + {Target: "resourceName", Name: validation.Pattern, Rule: `^[a-zA-Z0-9]$|^[a-zA-Z0-9][-_a-zA-Z0-9]{0,61}[a-zA-Z0-9]$`, Chain: nil}}}, + {TargetValue: childResourceName, + Constraints: []validation.Constraint{{Target: "childResourceName", Name: validation.MaxLength, Rule: 63, Chain: nil}, + {Target: "childResourceName", Name: validation.MinLength, Rule: 1, Chain: nil}, + {Target: "childResourceName", Name: validation.Pattern, Rule: `^[a-zA-Z0-9]$|^[a-zA-Z0-9][-_a-zA-Z0-9]{0,61}[a-zA-Z0-9]$`, Chain: nil}}}}); err != nil { + return result, validation.NewError("extendedlocation.ResourceSyncRulesClient", "CreateOrUpdate", err.Error()) + } + + req, err := client.CreateOrUpdatePreparer(ctx, resourceGroupName, resourceName, childResourceName, parameters) + if err != nil { + err = autorest.NewErrorWithError(err, "extendedlocation.ResourceSyncRulesClient", "CreateOrUpdate", nil, "Failure preparing request") + return + } + + result, err = client.CreateOrUpdateSender(req) + if err != nil { + err = autorest.NewErrorWithError(err, "extendedlocation.ResourceSyncRulesClient", "CreateOrUpdate", result.Response(), "Failure sending request") + return + } + + return +} + +// CreateOrUpdatePreparer prepares the CreateOrUpdate request. +func (client ResourceSyncRulesClient) CreateOrUpdatePreparer(ctx context.Context, resourceGroupName string, resourceName string, childResourceName string, parameters ResourceSyncRule) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "childResourceName": autorest.Encode("path", childResourceName), + "resourceGroupName": autorest.Encode("path", resourceGroupName), + "resourceName": autorest.Encode("path", resourceName), + "subscriptionId": autorest.Encode("path", client.SubscriptionID), + } + + const APIVersion = "2021-08-31-preview" + queryParameters := map[string]interface{}{ + "api-version": APIVersion, + } + + parameters.SystemData = nil + preparer := autorest.CreatePreparer( + autorest.AsContentType("application/json; charset=utf-8"), + autorest.AsPut(), + autorest.WithBaseURL(client.BaseURI), + autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ExtendedLocation/customLocations/{resourceName}/resourceSyncRules/{childResourceName}", pathParameters), + autorest.WithJSON(parameters), + autorest.WithQueryParameters(queryParameters)) + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the +// http.Response Body if it receives an error. +func (client ResourceSyncRulesClient) CreateOrUpdateSender(req *http.Request) (future ResourceSyncRulesCreateOrUpdateFuture, err error) { + var resp *http.Response + future.FutureAPI = &azure.Future{} + resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) + if err != nil { + return + } + var azf azure.Future + azf, err = azure.NewFutureFromResponse(resp) + future.FutureAPI = &azf + future.Result = future.result + return +} + +// CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always +// closes the http.Response Body. +func (client ResourceSyncRulesClient) CreateOrUpdateResponder(resp *http.Response) (result ResourceSyncRule, err error) { + err = autorest.Respond( + resp, + azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusCreated), + autorest.ByUnmarshallingJSON(&result), + autorest.ByClosing()) + result.Response = autorest.Response{Response: resp} + return +} + +// Delete deletes the Resource Sync Rule with the specified Resource Sync Rule Name, Custom Location Resource Name, +// Resource Group, and Subscription Id. +// Parameters: +// resourceGroupName - the name of the resource group. The name is case insensitive. +// resourceName - custom Locations name. +// childResourceName - resource Sync Rule name. +func (client ResourceSyncRulesClient) Delete(ctx context.Context, resourceGroupName string, resourceName string, childResourceName string) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ResourceSyncRulesClient.Delete") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } + if err := validation.Validate([]validation.Validation{ + {TargetValue: client.SubscriptionID, + Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, + {TargetValue: resourceGroupName, + Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, + {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}}}, + {TargetValue: resourceName, + Constraints: []validation.Constraint{{Target: "resourceName", Name: validation.MaxLength, Rule: 63, Chain: nil}, + {Target: "resourceName", Name: validation.MinLength, Rule: 1, Chain: nil}, + {Target: "resourceName", Name: validation.Pattern, Rule: `^[a-zA-Z0-9]$|^[a-zA-Z0-9][-_a-zA-Z0-9]{0,61}[a-zA-Z0-9]$`, Chain: nil}}}, + {TargetValue: childResourceName, + Constraints: []validation.Constraint{{Target: "childResourceName", Name: validation.MaxLength, Rule: 63, Chain: nil}, + {Target: "childResourceName", Name: validation.MinLength, Rule: 1, Chain: nil}, + {Target: "childResourceName", Name: validation.Pattern, Rule: `^[a-zA-Z0-9]$|^[a-zA-Z0-9][-_a-zA-Z0-9]{0,61}[a-zA-Z0-9]$`, Chain: nil}}}}); err != nil { + return result, validation.NewError("extendedlocation.ResourceSyncRulesClient", "Delete", err.Error()) + } + + req, err := client.DeletePreparer(ctx, resourceGroupName, resourceName, childResourceName) + if err != nil { + err = autorest.NewErrorWithError(err, "extendedlocation.ResourceSyncRulesClient", "Delete", nil, "Failure preparing request") + return + } + + resp, err := client.DeleteSender(req) + if err != nil { + result.Response = resp + err = autorest.NewErrorWithError(err, "extendedlocation.ResourceSyncRulesClient", "Delete", resp, "Failure sending request") + return + } + + result, err = client.DeleteResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "extendedlocation.ResourceSyncRulesClient", "Delete", resp, "Failure responding to request") + return + } + + return +} + +// DeletePreparer prepares the Delete request. +func (client ResourceSyncRulesClient) DeletePreparer(ctx context.Context, resourceGroupName string, resourceName string, childResourceName string) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "childResourceName": autorest.Encode("path", childResourceName), + "resourceGroupName": autorest.Encode("path", resourceGroupName), + "resourceName": autorest.Encode("path", resourceName), + "subscriptionId": autorest.Encode("path", client.SubscriptionID), + } + + const APIVersion = "2021-08-31-preview" + queryParameters := map[string]interface{}{ + "api-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsDelete(), + autorest.WithBaseURL(client.BaseURI), + autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ExtendedLocation/customLocations/{resourceName}/resourceSyncRules/{childResourceName}", pathParameters), + autorest.WithQueryParameters(queryParameters)) + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// DeleteSender sends the Delete request. The method will close the +// http.Response Body if it receives an error. +func (client ResourceSyncRulesClient) DeleteSender(req *http.Request) (*http.Response, error) { + return client.Send(req, azure.DoRetryWithRegistration(client.Client)) +} + +// DeleteResponder handles the response to the Delete request. The method always +// closes the http.Response Body. +func (client ResourceSyncRulesClient) DeleteResponder(resp *http.Response) (result autorest.Response, err error) { + err = autorest.Respond( + resp, + azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNoContent), + autorest.ByClosing()) + result.Response = resp + return +} + +// Get gets the details of the resourceSyncRule with a specified resource group, subscription id Custom Location +// resource name and Resource Sync Rule name. +// Parameters: +// resourceGroupName - the name of the resource group. The name is case insensitive. +// resourceName - custom Locations name. +// childResourceName - resource Sync Rule name. +func (client ResourceSyncRulesClient) Get(ctx context.Context, resourceGroupName string, resourceName string, childResourceName string) (result ResourceSyncRule, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ResourceSyncRulesClient.Get") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } + if err := validation.Validate([]validation.Validation{ + {TargetValue: client.SubscriptionID, + Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, + {TargetValue: resourceGroupName, + Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, + {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}}}, + {TargetValue: resourceName, + Constraints: []validation.Constraint{{Target: "resourceName", Name: validation.MaxLength, Rule: 63, Chain: nil}, + {Target: "resourceName", Name: validation.MinLength, Rule: 1, Chain: nil}, + {Target: "resourceName", Name: validation.Pattern, Rule: `^[a-zA-Z0-9]$|^[a-zA-Z0-9][-_a-zA-Z0-9]{0,61}[a-zA-Z0-9]$`, Chain: nil}}}, + {TargetValue: childResourceName, + Constraints: []validation.Constraint{{Target: "childResourceName", Name: validation.MaxLength, Rule: 63, Chain: nil}, + {Target: "childResourceName", Name: validation.MinLength, Rule: 1, Chain: nil}, + {Target: "childResourceName", Name: validation.Pattern, Rule: `^[a-zA-Z0-9]$|^[a-zA-Z0-9][-_a-zA-Z0-9]{0,61}[a-zA-Z0-9]$`, Chain: nil}}}}); err != nil { + return result, validation.NewError("extendedlocation.ResourceSyncRulesClient", "Get", err.Error()) + } + + req, err := client.GetPreparer(ctx, resourceGroupName, resourceName, childResourceName) + if err != nil { + err = autorest.NewErrorWithError(err, "extendedlocation.ResourceSyncRulesClient", "Get", nil, "Failure preparing request") + return + } + + resp, err := client.GetSender(req) + if err != nil { + result.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "extendedlocation.ResourceSyncRulesClient", "Get", resp, "Failure sending request") + return + } + + result, err = client.GetResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "extendedlocation.ResourceSyncRulesClient", "Get", resp, "Failure responding to request") + return + } + + return +} + +// GetPreparer prepares the Get request. +func (client ResourceSyncRulesClient) GetPreparer(ctx context.Context, resourceGroupName string, resourceName string, childResourceName string) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "childResourceName": autorest.Encode("path", childResourceName), + "resourceGroupName": autorest.Encode("path", resourceGroupName), + "resourceName": autorest.Encode("path", resourceName), + "subscriptionId": autorest.Encode("path", client.SubscriptionID), + } + + const APIVersion = "2021-08-31-preview" + queryParameters := map[string]interface{}{ + "api-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsGet(), + autorest.WithBaseURL(client.BaseURI), + autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ExtendedLocation/customLocations/{resourceName}/resourceSyncRules/{childResourceName}", pathParameters), + autorest.WithQueryParameters(queryParameters)) + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// GetSender sends the Get request. The method will close the +// http.Response Body if it receives an error. +func (client ResourceSyncRulesClient) GetSender(req *http.Request) (*http.Response, error) { + return client.Send(req, azure.DoRetryWithRegistration(client.Client)) +} + +// GetResponder handles the response to the Get request. The method always +// closes the http.Response Body. +func (client ResourceSyncRulesClient) GetResponder(resp *http.Response) (result ResourceSyncRule, err error) { + err = autorest.Respond( + resp, + azure.WithErrorUnlessStatusCode(http.StatusOK), + autorest.ByUnmarshallingJSON(&result), + autorest.ByClosing()) + result.Response = autorest.Response{Response: resp} + return +} + +// ListByCustomLocationID gets a list of Resource Sync Rules in the specified subscription. The operation returns +// properties of each Resource Sync Rule +// Parameters: +// resourceGroupName - the name of the resource group. The name is case insensitive. +// resourceName - custom Locations name. +func (client ResourceSyncRulesClient) ListByCustomLocationID(ctx context.Context, resourceGroupName string, resourceName string) (result ResourceSyncRuleListResultPage, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ResourceSyncRulesClient.ListByCustomLocationID") + defer func() { + sc := -1 + if result.rsrlr.Response.Response != nil { + sc = result.rsrlr.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } + if err := validation.Validate([]validation.Validation{ + {TargetValue: client.SubscriptionID, + Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, + {TargetValue: resourceGroupName, + Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, + {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}}}, + {TargetValue: resourceName, + Constraints: []validation.Constraint{{Target: "resourceName", Name: validation.MaxLength, Rule: 63, Chain: nil}, + {Target: "resourceName", Name: validation.MinLength, Rule: 1, Chain: nil}, + {Target: "resourceName", Name: validation.Pattern, Rule: `^[a-zA-Z0-9]$|^[a-zA-Z0-9][-_a-zA-Z0-9]{0,61}[a-zA-Z0-9]$`, Chain: nil}}}}); err != nil { + return result, validation.NewError("extendedlocation.ResourceSyncRulesClient", "ListByCustomLocationID", err.Error()) + } + + result.fn = client.listByCustomLocationIDNextResults + req, err := client.ListByCustomLocationIDPreparer(ctx, resourceGroupName, resourceName) + if err != nil { + err = autorest.NewErrorWithError(err, "extendedlocation.ResourceSyncRulesClient", "ListByCustomLocationID", nil, "Failure preparing request") + return + } + + resp, err := client.ListByCustomLocationIDSender(req) + if err != nil { + result.rsrlr.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "extendedlocation.ResourceSyncRulesClient", "ListByCustomLocationID", resp, "Failure sending request") + return + } + + result.rsrlr, err = client.ListByCustomLocationIDResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "extendedlocation.ResourceSyncRulesClient", "ListByCustomLocationID", resp, "Failure responding to request") + return + } + if result.rsrlr.hasNextLink() && result.rsrlr.IsEmpty() { + err = result.NextWithContext(ctx) + return + } + + return +} + +// ListByCustomLocationIDPreparer prepares the ListByCustomLocationID request. +func (client ResourceSyncRulesClient) ListByCustomLocationIDPreparer(ctx context.Context, resourceGroupName string, resourceName string) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "resourceGroupName": autorest.Encode("path", resourceGroupName), + "resourceName": autorest.Encode("path", resourceName), + "subscriptionId": autorest.Encode("path", client.SubscriptionID), + } + + const APIVersion = "2021-08-31-preview" + queryParameters := map[string]interface{}{ + "api-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsGet(), + autorest.WithBaseURL(client.BaseURI), + autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ExtendedLocation/customLocations/{resourceName}/resourceSyncRules", pathParameters), + autorest.WithQueryParameters(queryParameters)) + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// ListByCustomLocationIDSender sends the ListByCustomLocationID request. The method will close the +// http.Response Body if it receives an error. +func (client ResourceSyncRulesClient) ListByCustomLocationIDSender(req *http.Request) (*http.Response, error) { + return client.Send(req, azure.DoRetryWithRegistration(client.Client)) +} + +// ListByCustomLocationIDResponder handles the response to the ListByCustomLocationID request. The method always +// closes the http.Response Body. +func (client ResourceSyncRulesClient) ListByCustomLocationIDResponder(resp *http.Response) (result ResourceSyncRuleListResult, err error) { + err = autorest.Respond( + resp, + azure.WithErrorUnlessStatusCode(http.StatusOK), + autorest.ByUnmarshallingJSON(&result), + autorest.ByClosing()) + result.Response = autorest.Response{Response: resp} + return +} + +// listByCustomLocationIDNextResults retrieves the next set of results, if any. +func (client ResourceSyncRulesClient) listByCustomLocationIDNextResults(ctx context.Context, lastResults ResourceSyncRuleListResult) (result ResourceSyncRuleListResult, err error) { + req, err := lastResults.resourceSyncRuleListResultPreparer(ctx) + if err != nil { + return result, autorest.NewErrorWithError(err, "extendedlocation.ResourceSyncRulesClient", "listByCustomLocationIDNextResults", nil, "Failure preparing next results request") + } + if req == nil { + return + } + resp, err := client.ListByCustomLocationIDSender(req) + if err != nil { + result.Response = autorest.Response{Response: resp} + return result, autorest.NewErrorWithError(err, "extendedlocation.ResourceSyncRulesClient", "listByCustomLocationIDNextResults", resp, "Failure sending next results request") + } + result, err = client.ListByCustomLocationIDResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "extendedlocation.ResourceSyncRulesClient", "listByCustomLocationIDNextResults", resp, "Failure responding to next results request") + } + return +} + +// ListByCustomLocationIDComplete enumerates all values, automatically crossing page boundaries as required. +func (client ResourceSyncRulesClient) ListByCustomLocationIDComplete(ctx context.Context, resourceGroupName string, resourceName string) (result ResourceSyncRuleListResultIterator, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ResourceSyncRulesClient.ListByCustomLocationID") + defer func() { + sc := -1 + if result.Response().Response.Response != nil { + sc = result.page.Response().Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } + result.page, err = client.ListByCustomLocationID(ctx, resourceGroupName, resourceName) + return +} + +// Update updates a Resource Sync Rule with the specified Resource Sync Rule name in the specified Resource Group, +// Subscription and Custom Location name. +// Parameters: +// resourceGroupName - the name of the resource group. The name is case insensitive. +// resourceName - custom Locations name. +// childResourceName - resource Sync Rule name. +// parameters - the updatable fields of an existing Resource Sync Rule. +func (client ResourceSyncRulesClient) Update(ctx context.Context, resourceGroupName string, resourceName string, childResourceName string, parameters PatchableResourceSyncRule) (result ResourceSyncRulesUpdateFuture, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ResourceSyncRulesClient.Update") + defer func() { + sc := -1 + if result.FutureAPI != nil && result.FutureAPI.Response() != nil { + sc = result.FutureAPI.Response().StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } + if err := validation.Validate([]validation.Validation{ + {TargetValue: client.SubscriptionID, + Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, + {TargetValue: resourceGroupName, + Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, + {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}}}, + {TargetValue: resourceName, + Constraints: []validation.Constraint{{Target: "resourceName", Name: validation.MaxLength, Rule: 63, Chain: nil}, + {Target: "resourceName", Name: validation.MinLength, Rule: 1, Chain: nil}, + {Target: "resourceName", Name: validation.Pattern, Rule: `^[a-zA-Z0-9]$|^[a-zA-Z0-9][-_a-zA-Z0-9]{0,61}[a-zA-Z0-9]$`, Chain: nil}}}, + {TargetValue: childResourceName, + Constraints: []validation.Constraint{{Target: "childResourceName", Name: validation.MaxLength, Rule: 63, Chain: nil}, + {Target: "childResourceName", Name: validation.MinLength, Rule: 1, Chain: nil}, + {Target: "childResourceName", Name: validation.Pattern, Rule: `^[a-zA-Z0-9]$|^[a-zA-Z0-9][-_a-zA-Z0-9]{0,61}[a-zA-Z0-9]$`, Chain: nil}}}}); err != nil { + return result, validation.NewError("extendedlocation.ResourceSyncRulesClient", "Update", err.Error()) + } + + req, err := client.UpdatePreparer(ctx, resourceGroupName, resourceName, childResourceName, parameters) + if err != nil { + err = autorest.NewErrorWithError(err, "extendedlocation.ResourceSyncRulesClient", "Update", nil, "Failure preparing request") + return + } + + result, err = client.UpdateSender(req) + if err != nil { + err = autorest.NewErrorWithError(err, "extendedlocation.ResourceSyncRulesClient", "Update", result.Response(), "Failure sending request") + return + } + + return +} + +// UpdatePreparer prepares the Update request. +func (client ResourceSyncRulesClient) UpdatePreparer(ctx context.Context, resourceGroupName string, resourceName string, childResourceName string, parameters PatchableResourceSyncRule) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "childResourceName": autorest.Encode("path", childResourceName), + "resourceGroupName": autorest.Encode("path", resourceGroupName), + "resourceName": autorest.Encode("path", resourceName), + "subscriptionId": autorest.Encode("path", client.SubscriptionID), + } + + const APIVersion = "2021-08-31-preview" + queryParameters := map[string]interface{}{ + "api-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsContentType("application/json; charset=utf-8"), + autorest.AsPatch(), + autorest.WithBaseURL(client.BaseURI), + autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ExtendedLocation/customLocations/{resourceName}/resourceSyncRules/{childResourceName}", pathParameters), + autorest.WithJSON(parameters), + autorest.WithQueryParameters(queryParameters)) + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// UpdateSender sends the Update request. The method will close the +// http.Response Body if it receives an error. +func (client ResourceSyncRulesClient) UpdateSender(req *http.Request) (future ResourceSyncRulesUpdateFuture, err error) { + var resp *http.Response + future.FutureAPI = &azure.Future{} + resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) + if err != nil { + return + } + var azf azure.Future + azf, err = azure.NewFutureFromResponse(resp) + future.FutureAPI = &azf + future.Result = future.result + return +} + +// UpdateResponder handles the response to the Update request. The method always +// closes the http.Response Body. +func (client ResourceSyncRulesClient) UpdateResponder(resp *http.Response) (result ResourceSyncRule, err error) { + err = autorest.Respond( + resp, + azure.WithErrorUnlessStatusCode(http.StatusOK), + autorest.ByUnmarshallingJSON(&result), + autorest.ByClosing()) + result.Response = autorest.Response{Response: resp} + return +} diff --git a/services/preview/extendedlocation/mgmt/2021-08-31-preview/extendedlocation/version.go b/services/preview/extendedlocation/mgmt/2021-08-31-preview/extendedlocation/version.go new file mode 100644 index 000000000000..1b32f9e3848d --- /dev/null +++ b/services/preview/extendedlocation/mgmt/2021-08-31-preview/extendedlocation/version.go @@ -0,0 +1,19 @@ +package extendedlocation + +import "github.com/Azure/azure-sdk-for-go/version" + +// Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT License. See License.txt in the project root for license information. +// +// Code generated by Microsoft (R) AutoRest Code Generator. +// Changes may cause incorrect behavior and will be lost if the code is regenerated. + +// UserAgent returns the UserAgent string to use when sending http.Requests. +func UserAgent() string { + return "Azure-SDK-For-Go/" + Version() + " extendedlocation/2021-08-31-preview" +} + +// Version returns the semantic version (see http://semver.org) of the client. +func Version() string { + return version.Number +}