diff --git a/sdk/resourcemanager/secretsstoreextension/armsecretsstoreextension/CHANGELOG.md b/sdk/resourcemanager/secretsstoreextension/armsecretsstoreextension/CHANGELOG.md new file mode 100644 index 000000000000..3453d1b0dd8a --- /dev/null +++ b/sdk/resourcemanager/secretsstoreextension/armsecretsstoreextension/CHANGELOG.md @@ -0,0 +1,8 @@ +# Release History + +## 0.1.0 (2025-05-08) +### Other Changes + +The package of `github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/secretsstoreextension/armsecretsstoreextension` is using our [next generation design principles](https://azure.github.io/azure-sdk/general_introduction.html). + +To learn more, please refer to our documentation [Quick Start](https://aka.ms/azsdk/go/mgmt). \ No newline at end of file diff --git a/sdk/resourcemanager/secretsstoreextension/armsecretsstoreextension/LICENSE.txt b/sdk/resourcemanager/secretsstoreextension/armsecretsstoreextension/LICENSE.txt new file mode 100644 index 000000000000..dc0c2ffb3dc1 --- /dev/null +++ b/sdk/resourcemanager/secretsstoreextension/armsecretsstoreextension/LICENSE.txt @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) Microsoft Corporation. All rights reserved. + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. \ No newline at end of file diff --git a/sdk/resourcemanager/secretsstoreextension/armsecretsstoreextension/README.md b/sdk/resourcemanager/secretsstoreextension/armsecretsstoreextension/README.md new file mode 100644 index 000000000000..539a71aee876 --- /dev/null +++ b/sdk/resourcemanager/secretsstoreextension/armsecretsstoreextension/README.md @@ -0,0 +1,90 @@ +# Azure Secretsstoreextension Module for Go + +The `armsecretsstoreextension` module provides operations for working with Azure Secretsstoreextension. + +[Source code](https://github.com/Azure/azure-sdk-for-go/tree/main/sdk/resourcemanager/secretsstoreextension/armsecretsstoreextension) + +# Getting started + +## Prerequisites + +- an [Azure subscription](https://azure.microsoft.com/free/) +- Go 1.18 or above (You could download and install the latest version of Go from [here](https://go.dev/doc/install). It will replace the existing Go on your machine. If you want to install multiple Go versions on the same machine, you could refer this [doc](https://go.dev/doc/manage-install).) + +## Install the package + +This project uses [Go modules](https://github.com/golang/go/wiki/Modules) for versioning and dependency management. + +Install the Azure Secretsstoreextension module: + +```sh +go get github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/secretsstoreextension/armsecretsstoreextension +``` + +## Authorization + +When creating a client, you will need to provide a credential for authenticating with Azure Secretsstoreextension. The `azidentity` module provides facilities for various ways of authenticating with Azure including client/secret, certificate, managed identity, and more. + +```go +cred, err := azidentity.NewDefaultAzureCredential(nil) +``` + +For more information on authentication, please see the documentation for `azidentity` at [pkg.go.dev/github.com/Azure/azure-sdk-for-go/sdk/azidentity](https://pkg.go.dev/github.com/Azure/azure-sdk-for-go/sdk/azidentity). + +## Client Factory + +Azure Secretsstoreextension module consists of one or more clients. We provide a client factory which could be used to create any client in this module. + +```go +clientFactory, err := armsecretsstoreextension.NewClientFactory(, cred, nil) +``` + +You can use `ClientOptions` in package `github.com/Azure/azure-sdk-for-go/sdk/azcore/arm` to set endpoint to connect with public and sovereign clouds as well as Azure Stack. For more information, please see the documentation for `azcore` at [pkg.go.dev/github.com/Azure/azure-sdk-for-go/sdk/azcore](https://pkg.go.dev/github.com/Azure/azure-sdk-for-go/sdk/azcore). + +```go +options := arm.ClientOptions { + ClientOptions: azcore.ClientOptions { + Cloud: cloud.AzureChina, + }, +} +clientFactory, err := armsecretsstoreextension.NewClientFactory(, cred, &options) +``` + +## Clients + +A client groups a set of related APIs, providing access to its functionality. Create one or more clients to access the APIs you require using client factory. + +```go +client := clientFactory.NewAzureKeyVaultSecretProviderClassesClient() +``` + +## Fakes + +The fake package contains types used for constructing in-memory fake servers used in unit tests. +This allows writing tests to cover various success/error conditions without the need for connecting to a live service. + +Please see https://github.com/Azure/azure-sdk-for-go/tree/main/sdk/samples/fakes for details and examples on how to use fakes. + +## Provide Feedback + +If you encounter bugs or have suggestions, please +[open an issue](https://github.com/Azure/azure-sdk-for-go/issues) and assign the `Secretsstoreextension` label. + +# Contributing + +This project welcomes contributions and suggestions. Most contributions require +you to agree to a Contributor License Agreement (CLA) declaring that you have +the right to, and actually do, grant us the rights to use your contribution. +For details, visit [https://cla.microsoft.com](https://cla.microsoft.com). + +When you submit a pull request, a CLA-bot will automatically determine whether +you need to provide a CLA and decorate the PR appropriately (e.g., label, +comment). Simply follow the instructions provided by the bot. You will only +need to do this once across all repos using our CLA. + +This project has adopted the +[Microsoft Open Source Code of Conduct](https://opensource.microsoft.com/codeofconduct/). +For more information, see the +[Code of Conduct FAQ](https://opensource.microsoft.com/codeofconduct/faq/) +or contact [opencode@microsoft.com](mailto:opencode@microsoft.com) with any +additional questions or comments. \ No newline at end of file diff --git a/sdk/resourcemanager/secretsstoreextension/armsecretsstoreextension/azurekeyvaultsecretproviderclasses_client.go b/sdk/resourcemanager/secretsstoreextension/armsecretsstoreextension/azurekeyvaultsecretproviderclasses_client.go new file mode 100644 index 000000000000..92ad87048c9d --- /dev/null +++ b/sdk/resourcemanager/secretsstoreextension/armsecretsstoreextension/azurekeyvaultsecretproviderclasses_client.go @@ -0,0 +1,458 @@ +// 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) Go Code Generator. DO NOT EDIT. + +package armsecretsstoreextension + +import ( + "context" + "errors" + "github.com/Azure/azure-sdk-for-go/sdk/azcore" + "github.com/Azure/azure-sdk-for-go/sdk/azcore/arm" + "github.com/Azure/azure-sdk-for-go/sdk/azcore/policy" + "github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime" + "net/http" + "net/url" + "strings" +) + +// AzureKeyVaultSecretProviderClassesClient contains the methods for the AzureKeyVaultSecretProviderClasses group. +// Don't use this type directly, use NewAzureKeyVaultSecretProviderClassesClient() instead. +type AzureKeyVaultSecretProviderClassesClient struct { + internal *arm.Client + subscriptionID string +} + +// NewAzureKeyVaultSecretProviderClassesClient creates a new instance of AzureKeyVaultSecretProviderClassesClient with the specified values. +// - subscriptionID - The ID of the target subscription. The value must be an UUID. +// - credential - used to authorize requests. Usually a credential from azidentity. +// - options - pass nil to accept the default values. +func NewAzureKeyVaultSecretProviderClassesClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*AzureKeyVaultSecretProviderClassesClient, error) { + cl, err := arm.NewClient(moduleName, moduleVersion, credential, options) + if err != nil { + return nil, err + } + client := &AzureKeyVaultSecretProviderClassesClient{ + subscriptionID: subscriptionID, + internal: cl, + } + return client, nil +} + +// BeginCreateOrUpdate - Creates, or updates, an AzureKeyVaultSecretProviderClass instance. +// If the operation fails it returns an *azcore.ResponseError type. +// +// Generated from API version 2024-08-21-preview +// - resourceGroupName - The name of the resource group. The name is case insensitive. +// - azureKeyVaultSecretProviderClassName - The name of the AzureKeyVaultSecretProviderClass +// - resource - Resource create parameters. +// - options - AzureKeyVaultSecretProviderClassesClientBeginCreateOrUpdateOptions contains the optional parameters for the AzureKeyVaultSecretProviderClassesClient.BeginCreateOrUpdate +// method. +func (client *AzureKeyVaultSecretProviderClassesClient) BeginCreateOrUpdate(ctx context.Context, resourceGroupName string, azureKeyVaultSecretProviderClassName string, resource AzureKeyVaultSecretProviderClass, options *AzureKeyVaultSecretProviderClassesClientBeginCreateOrUpdateOptions) (*runtime.Poller[AzureKeyVaultSecretProviderClassesClientCreateOrUpdateResponse], error) { + if options == nil || options.ResumeToken == "" { + resp, err := client.createOrUpdate(ctx, resourceGroupName, azureKeyVaultSecretProviderClassName, resource, options) + if err != nil { + return nil, err + } + poller, err := runtime.NewPoller(resp, client.internal.Pipeline(), &runtime.NewPollerOptions[AzureKeyVaultSecretProviderClassesClientCreateOrUpdateResponse]{ + Tracer: client.internal.Tracer(), + }) + return poller, err + } else { + return runtime.NewPollerFromResumeToken(options.ResumeToken, client.internal.Pipeline(), &runtime.NewPollerFromResumeTokenOptions[AzureKeyVaultSecretProviderClassesClientCreateOrUpdateResponse]{ + Tracer: client.internal.Tracer(), + }) + } +} + +// CreateOrUpdate - Creates, or updates, an AzureKeyVaultSecretProviderClass instance. +// If the operation fails it returns an *azcore.ResponseError type. +// +// Generated from API version 2024-08-21-preview +func (client *AzureKeyVaultSecretProviderClassesClient) createOrUpdate(ctx context.Context, resourceGroupName string, azureKeyVaultSecretProviderClassName string, resource AzureKeyVaultSecretProviderClass, options *AzureKeyVaultSecretProviderClassesClientBeginCreateOrUpdateOptions) (*http.Response, error) { + var err error + const operationName = "AzureKeyVaultSecretProviderClassesClient.BeginCreateOrUpdate" + ctx = context.WithValue(ctx, runtime.CtxAPINameKey{}, operationName) + ctx, endSpan := runtime.StartSpan(ctx, operationName, client.internal.Tracer(), nil) + defer func() { endSpan(err) }() + req, err := client.createOrUpdateCreateRequest(ctx, resourceGroupName, azureKeyVaultSecretProviderClassName, resource, options) + if err != nil { + return nil, err + } + httpResp, err := client.internal.Pipeline().Do(req) + if err != nil { + return nil, err + } + if !runtime.HasStatusCode(httpResp, http.StatusOK, http.StatusCreated) { + err = runtime.NewResponseError(httpResp) + return nil, err + } + return httpResp, nil +} + +// createOrUpdateCreateRequest creates the CreateOrUpdate request. +func (client *AzureKeyVaultSecretProviderClassesClient) createOrUpdateCreateRequest(ctx context.Context, resourceGroupName string, azureKeyVaultSecretProviderClassName string, resource AzureKeyVaultSecretProviderClass, _ *AzureKeyVaultSecretProviderClassesClientBeginCreateOrUpdateOptions) (*policy.Request, error) { + urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.SecretSyncController/azureKeyVaultSecretProviderClasses/{azureKeyVaultSecretProviderClassName}" + if client.subscriptionID == "" { + return nil, errors.New("parameter client.subscriptionID cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) + if resourceGroupName == "" { + return nil, errors.New("parameter resourceGroupName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName)) + if azureKeyVaultSecretProviderClassName == "" { + return nil, errors.New("parameter azureKeyVaultSecretProviderClassName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{azureKeyVaultSecretProviderClassName}", url.PathEscape(azureKeyVaultSecretProviderClassName)) + req, err := runtime.NewRequest(ctx, http.MethodPut, runtime.JoinPaths(client.internal.Endpoint(), urlPath)) + if err != nil { + return nil, err + } + reqQP := req.Raw().URL.Query() + reqQP.Set("api-version", "2024-08-21-preview") + req.Raw().URL.RawQuery = reqQP.Encode() + req.Raw().Header["Accept"] = []string{"application/json"} + req.Raw().Header["Content-Type"] = []string{"application/json"} + if err := runtime.MarshalAsJSON(req, resource); err != nil { + return nil, err + } + return req, nil +} + +// BeginDelete - Deletes an AzureKeyVaultSecretProviderClass instance. +// If the operation fails it returns an *azcore.ResponseError type. +// +// Generated from API version 2024-08-21-preview +// - resourceGroupName - The name of the resource group. The name is case insensitive. +// - azureKeyVaultSecretProviderClassName - The name of the AzureKeyVaultSecretProviderClass +// - options - AzureKeyVaultSecretProviderClassesClientBeginDeleteOptions contains the optional parameters for the AzureKeyVaultSecretProviderClassesClient.BeginDelete +// method. +func (client *AzureKeyVaultSecretProviderClassesClient) BeginDelete(ctx context.Context, resourceGroupName string, azureKeyVaultSecretProviderClassName string, options *AzureKeyVaultSecretProviderClassesClientBeginDeleteOptions) (*runtime.Poller[AzureKeyVaultSecretProviderClassesClientDeleteResponse], error) { + if options == nil || options.ResumeToken == "" { + resp, err := client.deleteOperation(ctx, resourceGroupName, azureKeyVaultSecretProviderClassName, options) + if err != nil { + return nil, err + } + poller, err := runtime.NewPoller(resp, client.internal.Pipeline(), &runtime.NewPollerOptions[AzureKeyVaultSecretProviderClassesClientDeleteResponse]{ + Tracer: client.internal.Tracer(), + }) + return poller, err + } else { + return runtime.NewPollerFromResumeToken(options.ResumeToken, client.internal.Pipeline(), &runtime.NewPollerFromResumeTokenOptions[AzureKeyVaultSecretProviderClassesClientDeleteResponse]{ + Tracer: client.internal.Tracer(), + }) + } +} + +// Delete - Deletes an AzureKeyVaultSecretProviderClass instance. +// If the operation fails it returns an *azcore.ResponseError type. +// +// Generated from API version 2024-08-21-preview +func (client *AzureKeyVaultSecretProviderClassesClient) deleteOperation(ctx context.Context, resourceGroupName string, azureKeyVaultSecretProviderClassName string, options *AzureKeyVaultSecretProviderClassesClientBeginDeleteOptions) (*http.Response, error) { + var err error + const operationName = "AzureKeyVaultSecretProviderClassesClient.BeginDelete" + ctx = context.WithValue(ctx, runtime.CtxAPINameKey{}, operationName) + ctx, endSpan := runtime.StartSpan(ctx, operationName, client.internal.Tracer(), nil) + defer func() { endSpan(err) }() + req, err := client.deleteCreateRequest(ctx, resourceGroupName, azureKeyVaultSecretProviderClassName, options) + if err != nil { + return nil, err + } + httpResp, err := client.internal.Pipeline().Do(req) + if err != nil { + return nil, err + } + if !runtime.HasStatusCode(httpResp, http.StatusAccepted, http.StatusNoContent) { + err = runtime.NewResponseError(httpResp) + return nil, err + } + return httpResp, nil +} + +// deleteCreateRequest creates the Delete request. +func (client *AzureKeyVaultSecretProviderClassesClient) deleteCreateRequest(ctx context.Context, resourceGroupName string, azureKeyVaultSecretProviderClassName string, _ *AzureKeyVaultSecretProviderClassesClientBeginDeleteOptions) (*policy.Request, error) { + urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.SecretSyncController/azureKeyVaultSecretProviderClasses/{azureKeyVaultSecretProviderClassName}" + if client.subscriptionID == "" { + return nil, errors.New("parameter client.subscriptionID cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) + if resourceGroupName == "" { + return nil, errors.New("parameter resourceGroupName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName)) + if azureKeyVaultSecretProviderClassName == "" { + return nil, errors.New("parameter azureKeyVaultSecretProviderClassName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{azureKeyVaultSecretProviderClassName}", url.PathEscape(azureKeyVaultSecretProviderClassName)) + req, err := runtime.NewRequest(ctx, http.MethodDelete, runtime.JoinPaths(client.internal.Endpoint(), urlPath)) + if err != nil { + return nil, err + } + reqQP := req.Raw().URL.Query() + reqQP.Set("api-version", "2024-08-21-preview") + req.Raw().URL.RawQuery = reqQP.Encode() + req.Raw().Header["Accept"] = []string{"application/json"} + return req, nil +} + +// Get - Gets the properties of an AzureKeyVaultSecretProviderClass instance. +// If the operation fails it returns an *azcore.ResponseError type. +// +// Generated from API version 2024-08-21-preview +// - resourceGroupName - The name of the resource group. The name is case insensitive. +// - azureKeyVaultSecretProviderClassName - The name of the AzureKeyVaultSecretProviderClass +// - options - AzureKeyVaultSecretProviderClassesClientGetOptions contains the optional parameters for the AzureKeyVaultSecretProviderClassesClient.Get +// method. +func (client *AzureKeyVaultSecretProviderClassesClient) Get(ctx context.Context, resourceGroupName string, azureKeyVaultSecretProviderClassName string, options *AzureKeyVaultSecretProviderClassesClientGetOptions) (AzureKeyVaultSecretProviderClassesClientGetResponse, error) { + var err error + const operationName = "AzureKeyVaultSecretProviderClassesClient.Get" + ctx = context.WithValue(ctx, runtime.CtxAPINameKey{}, operationName) + ctx, endSpan := runtime.StartSpan(ctx, operationName, client.internal.Tracer(), nil) + defer func() { endSpan(err) }() + req, err := client.getCreateRequest(ctx, resourceGroupName, azureKeyVaultSecretProviderClassName, options) + if err != nil { + return AzureKeyVaultSecretProviderClassesClientGetResponse{}, err + } + httpResp, err := client.internal.Pipeline().Do(req) + if err != nil { + return AzureKeyVaultSecretProviderClassesClientGetResponse{}, err + } + if !runtime.HasStatusCode(httpResp, http.StatusOK) { + err = runtime.NewResponseError(httpResp) + return AzureKeyVaultSecretProviderClassesClientGetResponse{}, err + } + resp, err := client.getHandleResponse(httpResp) + return resp, err +} + +// getCreateRequest creates the Get request. +func (client *AzureKeyVaultSecretProviderClassesClient) getCreateRequest(ctx context.Context, resourceGroupName string, azureKeyVaultSecretProviderClassName string, _ *AzureKeyVaultSecretProviderClassesClientGetOptions) (*policy.Request, error) { + urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.SecretSyncController/azureKeyVaultSecretProviderClasses/{azureKeyVaultSecretProviderClassName}" + if client.subscriptionID == "" { + return nil, errors.New("parameter client.subscriptionID cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) + if resourceGroupName == "" { + return nil, errors.New("parameter resourceGroupName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName)) + if azureKeyVaultSecretProviderClassName == "" { + return nil, errors.New("parameter azureKeyVaultSecretProviderClassName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{azureKeyVaultSecretProviderClassName}", url.PathEscape(azureKeyVaultSecretProviderClassName)) + req, err := runtime.NewRequest(ctx, http.MethodGet, runtime.JoinPaths(client.internal.Endpoint(), urlPath)) + if err != nil { + return nil, err + } + reqQP := req.Raw().URL.Query() + reqQP.Set("api-version", "2024-08-21-preview") + req.Raw().URL.RawQuery = reqQP.Encode() + req.Raw().Header["Accept"] = []string{"application/json"} + return req, nil +} + +// getHandleResponse handles the Get response. +func (client *AzureKeyVaultSecretProviderClassesClient) getHandleResponse(resp *http.Response) (AzureKeyVaultSecretProviderClassesClientGetResponse, error) { + result := AzureKeyVaultSecretProviderClassesClientGetResponse{} + if err := runtime.UnmarshalAsJSON(resp, &result.AzureKeyVaultSecretProviderClass); err != nil { + return AzureKeyVaultSecretProviderClassesClientGetResponse{}, err + } + return result, nil +} + +// NewListByResourceGroupPager - Lists the AzureKeyVaultSecretProviderClass instances within a resource group. +// +// Generated from API version 2024-08-21-preview +// - resourceGroupName - The name of the resource group. The name is case insensitive. +// - options - AzureKeyVaultSecretProviderClassesClientListByResourceGroupOptions contains the optional parameters for the AzureKeyVaultSecretProviderClassesClient.NewListByResourceGroupPager +// method. +func (client *AzureKeyVaultSecretProviderClassesClient) NewListByResourceGroupPager(resourceGroupName string, options *AzureKeyVaultSecretProviderClassesClientListByResourceGroupOptions) *runtime.Pager[AzureKeyVaultSecretProviderClassesClientListByResourceGroupResponse] { + return runtime.NewPager(runtime.PagingHandler[AzureKeyVaultSecretProviderClassesClientListByResourceGroupResponse]{ + More: func(page AzureKeyVaultSecretProviderClassesClientListByResourceGroupResponse) bool { + return page.NextLink != nil && len(*page.NextLink) > 0 + }, + Fetcher: func(ctx context.Context, page *AzureKeyVaultSecretProviderClassesClientListByResourceGroupResponse) (AzureKeyVaultSecretProviderClassesClientListByResourceGroupResponse, error) { + ctx = context.WithValue(ctx, runtime.CtxAPINameKey{}, "AzureKeyVaultSecretProviderClassesClient.NewListByResourceGroupPager") + nextLink := "" + if page != nil { + nextLink = *page.NextLink + } + resp, err := runtime.FetcherForNextLink(ctx, client.internal.Pipeline(), nextLink, func(ctx context.Context) (*policy.Request, error) { + return client.listByResourceGroupCreateRequest(ctx, resourceGroupName, options) + }, nil) + if err != nil { + return AzureKeyVaultSecretProviderClassesClientListByResourceGroupResponse{}, err + } + return client.listByResourceGroupHandleResponse(resp) + }, + Tracer: client.internal.Tracer(), + }) +} + +// listByResourceGroupCreateRequest creates the ListByResourceGroup request. +func (client *AzureKeyVaultSecretProviderClassesClient) listByResourceGroupCreateRequest(ctx context.Context, resourceGroupName string, _ *AzureKeyVaultSecretProviderClassesClientListByResourceGroupOptions) (*policy.Request, error) { + urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.SecretSyncController/azureKeyVaultSecretProviderClasses" + if client.subscriptionID == "" { + return nil, errors.New("parameter client.subscriptionID cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) + if resourceGroupName == "" { + return nil, errors.New("parameter resourceGroupName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName)) + req, err := runtime.NewRequest(ctx, http.MethodGet, runtime.JoinPaths(client.internal.Endpoint(), urlPath)) + if err != nil { + return nil, err + } + reqQP := req.Raw().URL.Query() + reqQP.Set("api-version", "2024-08-21-preview") + req.Raw().URL.RawQuery = reqQP.Encode() + req.Raw().Header["Accept"] = []string{"application/json"} + return req, nil +} + +// listByResourceGroupHandleResponse handles the ListByResourceGroup response. +func (client *AzureKeyVaultSecretProviderClassesClient) listByResourceGroupHandleResponse(resp *http.Response) (AzureKeyVaultSecretProviderClassesClientListByResourceGroupResponse, error) { + result := AzureKeyVaultSecretProviderClassesClientListByResourceGroupResponse{} + if err := runtime.UnmarshalAsJSON(resp, &result.AzureKeyVaultSecretProviderClassListResult); err != nil { + return AzureKeyVaultSecretProviderClassesClientListByResourceGroupResponse{}, err + } + return result, nil +} + +// NewListBySubscriptionPager - Lists the AzureKeyVaultSecretProviderClass instances within an Azure subscription. +// +// Generated from API version 2024-08-21-preview +// - options - AzureKeyVaultSecretProviderClassesClientListBySubscriptionOptions contains the optional parameters for the AzureKeyVaultSecretProviderClassesClient.NewListBySubscriptionPager +// method. +func (client *AzureKeyVaultSecretProviderClassesClient) NewListBySubscriptionPager(options *AzureKeyVaultSecretProviderClassesClientListBySubscriptionOptions) *runtime.Pager[AzureKeyVaultSecretProviderClassesClientListBySubscriptionResponse] { + return runtime.NewPager(runtime.PagingHandler[AzureKeyVaultSecretProviderClassesClientListBySubscriptionResponse]{ + More: func(page AzureKeyVaultSecretProviderClassesClientListBySubscriptionResponse) bool { + return page.NextLink != nil && len(*page.NextLink) > 0 + }, + Fetcher: func(ctx context.Context, page *AzureKeyVaultSecretProviderClassesClientListBySubscriptionResponse) (AzureKeyVaultSecretProviderClassesClientListBySubscriptionResponse, error) { + ctx = context.WithValue(ctx, runtime.CtxAPINameKey{}, "AzureKeyVaultSecretProviderClassesClient.NewListBySubscriptionPager") + nextLink := "" + if page != nil { + nextLink = *page.NextLink + } + resp, err := runtime.FetcherForNextLink(ctx, client.internal.Pipeline(), nextLink, func(ctx context.Context) (*policy.Request, error) { + return client.listBySubscriptionCreateRequest(ctx, options) + }, nil) + if err != nil { + return AzureKeyVaultSecretProviderClassesClientListBySubscriptionResponse{}, err + } + return client.listBySubscriptionHandleResponse(resp) + }, + Tracer: client.internal.Tracer(), + }) +} + +// listBySubscriptionCreateRequest creates the ListBySubscription request. +func (client *AzureKeyVaultSecretProviderClassesClient) listBySubscriptionCreateRequest(ctx context.Context, _ *AzureKeyVaultSecretProviderClassesClientListBySubscriptionOptions) (*policy.Request, error) { + urlPath := "/subscriptions/{subscriptionId}/providers/Microsoft.SecretSyncController/azureKeyVaultSecretProviderClasses" + if client.subscriptionID == "" { + return nil, errors.New("parameter client.subscriptionID cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) + req, err := runtime.NewRequest(ctx, http.MethodGet, runtime.JoinPaths(client.internal.Endpoint(), urlPath)) + if err != nil { + return nil, err + } + reqQP := req.Raw().URL.Query() + reqQP.Set("api-version", "2024-08-21-preview") + req.Raw().URL.RawQuery = reqQP.Encode() + req.Raw().Header["Accept"] = []string{"application/json"} + return req, nil +} + +// listBySubscriptionHandleResponse handles the ListBySubscription response. +func (client *AzureKeyVaultSecretProviderClassesClient) listBySubscriptionHandleResponse(resp *http.Response) (AzureKeyVaultSecretProviderClassesClientListBySubscriptionResponse, error) { + result := AzureKeyVaultSecretProviderClassesClientListBySubscriptionResponse{} + if err := runtime.UnmarshalAsJSON(resp, &result.AzureKeyVaultSecretProviderClassListResult); err != nil { + return AzureKeyVaultSecretProviderClassesClientListBySubscriptionResponse{}, err + } + return result, nil +} + +// BeginUpdate - Updates an AzureKeyVaultSecretProviderClass instance. +// If the operation fails it returns an *azcore.ResponseError type. +// +// Generated from API version 2024-08-21-preview +// - resourceGroupName - The name of the resource group. The name is case insensitive. +// - azureKeyVaultSecretProviderClassName - The name of the AzureKeyVaultSecretProviderClass +// - properties - The resource properties to be updated. +// - options - AzureKeyVaultSecretProviderClassesClientBeginUpdateOptions contains the optional parameters for the AzureKeyVaultSecretProviderClassesClient.BeginUpdate +// method. +func (client *AzureKeyVaultSecretProviderClassesClient) BeginUpdate(ctx context.Context, resourceGroupName string, azureKeyVaultSecretProviderClassName string, properties AzureKeyVaultSecretProviderClassUpdate, options *AzureKeyVaultSecretProviderClassesClientBeginUpdateOptions) (*runtime.Poller[AzureKeyVaultSecretProviderClassesClientUpdateResponse], error) { + if options == nil || options.ResumeToken == "" { + resp, err := client.update(ctx, resourceGroupName, azureKeyVaultSecretProviderClassName, properties, options) + if err != nil { + return nil, err + } + poller, err := runtime.NewPoller(resp, client.internal.Pipeline(), &runtime.NewPollerOptions[AzureKeyVaultSecretProviderClassesClientUpdateResponse]{ + Tracer: client.internal.Tracer(), + }) + return poller, err + } else { + return runtime.NewPollerFromResumeToken(options.ResumeToken, client.internal.Pipeline(), &runtime.NewPollerFromResumeTokenOptions[AzureKeyVaultSecretProviderClassesClientUpdateResponse]{ + Tracer: client.internal.Tracer(), + }) + } +} + +// Update - Updates an AzureKeyVaultSecretProviderClass instance. +// If the operation fails it returns an *azcore.ResponseError type. +// +// Generated from API version 2024-08-21-preview +func (client *AzureKeyVaultSecretProviderClassesClient) update(ctx context.Context, resourceGroupName string, azureKeyVaultSecretProviderClassName string, properties AzureKeyVaultSecretProviderClassUpdate, options *AzureKeyVaultSecretProviderClassesClientBeginUpdateOptions) (*http.Response, error) { + var err error + const operationName = "AzureKeyVaultSecretProviderClassesClient.BeginUpdate" + ctx = context.WithValue(ctx, runtime.CtxAPINameKey{}, operationName) + ctx, endSpan := runtime.StartSpan(ctx, operationName, client.internal.Tracer(), nil) + defer func() { endSpan(err) }() + req, err := client.updateCreateRequest(ctx, resourceGroupName, azureKeyVaultSecretProviderClassName, properties, options) + if err != nil { + return nil, err + } + httpResp, err := client.internal.Pipeline().Do(req) + if err != nil { + return nil, err + } + if !runtime.HasStatusCode(httpResp, http.StatusOK, http.StatusAccepted) { + err = runtime.NewResponseError(httpResp) + return nil, err + } + return httpResp, nil +} + +// updateCreateRequest creates the Update request. +func (client *AzureKeyVaultSecretProviderClassesClient) updateCreateRequest(ctx context.Context, resourceGroupName string, azureKeyVaultSecretProviderClassName string, properties AzureKeyVaultSecretProviderClassUpdate, _ *AzureKeyVaultSecretProviderClassesClientBeginUpdateOptions) (*policy.Request, error) { + urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.SecretSyncController/azureKeyVaultSecretProviderClasses/{azureKeyVaultSecretProviderClassName}" + if client.subscriptionID == "" { + return nil, errors.New("parameter client.subscriptionID cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) + if resourceGroupName == "" { + return nil, errors.New("parameter resourceGroupName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName)) + if azureKeyVaultSecretProviderClassName == "" { + return nil, errors.New("parameter azureKeyVaultSecretProviderClassName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{azureKeyVaultSecretProviderClassName}", url.PathEscape(azureKeyVaultSecretProviderClassName)) + req, err := runtime.NewRequest(ctx, http.MethodPatch, runtime.JoinPaths(client.internal.Endpoint(), urlPath)) + if err != nil { + return nil, err + } + reqQP := req.Raw().URL.Query() + reqQP.Set("api-version", "2024-08-21-preview") + req.Raw().URL.RawQuery = reqQP.Encode() + req.Raw().Header["Accept"] = []string{"application/json"} + req.Raw().Header["Content-Type"] = []string{"application/json"} + if err := runtime.MarshalAsJSON(req, properties); err != nil { + return nil, err + } + return req, nil +} diff --git a/sdk/resourcemanager/secretsstoreextension/armsecretsstoreextension/azurekeyvaultsecretproviderclasses_client_example_test.go b/sdk/resourcemanager/secretsstoreextension/armsecretsstoreextension/azurekeyvaultsecretproviderclasses_client_example_test.go new file mode 100644 index 000000000000..3d7ac28f2e8c --- /dev/null +++ b/sdk/resourcemanager/secretsstoreextension/armsecretsstoreextension/azurekeyvaultsecretproviderclasses_client_example_test.go @@ -0,0 +1,292 @@ +// 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) Go Code Generator. DO NOT EDIT. + +package armsecretsstoreextension_test + +import ( + "context" + "github.com/Azure/azure-sdk-for-go/sdk/azcore/to" + "github.com/Azure/azure-sdk-for-go/sdk/azidentity" + "github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/secretsstoreextension/armsecretsstoreextension" + "log" +) + +// Generated from example definition: 2024-08-21-preview/AzureKeyVaultSecretProviderClasses_CreateOrUpdate_MaximumSet_Gen.json +func ExampleAzureKeyVaultSecretProviderClassesClient_BeginCreateOrUpdate() { + cred, err := azidentity.NewDefaultAzureCredential(nil) + if err != nil { + log.Fatalf("failed to obtain a credential: %v", err) + } + ctx := context.Background() + clientFactory, err := armsecretsstoreextension.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil) + if err != nil { + log.Fatalf("failed to create client: %v", err) + } + poller, err := clientFactory.NewAzureKeyVaultSecretProviderClassesClient().BeginCreateOrUpdate(ctx, "rg-ssc-example", "akvspc-ssc-example", armsecretsstoreextension.AzureKeyVaultSecretProviderClass{ + Properties: &armsecretsstoreextension.AzureKeyVaultSecretProviderClassProperties{ + KeyvaultName: to.Ptr("example-ssc-key-vault"), + ClientID: to.Ptr("00000000-0000-0000-0000-000000000000"), + TenantID: to.Ptr("00000000-0000-0000-0000-000000000000"), + Objects: to.Ptr("array: |\n - |\n objectName: my-secret-object\n objectType: secret\n objectVersionHistory: 1"), + }, + ExtendedLocation: &armsecretsstoreextension.ExtendedLocation{ + Name: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg-ssc-example/providers/Microsoft.ExtendedLocation/customLocations/example-custom-location"), + Type: to.Ptr(armsecretsstoreextension.ExtendedLocationTypeCustomLocation), + }, + Tags: map[string]*string{ + "example-tag": to.Ptr("example-tag-value"), + }, + Location: to.Ptr("eastus"), + }, nil) + if err != nil { + log.Fatalf("failed to finish the request: %v", err) + } + res, err := poller.PollUntilDone(ctx, nil) + if err != nil { + log.Fatalf("failed to pull the result: %v", err) + } + // You could use response here. We use blank identifier for just demo purposes. + _ = res + // If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes. + // res = armsecretsstoreextension.AzureKeyVaultSecretProviderClassesClientCreateOrUpdateResponse{ + // AzureKeyVaultSecretProviderClass: &armsecretsstoreextension.AzureKeyVaultSecretProviderClass{ + // Properties: &armsecretsstoreextension.AzureKeyVaultSecretProviderClassProperties{ + // ProvisioningState: to.Ptr(armsecretsstoreextension.ProvisioningStateSucceeded), + // KeyvaultName: to.Ptr("example-ssc-key-vault"), + // ClientID: to.Ptr("00000000-0000-0000-0000-000000000000"), + // TenantID: to.Ptr("00000000-0000-0000-0000-000000000000"), + // Objects: to.Ptr("array: |\n - |\n objectName: my-secret-object\n objectType: secret\n objectVersionHistory: 1"), + // }, + // ExtendedLocation: &armsecretsstoreextension.ExtendedLocation{ + // Name: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg-ssc-example/providers/Microsoft.ExtendedLocation/customLocations/example-custom-location"), + // Type: to.Ptr(armsecretsstoreextension.ExtendedLocationTypeCustomLocation), + // }, + // Tags: map[string]*string{ + // "example-tag": to.Ptr("example-tag-value"), + // }, + // Location: to.Ptr("eastus"), + // ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg-ssc-example/providers/Microsoft.SecretSyncController/azurekeyvaultsecretproviderclass/akvssc-example"), + // Name: to.Ptr("akvspc-ssc-example"), + // }, + // } +} + +// Generated from example definition: 2024-08-21-preview/AzureKeyVaultSecretProviderClasses_Delete_MaximumSet_Gen.json +func ExampleAzureKeyVaultSecretProviderClassesClient_BeginDelete() { + cred, err := azidentity.NewDefaultAzureCredential(nil) + if err != nil { + log.Fatalf("failed to obtain a credential: %v", err) + } + ctx := context.Background() + clientFactory, err := armsecretsstoreextension.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil) + if err != nil { + log.Fatalf("failed to create client: %v", err) + } + poller, err := clientFactory.NewAzureKeyVaultSecretProviderClassesClient().BeginDelete(ctx, "rg-ssc-example", "akvspc-ssc-example", nil) + if err != nil { + log.Fatalf("failed to finish the request: %v", err) + } + _, err = poller.PollUntilDone(ctx, nil) + if err != nil { + log.Fatalf("failed to pull the result: %v", err) + } +} + +// Generated from example definition: 2024-08-21-preview/AzureKeyVaultSecretProviderClasses_Get_MaximumSet_Gen.json +func ExampleAzureKeyVaultSecretProviderClassesClient_Get() { + cred, err := azidentity.NewDefaultAzureCredential(nil) + if err != nil { + log.Fatalf("failed to obtain a credential: %v", err) + } + ctx := context.Background() + clientFactory, err := armsecretsstoreextension.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil) + if err != nil { + log.Fatalf("failed to create client: %v", err) + } + res, err := clientFactory.NewAzureKeyVaultSecretProviderClassesClient().Get(ctx, "rg-ssc-example", "akvspc-ssc-example", nil) + if err != nil { + log.Fatalf("failed to finish the request: %v", err) + } + // You could use response here. We use blank identifier for just demo purposes. + _ = res + // If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes. + // res = armsecretsstoreextension.AzureKeyVaultSecretProviderClassesClientGetResponse{ + // AzureKeyVaultSecretProviderClass: &armsecretsstoreextension.AzureKeyVaultSecretProviderClass{ + // Properties: &armsecretsstoreextension.AzureKeyVaultSecretProviderClassProperties{ + // ProvisioningState: to.Ptr(armsecretsstoreextension.ProvisioningStateSucceeded), + // KeyvaultName: to.Ptr("example-ssc-key-vault"), + // ClientID: to.Ptr("00000000-0000-0000-0000-000000000000"), + // TenantID: to.Ptr("00000000-0000-0000-0000-000000000000"), + // Objects: to.Ptr("array: |\n - |\n objectName: my-secret-object\n objectType: secret\n objectVersionHistory: 1"), + // }, + // ExtendedLocation: &armsecretsstoreextension.ExtendedLocation{ + // Name: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg-ssc-example/providers/Microsoft.ExtendedLocation/customLocations/example-custom-location"), + // Type: to.Ptr(armsecretsstoreextension.ExtendedLocationTypeCustomLocation), + // }, + // Tags: map[string]*string{ + // "example-tag": to.Ptr("example-tag-value"), + // }, + // Location: to.Ptr("eastus"), + // ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg-ssc-example/providers/Microsoft.SecretSyncController/azurekeyvaultsecretproviderclass/akvssc-example"), + // Name: to.Ptr("akvspc-ssc-example"), + // }, + // } +} + +// Generated from example definition: 2024-08-21-preview/AzureKeyVaultSecretProviderClasses_ListByResourceGroup_MaximumSet_Gen.json +func ExampleAzureKeyVaultSecretProviderClassesClient_NewListByResourceGroupPager() { + cred, err := azidentity.NewDefaultAzureCredential(nil) + if err != nil { + log.Fatalf("failed to obtain a credential: %v", err) + } + ctx := context.Background() + clientFactory, err := armsecretsstoreextension.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil) + if err != nil { + log.Fatalf("failed to create client: %v", err) + } + pager := clientFactory.NewAzureKeyVaultSecretProviderClassesClient().NewListByResourceGroupPager("rg-ssc-example", nil) + for pager.More() { + page, err := pager.NextPage(ctx) + if err != nil { + log.Fatalf("failed to advance page: %v", err) + } + for _, v := range page.Value { + // You could use page here. We use blank identifier for just demo purposes. + _ = v + } + // If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes. + // page = armsecretsstoreextension.AzureKeyVaultSecretProviderClassesClientListByResourceGroupResponse{ + // AzureKeyVaultSecretProviderClassListResult: armsecretsstoreextension.AzureKeyVaultSecretProviderClassListResult{ + // Value: []*armsecretsstoreextension.AzureKeyVaultSecretProviderClass{ + // { + // Properties: &armsecretsstoreextension.AzureKeyVaultSecretProviderClassProperties{ + // ProvisioningState: to.Ptr(armsecretsstoreextension.ProvisioningStateSucceeded), + // KeyvaultName: to.Ptr("example-ssc-key-vault"), + // ClientID: to.Ptr("00000000-0000-0000-0000-000000000000"), + // TenantID: to.Ptr("00000000-0000-0000-0000-000000000000"), + // Objects: to.Ptr("array: |\n - |\n objectName: my-secret-object\n objectType: secret\n objectVersionHistory: 1"), + // }, + // ExtendedLocation: &armsecretsstoreextension.ExtendedLocation{ + // Name: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg-ssc-example/providers/Microsoft.ExtendedLocation/customLocations/example-custom-location"), + // Type: to.Ptr(armsecretsstoreextension.ExtendedLocationTypeCustomLocation), + // }, + // Tags: map[string]*string{ + // "example-tag": to.Ptr("example-tag-value"), + // }, + // Location: to.Ptr("eastus"), + // ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg-ssc-example/providers/Microsoft.SecretSyncController/azurekeyvaultsecretproviderclass/akvssc-example"), + // Name: to.Ptr("akvspc-ssc-example"), + // }, + // }, + // NextLink: to.Ptr("https://microsoft.com/aolkmb"), + // }, + // } + } +} + +// Generated from example definition: 2024-08-21-preview/AzureKeyVaultSecretProviderClasses_ListBySubscription_MaximumSet_Gen.json +func ExampleAzureKeyVaultSecretProviderClassesClient_NewListBySubscriptionPager() { + cred, err := azidentity.NewDefaultAzureCredential(nil) + if err != nil { + log.Fatalf("failed to obtain a credential: %v", err) + } + ctx := context.Background() + clientFactory, err := armsecretsstoreextension.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil) + if err != nil { + log.Fatalf("failed to create client: %v", err) + } + pager := clientFactory.NewAzureKeyVaultSecretProviderClassesClient().NewListBySubscriptionPager(nil) + for pager.More() { + page, err := pager.NextPage(ctx) + if err != nil { + log.Fatalf("failed to advance page: %v", err) + } + for _, v := range page.Value { + // You could use page here. We use blank identifier for just demo purposes. + _ = v + } + // If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes. + // page = armsecretsstoreextension.AzureKeyVaultSecretProviderClassesClientListBySubscriptionResponse{ + // AzureKeyVaultSecretProviderClassListResult: armsecretsstoreextension.AzureKeyVaultSecretProviderClassListResult{ + // Value: []*armsecretsstoreextension.AzureKeyVaultSecretProviderClass{ + // { + // Properties: &armsecretsstoreextension.AzureKeyVaultSecretProviderClassProperties{ + // ProvisioningState: to.Ptr(armsecretsstoreextension.ProvisioningStateSucceeded), + // KeyvaultName: to.Ptr("example-ssc-key-vault"), + // ClientID: to.Ptr("00000000-0000-0000-0000-000000000000"), + // TenantID: to.Ptr("00000000-0000-0000-0000-000000000000"), + // Objects: to.Ptr("array: |\n - |\n objectName: my-secret-object\n objectType: secret\n objectVersionHistory: 1"), + // }, + // ExtendedLocation: &armsecretsstoreextension.ExtendedLocation{ + // Name: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg-ssc-example/providers/Microsoft.ExtendedLocation/customLocations/example-custom-location"), + // Type: to.Ptr(armsecretsstoreextension.ExtendedLocationTypeCustomLocation), + // }, + // Tags: map[string]*string{ + // "example-tag": to.Ptr("example-tag-value"), + // }, + // Location: to.Ptr("eastus"), + // ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg-ssc-example/providers/Microsoft.SecretSyncController/azurekeyvaultsecretproviderclass/akvssc-example"), + // Name: to.Ptr("akvspc-ssc-example"), + // }, + // }, + // NextLink: to.Ptr("https://microsoft.com/aolkmb"), + // }, + // } + } +} + +// Generated from example definition: 2024-08-21-preview/AzureKeyVaultSecretProviderClasses_Update_MaximumSet_Gen.json +func ExampleAzureKeyVaultSecretProviderClassesClient_BeginUpdate() { + cred, err := azidentity.NewDefaultAzureCredential(nil) + if err != nil { + log.Fatalf("failed to obtain a credential: %v", err) + } + ctx := context.Background() + clientFactory, err := armsecretsstoreextension.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil) + if err != nil { + log.Fatalf("failed to create client: %v", err) + } + poller, err := clientFactory.NewAzureKeyVaultSecretProviderClassesClient().BeginUpdate(ctx, "rg-ssc-example", "akvspc-ssc-example", armsecretsstoreextension.AzureKeyVaultSecretProviderClassUpdate{ + Tags: map[string]*string{ + "example-tag": to.Ptr("example-tag-value"), + }, + Properties: &armsecretsstoreextension.AzureKeyVaultSecretProviderClassUpdateProperties{ + KeyvaultName: to.Ptr("example-ssc-key-vault"), + ClientID: to.Ptr("00000000-0000-0000-0000-000000000000"), + TenantID: to.Ptr("00000000-0000-0000-0000-000000000000"), + Objects: to.Ptr("array: |\n - |\n objectName: my-secret-object\n objectType: secret\n objectVersionHistory: 1"), + }, + }, nil) + if err != nil { + log.Fatalf("failed to finish the request: %v", err) + } + res, err := poller.PollUntilDone(ctx, nil) + if err != nil { + log.Fatalf("failed to pull the result: %v", err) + } + // You could use response here. We use blank identifier for just demo purposes. + _ = res + // If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes. + // res = armsecretsstoreextension.AzureKeyVaultSecretProviderClassesClientUpdateResponse{ + // AzureKeyVaultSecretProviderClass: &armsecretsstoreextension.AzureKeyVaultSecretProviderClass{ + // Properties: &armsecretsstoreextension.AzureKeyVaultSecretProviderClassProperties{ + // ProvisioningState: to.Ptr(armsecretsstoreextension.ProvisioningStateSucceeded), + // KeyvaultName: to.Ptr("example-ssc-key-vault"), + // ClientID: to.Ptr("00000000-0000-0000-0000-000000000000"), + // TenantID: to.Ptr("00000000-0000-0000-0000-000000000000"), + // Objects: to.Ptr("array: |\n - |\n objectName: my-secret-object\n objectType: secret\n objectVersionHistory: 1"), + // }, + // ExtendedLocation: &armsecretsstoreextension.ExtendedLocation{ + // Name: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg-ssc-example/providers/Microsoft.ExtendedLocation/customLocations/example-custom-location"), + // Type: to.Ptr(armsecretsstoreextension.ExtendedLocationTypeCustomLocation), + // }, + // Tags: map[string]*string{ + // "example-tag": to.Ptr("example-tag-value"), + // }, + // Location: to.Ptr("eastus"), + // ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg-ssc-example/providers/Microsoft.SecretSyncController/azurekeyvaultsecretproviderclass/akvssc-example"), + // Name: to.Ptr("akvspc-ssc-example"), + // }, + // } +} diff --git a/sdk/resourcemanager/secretsstoreextension/armsecretsstoreextension/ci.yml b/sdk/resourcemanager/secretsstoreextension/armsecretsstoreextension/ci.yml new file mode 100644 index 000000000000..e85474a9efd7 --- /dev/null +++ b/sdk/resourcemanager/secretsstoreextension/armsecretsstoreextension/ci.yml @@ -0,0 +1,27 @@ +# NOTE: Please refer to https://aka.ms/azsdk/engsys/ci-yaml before editing this file. +trigger: + branches: + include: + - main + - feature/* + - hotfix/* + - release/* + paths: + include: + - sdk/resourcemanager/secretsstoreextension/armsecretsstoreextension/ + +pr: + branches: + include: + - main + - feature/* + - hotfix/* + - release/* + paths: + include: + - sdk/resourcemanager/secretsstoreextension/armsecretsstoreextension/ + +extends: + template: /eng/pipelines/templates/jobs/archetype-sdk-client.yml + parameters: + ServiceDirectory: 'resourcemanager/secretsstoreextension/armsecretsstoreextension' diff --git a/sdk/resourcemanager/secretsstoreextension/armsecretsstoreextension/client_factory.go b/sdk/resourcemanager/secretsstoreextension/armsecretsstoreextension/client_factory.go new file mode 100644 index 000000000000..7cc8235b8191 --- /dev/null +++ b/sdk/resourcemanager/secretsstoreextension/armsecretsstoreextension/client_factory.go @@ -0,0 +1,56 @@ +// 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) Go Code Generator. DO NOT EDIT. + +package armsecretsstoreextension + +import ( + "github.com/Azure/azure-sdk-for-go/sdk/azcore" + "github.com/Azure/azure-sdk-for-go/sdk/azcore/arm" +) + +// ClientFactory is a client factory used to create any client in this module. +// Don't use this type directly, use NewClientFactory instead. +type ClientFactory struct { + subscriptionID string + internal *arm.Client +} + +// NewClientFactory creates a new instance of ClientFactory with the specified values. +// The parameter values will be propagated to any client created from this factory. +// - subscriptionID - The ID of the target subscription. The value must be an UUID. +// - credential - used to authorize requests. Usually a credential from azidentity. +// - options - pass nil to accept the default values. +func NewClientFactory(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*ClientFactory, error) { + internal, err := arm.NewClient(moduleName, moduleVersion, credential, options) + if err != nil { + return nil, err + } + return &ClientFactory{ + subscriptionID: subscriptionID, + internal: internal, + }, nil +} + +// NewAzureKeyVaultSecretProviderClassesClient creates a new instance of AzureKeyVaultSecretProviderClassesClient. +func (c *ClientFactory) NewAzureKeyVaultSecretProviderClassesClient() *AzureKeyVaultSecretProviderClassesClient { + return &AzureKeyVaultSecretProviderClassesClient{ + subscriptionID: c.subscriptionID, + internal: c.internal, + } +} + +// NewOperationsClient creates a new instance of OperationsClient. +func (c *ClientFactory) NewOperationsClient() *OperationsClient { + return &OperationsClient{ + internal: c.internal, + } +} + +// NewSecretSyncsClient creates a new instance of SecretSyncsClient. +func (c *ClientFactory) NewSecretSyncsClient() *SecretSyncsClient { + return &SecretSyncsClient{ + subscriptionID: c.subscriptionID, + internal: c.internal, + } +} diff --git a/sdk/resourcemanager/secretsstoreextension/armsecretsstoreextension/constants.go b/sdk/resourcemanager/secretsstoreextension/armsecretsstoreextension/constants.go new file mode 100644 index 000000000000..23dbf1c21b5c --- /dev/null +++ b/sdk/resourcemanager/secretsstoreextension/armsecretsstoreextension/constants.go @@ -0,0 +1,150 @@ +// 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) Go Code Generator. DO NOT EDIT. + +package armsecretsstoreextension + +const ( + moduleName = "github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/secretsstoreextension/armsecretsstoreextension" + moduleVersion = "v0.1.0" +) + +// ActionType - Extensible enum. Indicates the action type. "Internal" refers to actions that are for internal only APIs. +type ActionType string + +const ( + // ActionTypeInternal - Actions are for internal-only APIs. + ActionTypeInternal ActionType = "Internal" +) + +// PossibleActionTypeValues returns the possible values for the ActionType const type. +func PossibleActionTypeValues() []ActionType { + return []ActionType{ + ActionTypeInternal, + } +} + +// CreatedByType - The kind of entity that created the resource. +type CreatedByType string + +const ( + // CreatedByTypeApplication - The entity was created by an application. + CreatedByTypeApplication CreatedByType = "Application" + // CreatedByTypeKey - The entity was created by a key. + CreatedByTypeKey CreatedByType = "Key" + // CreatedByTypeManagedIdentity - The entity was created by a managed identity. + CreatedByTypeManagedIdentity CreatedByType = "ManagedIdentity" + // CreatedByTypeUser - The entity was created by a user. + CreatedByTypeUser CreatedByType = "User" +) + +// PossibleCreatedByTypeValues returns the possible values for the CreatedByType const type. +func PossibleCreatedByTypeValues() []CreatedByType { + return []CreatedByType{ + CreatedByTypeApplication, + CreatedByTypeKey, + CreatedByTypeManagedIdentity, + CreatedByTypeUser, + } +} + +// ExtendedLocationType - The supported ExtendedLocation types. +type ExtendedLocationType string + +const ( + // ExtendedLocationTypeCustomLocation - Azure Custom Locations type + ExtendedLocationTypeCustomLocation ExtendedLocationType = "CustomLocation" + // ExtendedLocationTypeEdgeZone - Azure Edge Zones location type + ExtendedLocationTypeEdgeZone ExtendedLocationType = "EdgeZone" +) + +// PossibleExtendedLocationTypeValues returns the possible values for the ExtendedLocationType const type. +func PossibleExtendedLocationTypeValues() []ExtendedLocationType { + return []ExtendedLocationType{ + ExtendedLocationTypeCustomLocation, + ExtendedLocationTypeEdgeZone, + } +} + +// KubernetesSecretType - Supported Kubernetes secret types. +type KubernetesSecretType string + +const ( + // KubernetesSecretTypeOpaque - Opaque is the default secret type. + KubernetesSecretTypeOpaque KubernetesSecretType = "Opaque" + // KubernetesSecretTypeTLS - The kubernetes.io/tls secret type is for storing a certificate and its associated key that are + // typically used for TLS. + KubernetesSecretTypeTLS KubernetesSecretType = "kubernetes.io/tls" +) + +// PossibleKubernetesSecretTypeValues returns the possible values for the KubernetesSecretType const type. +func PossibleKubernetesSecretTypeValues() []KubernetesSecretType { + return []KubernetesSecretType{ + KubernetesSecretTypeOpaque, + KubernetesSecretTypeTLS, + } +} + +// Origin - The intended executor of the operation; as in Resource Based Access Control (RBAC) and audit logs UX. Default +// value is "user,system" +type Origin string + +const ( + // OriginSystem - Indicates the operation is initiated by a system. + OriginSystem Origin = "system" + // OriginUser - Indicates the operation is initiated by a user. + OriginUser Origin = "user" + // OriginUserSystem - Indicates the operation is initiated by a user or system. + OriginUserSystem Origin = "user,system" +) + +// PossibleOriginValues returns the possible values for the Origin const type. +func PossibleOriginValues() []Origin { + return []Origin{ + OriginSystem, + OriginUser, + OriginUserSystem, + } +} + +// ProvisioningState - Provisioning state of the resource. +type ProvisioningState string + +const ( + // ProvisioningStateCanceled - Resource creation was canceled. + ProvisioningStateCanceled ProvisioningState = "Canceled" + // ProvisioningStateFailed - Resource creation failed. + ProvisioningStateFailed ProvisioningState = "Failed" + // ProvisioningStateSucceeded - Resource has been created. + ProvisioningStateSucceeded ProvisioningState = "Succeeded" +) + +// PossibleProvisioningStateValues returns the possible values for the ProvisioningState const type. +func PossibleProvisioningStateValues() []ProvisioningState { + return []ProvisioningState{ + ProvisioningStateCanceled, + ProvisioningStateFailed, + ProvisioningStateSucceeded, + } +} + +// StatusConditionType - Status conditions types +type StatusConditionType string + +const ( + // StatusConditionTypeFalse - The status is false + StatusConditionTypeFalse StatusConditionType = "False" + // StatusConditionTypeTrue - The status is true + StatusConditionTypeTrue StatusConditionType = "True" + // StatusConditionTypeUnknown - The status is unknown + StatusConditionTypeUnknown StatusConditionType = "Unknown" +) + +// PossibleStatusConditionTypeValues returns the possible values for the StatusConditionType const type. +func PossibleStatusConditionTypeValues() []StatusConditionType { + return []StatusConditionType{ + StatusConditionTypeFalse, + StatusConditionTypeTrue, + StatusConditionTypeUnknown, + } +} diff --git a/sdk/resourcemanager/secretsstoreextension/armsecretsstoreextension/fake/azurekeyvaultsecretproviderclasses_server.go b/sdk/resourcemanager/secretsstoreextension/armsecretsstoreextension/fake/azurekeyvaultsecretproviderclasses_server.go new file mode 100644 index 000000000000..f3fbf2c1d57d --- /dev/null +++ b/sdk/resourcemanager/secretsstoreextension/armsecretsstoreextension/fake/azurekeyvaultsecretproviderclasses_server.go @@ -0,0 +1,374 @@ +// 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) Go Code Generator. DO NOT EDIT. + +package fake + +import ( + "context" + "errors" + "fmt" + azfake "github.com/Azure/azure-sdk-for-go/sdk/azcore/fake" + "github.com/Azure/azure-sdk-for-go/sdk/azcore/fake/server" + "github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime" + "github.com/Azure/azure-sdk-for-go/sdk/azcore/to" + "github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/secretsstoreextension/armsecretsstoreextension" + "net/http" + "net/url" + "regexp" +) + +// AzureKeyVaultSecretProviderClassesServer is a fake server for instances of the armsecretsstoreextension.AzureKeyVaultSecretProviderClassesClient type. +type AzureKeyVaultSecretProviderClassesServer struct { + // BeginCreateOrUpdate is the fake for method AzureKeyVaultSecretProviderClassesClient.BeginCreateOrUpdate + // HTTP status codes to indicate success: http.StatusOK, http.StatusCreated + BeginCreateOrUpdate func(ctx context.Context, resourceGroupName string, azureKeyVaultSecretProviderClassName string, resource armsecretsstoreextension.AzureKeyVaultSecretProviderClass, options *armsecretsstoreextension.AzureKeyVaultSecretProviderClassesClientBeginCreateOrUpdateOptions) (resp azfake.PollerResponder[armsecretsstoreextension.AzureKeyVaultSecretProviderClassesClientCreateOrUpdateResponse], errResp azfake.ErrorResponder) + + // BeginDelete is the fake for method AzureKeyVaultSecretProviderClassesClient.BeginDelete + // HTTP status codes to indicate success: http.StatusOK, http.StatusAccepted, http.StatusNoContent + BeginDelete func(ctx context.Context, resourceGroupName string, azureKeyVaultSecretProviderClassName string, options *armsecretsstoreextension.AzureKeyVaultSecretProviderClassesClientBeginDeleteOptions) (resp azfake.PollerResponder[armsecretsstoreextension.AzureKeyVaultSecretProviderClassesClientDeleteResponse], errResp azfake.ErrorResponder) + + // Get is the fake for method AzureKeyVaultSecretProviderClassesClient.Get + // HTTP status codes to indicate success: http.StatusOK + Get func(ctx context.Context, resourceGroupName string, azureKeyVaultSecretProviderClassName string, options *armsecretsstoreextension.AzureKeyVaultSecretProviderClassesClientGetOptions) (resp azfake.Responder[armsecretsstoreextension.AzureKeyVaultSecretProviderClassesClientGetResponse], errResp azfake.ErrorResponder) + + // NewListByResourceGroupPager is the fake for method AzureKeyVaultSecretProviderClassesClient.NewListByResourceGroupPager + // HTTP status codes to indicate success: http.StatusOK + NewListByResourceGroupPager func(resourceGroupName string, options *armsecretsstoreextension.AzureKeyVaultSecretProviderClassesClientListByResourceGroupOptions) (resp azfake.PagerResponder[armsecretsstoreextension.AzureKeyVaultSecretProviderClassesClientListByResourceGroupResponse]) + + // NewListBySubscriptionPager is the fake for method AzureKeyVaultSecretProviderClassesClient.NewListBySubscriptionPager + // HTTP status codes to indicate success: http.StatusOK + NewListBySubscriptionPager func(options *armsecretsstoreextension.AzureKeyVaultSecretProviderClassesClientListBySubscriptionOptions) (resp azfake.PagerResponder[armsecretsstoreextension.AzureKeyVaultSecretProviderClassesClientListBySubscriptionResponse]) + + // BeginUpdate is the fake for method AzureKeyVaultSecretProviderClassesClient.BeginUpdate + // HTTP status codes to indicate success: http.StatusOK, http.StatusAccepted + BeginUpdate func(ctx context.Context, resourceGroupName string, azureKeyVaultSecretProviderClassName string, properties armsecretsstoreextension.AzureKeyVaultSecretProviderClassUpdate, options *armsecretsstoreextension.AzureKeyVaultSecretProviderClassesClientBeginUpdateOptions) (resp azfake.PollerResponder[armsecretsstoreextension.AzureKeyVaultSecretProviderClassesClientUpdateResponse], errResp azfake.ErrorResponder) +} + +// NewAzureKeyVaultSecretProviderClassesServerTransport creates a new instance of AzureKeyVaultSecretProviderClassesServerTransport with the provided implementation. +// The returned AzureKeyVaultSecretProviderClassesServerTransport instance is connected to an instance of armsecretsstoreextension.AzureKeyVaultSecretProviderClassesClient via the +// azcore.ClientOptions.Transporter field in the client's constructor parameters. +func NewAzureKeyVaultSecretProviderClassesServerTransport(srv *AzureKeyVaultSecretProviderClassesServer) *AzureKeyVaultSecretProviderClassesServerTransport { + return &AzureKeyVaultSecretProviderClassesServerTransport{ + srv: srv, + beginCreateOrUpdate: newTracker[azfake.PollerResponder[armsecretsstoreextension.AzureKeyVaultSecretProviderClassesClientCreateOrUpdateResponse]](), + beginDelete: newTracker[azfake.PollerResponder[armsecretsstoreextension.AzureKeyVaultSecretProviderClassesClientDeleteResponse]](), + newListByResourceGroupPager: newTracker[azfake.PagerResponder[armsecretsstoreextension.AzureKeyVaultSecretProviderClassesClientListByResourceGroupResponse]](), + newListBySubscriptionPager: newTracker[azfake.PagerResponder[armsecretsstoreextension.AzureKeyVaultSecretProviderClassesClientListBySubscriptionResponse]](), + beginUpdate: newTracker[azfake.PollerResponder[armsecretsstoreextension.AzureKeyVaultSecretProviderClassesClientUpdateResponse]](), + } +} + +// AzureKeyVaultSecretProviderClassesServerTransport connects instances of armsecretsstoreextension.AzureKeyVaultSecretProviderClassesClient to instances of AzureKeyVaultSecretProviderClassesServer. +// Don't use this type directly, use NewAzureKeyVaultSecretProviderClassesServerTransport instead. +type AzureKeyVaultSecretProviderClassesServerTransport struct { + srv *AzureKeyVaultSecretProviderClassesServer + beginCreateOrUpdate *tracker[azfake.PollerResponder[armsecretsstoreextension.AzureKeyVaultSecretProviderClassesClientCreateOrUpdateResponse]] + beginDelete *tracker[azfake.PollerResponder[armsecretsstoreextension.AzureKeyVaultSecretProviderClassesClientDeleteResponse]] + newListByResourceGroupPager *tracker[azfake.PagerResponder[armsecretsstoreextension.AzureKeyVaultSecretProviderClassesClientListByResourceGroupResponse]] + newListBySubscriptionPager *tracker[azfake.PagerResponder[armsecretsstoreextension.AzureKeyVaultSecretProviderClassesClientListBySubscriptionResponse]] + beginUpdate *tracker[azfake.PollerResponder[armsecretsstoreextension.AzureKeyVaultSecretProviderClassesClientUpdateResponse]] +} + +// Do implements the policy.Transporter interface for AzureKeyVaultSecretProviderClassesServerTransport. +func (a *AzureKeyVaultSecretProviderClassesServerTransport) Do(req *http.Request) (*http.Response, error) { + rawMethod := req.Context().Value(runtime.CtxAPINameKey{}) + method, ok := rawMethod.(string) + if !ok { + return nil, nonRetriableError{errors.New("unable to dispatch request, missing value for CtxAPINameKey")} + } + + return a.dispatchToMethodFake(req, method) +} + +func (a *AzureKeyVaultSecretProviderClassesServerTransport) dispatchToMethodFake(req *http.Request, method string) (*http.Response, error) { + resultChan := make(chan result) + defer close(resultChan) + + go func() { + var intercepted bool + var res result + if azureKeyVaultSecretProviderClassesServerTransportInterceptor != nil { + res.resp, res.err, intercepted = azureKeyVaultSecretProviderClassesServerTransportInterceptor.Do(req) + } + if !intercepted { + switch method { + case "AzureKeyVaultSecretProviderClassesClient.BeginCreateOrUpdate": + res.resp, res.err = a.dispatchBeginCreateOrUpdate(req) + case "AzureKeyVaultSecretProviderClassesClient.BeginDelete": + res.resp, res.err = a.dispatchBeginDelete(req) + case "AzureKeyVaultSecretProviderClassesClient.Get": + res.resp, res.err = a.dispatchGet(req) + case "AzureKeyVaultSecretProviderClassesClient.NewListByResourceGroupPager": + res.resp, res.err = a.dispatchNewListByResourceGroupPager(req) + case "AzureKeyVaultSecretProviderClassesClient.NewListBySubscriptionPager": + res.resp, res.err = a.dispatchNewListBySubscriptionPager(req) + case "AzureKeyVaultSecretProviderClassesClient.BeginUpdate": + res.resp, res.err = a.dispatchBeginUpdate(req) + default: + res.err = fmt.Errorf("unhandled API %s", method) + } + + } + select { + case resultChan <- res: + case <-req.Context().Done(): + } + }() + + select { + case <-req.Context().Done(): + return nil, req.Context().Err() + case res := <-resultChan: + return res.resp, res.err + } +} + +func (a *AzureKeyVaultSecretProviderClassesServerTransport) dispatchBeginCreateOrUpdate(req *http.Request) (*http.Response, error) { + if a.srv.BeginCreateOrUpdate == nil { + return nil, &nonRetriableError{errors.New("fake for method BeginCreateOrUpdate not implemented")} + } + beginCreateOrUpdate := a.beginCreateOrUpdate.get(req) + if beginCreateOrUpdate == nil { + const regexStr = `/subscriptions/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/resourceGroups/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/providers/Microsoft\.SecretSyncController/azureKeyVaultSecretProviderClasses/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)` + regex := regexp.MustCompile(regexStr) + matches := regex.FindStringSubmatch(req.URL.EscapedPath()) + if len(matches) < 4 { + return nil, fmt.Errorf("failed to parse path %s", req.URL.Path) + } + body, err := server.UnmarshalRequestAsJSON[armsecretsstoreextension.AzureKeyVaultSecretProviderClass](req) + if err != nil { + return nil, err + } + resourceGroupNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("resourceGroupName")]) + if err != nil { + return nil, err + } + azureKeyVaultSecretProviderClassNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("azureKeyVaultSecretProviderClassName")]) + if err != nil { + return nil, err + } + respr, errRespr := a.srv.BeginCreateOrUpdate(req.Context(), resourceGroupNameParam, azureKeyVaultSecretProviderClassNameParam, body, nil) + if respErr := server.GetError(errRespr, req); respErr != nil { + return nil, respErr + } + beginCreateOrUpdate = &respr + a.beginCreateOrUpdate.add(req, beginCreateOrUpdate) + } + + resp, err := server.PollerResponderNext(beginCreateOrUpdate, req) + if err != nil { + return nil, err + } + + if !contains([]int{http.StatusOK, http.StatusCreated}, resp.StatusCode) { + a.beginCreateOrUpdate.remove(req) + return nil, &nonRetriableError{fmt.Errorf("unexpected status code %d. acceptable values are http.StatusOK, http.StatusCreated", resp.StatusCode)} + } + if !server.PollerResponderMore(beginCreateOrUpdate) { + a.beginCreateOrUpdate.remove(req) + } + + return resp, nil +} + +func (a *AzureKeyVaultSecretProviderClassesServerTransport) dispatchBeginDelete(req *http.Request) (*http.Response, error) { + if a.srv.BeginDelete == nil { + return nil, &nonRetriableError{errors.New("fake for method BeginDelete not implemented")} + } + beginDelete := a.beginDelete.get(req) + if beginDelete == nil { + const regexStr = `/subscriptions/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/resourceGroups/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/providers/Microsoft\.SecretSyncController/azureKeyVaultSecretProviderClasses/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)` + regex := regexp.MustCompile(regexStr) + matches := regex.FindStringSubmatch(req.URL.EscapedPath()) + if len(matches) < 4 { + return nil, fmt.Errorf("failed to parse path %s", req.URL.Path) + } + resourceGroupNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("resourceGroupName")]) + if err != nil { + return nil, err + } + azureKeyVaultSecretProviderClassNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("azureKeyVaultSecretProviderClassName")]) + if err != nil { + return nil, err + } + respr, errRespr := a.srv.BeginDelete(req.Context(), resourceGroupNameParam, azureKeyVaultSecretProviderClassNameParam, nil) + if respErr := server.GetError(errRespr, req); respErr != nil { + return nil, respErr + } + beginDelete = &respr + a.beginDelete.add(req, beginDelete) + } + + resp, err := server.PollerResponderNext(beginDelete, req) + if err != nil { + return nil, err + } + + if !contains([]int{http.StatusOK, http.StatusAccepted, http.StatusNoContent}, resp.StatusCode) { + a.beginDelete.remove(req) + return nil, &nonRetriableError{fmt.Errorf("unexpected status code %d. acceptable values are http.StatusOK, http.StatusAccepted, http.StatusNoContent", resp.StatusCode)} + } + if !server.PollerResponderMore(beginDelete) { + a.beginDelete.remove(req) + } + + return resp, nil +} + +func (a *AzureKeyVaultSecretProviderClassesServerTransport) dispatchGet(req *http.Request) (*http.Response, error) { + if a.srv.Get == nil { + return nil, &nonRetriableError{errors.New("fake for method Get not implemented")} + } + const regexStr = `/subscriptions/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/resourceGroups/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/providers/Microsoft\.SecretSyncController/azureKeyVaultSecretProviderClasses/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)` + regex := regexp.MustCompile(regexStr) + matches := regex.FindStringSubmatch(req.URL.EscapedPath()) + if len(matches) < 4 { + return nil, fmt.Errorf("failed to parse path %s", req.URL.Path) + } + resourceGroupNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("resourceGroupName")]) + if err != nil { + return nil, err + } + azureKeyVaultSecretProviderClassNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("azureKeyVaultSecretProviderClassName")]) + if err != nil { + return nil, err + } + respr, errRespr := a.srv.Get(req.Context(), resourceGroupNameParam, azureKeyVaultSecretProviderClassNameParam, nil) + if respErr := server.GetError(errRespr, req); respErr != nil { + return nil, respErr + } + respContent := server.GetResponseContent(respr) + if !contains([]int{http.StatusOK}, respContent.HTTPStatus) { + return nil, &nonRetriableError{fmt.Errorf("unexpected status code %d. acceptable values are http.StatusOK", respContent.HTTPStatus)} + } + resp, err := server.MarshalResponseAsJSON(respContent, server.GetResponse(respr).AzureKeyVaultSecretProviderClass, req) + if err != nil { + return nil, err + } + return resp, nil +} + +func (a *AzureKeyVaultSecretProviderClassesServerTransport) dispatchNewListByResourceGroupPager(req *http.Request) (*http.Response, error) { + if a.srv.NewListByResourceGroupPager == nil { + return nil, &nonRetriableError{errors.New("fake for method NewListByResourceGroupPager not implemented")} + } + newListByResourceGroupPager := a.newListByResourceGroupPager.get(req) + if newListByResourceGroupPager == nil { + const regexStr = `/subscriptions/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/resourceGroups/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/providers/Microsoft\.SecretSyncController/azureKeyVaultSecretProviderClasses` + regex := regexp.MustCompile(regexStr) + matches := regex.FindStringSubmatch(req.URL.EscapedPath()) + if len(matches) < 3 { + return nil, fmt.Errorf("failed to parse path %s", req.URL.Path) + } + resourceGroupNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("resourceGroupName")]) + if err != nil { + return nil, err + } + resp := a.srv.NewListByResourceGroupPager(resourceGroupNameParam, nil) + newListByResourceGroupPager = &resp + a.newListByResourceGroupPager.add(req, newListByResourceGroupPager) + server.PagerResponderInjectNextLinks(newListByResourceGroupPager, req, func(page *armsecretsstoreextension.AzureKeyVaultSecretProviderClassesClientListByResourceGroupResponse, createLink func() string) { + page.NextLink = to.Ptr(createLink()) + }) + } + resp, err := server.PagerResponderNext(newListByResourceGroupPager, req) + if err != nil { + return nil, err + } + if !contains([]int{http.StatusOK}, resp.StatusCode) { + a.newListByResourceGroupPager.remove(req) + return nil, &nonRetriableError{fmt.Errorf("unexpected status code %d. acceptable values are http.StatusOK", resp.StatusCode)} + } + if !server.PagerResponderMore(newListByResourceGroupPager) { + a.newListByResourceGroupPager.remove(req) + } + return resp, nil +} + +func (a *AzureKeyVaultSecretProviderClassesServerTransport) dispatchNewListBySubscriptionPager(req *http.Request) (*http.Response, error) { + if a.srv.NewListBySubscriptionPager == nil { + return nil, &nonRetriableError{errors.New("fake for method NewListBySubscriptionPager not implemented")} + } + newListBySubscriptionPager := a.newListBySubscriptionPager.get(req) + if newListBySubscriptionPager == nil { + const regexStr = `/subscriptions/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/providers/Microsoft\.SecretSyncController/azureKeyVaultSecretProviderClasses` + regex := regexp.MustCompile(regexStr) + matches := regex.FindStringSubmatch(req.URL.EscapedPath()) + if len(matches) < 2 { + return nil, fmt.Errorf("failed to parse path %s", req.URL.Path) + } + resp := a.srv.NewListBySubscriptionPager(nil) + newListBySubscriptionPager = &resp + a.newListBySubscriptionPager.add(req, newListBySubscriptionPager) + server.PagerResponderInjectNextLinks(newListBySubscriptionPager, req, func(page *armsecretsstoreextension.AzureKeyVaultSecretProviderClassesClientListBySubscriptionResponse, createLink func() string) { + page.NextLink = to.Ptr(createLink()) + }) + } + resp, err := server.PagerResponderNext(newListBySubscriptionPager, req) + if err != nil { + return nil, err + } + if !contains([]int{http.StatusOK}, resp.StatusCode) { + a.newListBySubscriptionPager.remove(req) + return nil, &nonRetriableError{fmt.Errorf("unexpected status code %d. acceptable values are http.StatusOK", resp.StatusCode)} + } + if !server.PagerResponderMore(newListBySubscriptionPager) { + a.newListBySubscriptionPager.remove(req) + } + return resp, nil +} + +func (a *AzureKeyVaultSecretProviderClassesServerTransport) dispatchBeginUpdate(req *http.Request) (*http.Response, error) { + if a.srv.BeginUpdate == nil { + return nil, &nonRetriableError{errors.New("fake for method BeginUpdate not implemented")} + } + beginUpdate := a.beginUpdate.get(req) + if beginUpdate == nil { + const regexStr = `/subscriptions/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/resourceGroups/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/providers/Microsoft\.SecretSyncController/azureKeyVaultSecretProviderClasses/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)` + regex := regexp.MustCompile(regexStr) + matches := regex.FindStringSubmatch(req.URL.EscapedPath()) + if len(matches) < 4 { + return nil, fmt.Errorf("failed to parse path %s", req.URL.Path) + } + body, err := server.UnmarshalRequestAsJSON[armsecretsstoreextension.AzureKeyVaultSecretProviderClassUpdate](req) + if err != nil { + return nil, err + } + resourceGroupNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("resourceGroupName")]) + if err != nil { + return nil, err + } + azureKeyVaultSecretProviderClassNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("azureKeyVaultSecretProviderClassName")]) + if err != nil { + return nil, err + } + respr, errRespr := a.srv.BeginUpdate(req.Context(), resourceGroupNameParam, azureKeyVaultSecretProviderClassNameParam, body, nil) + if respErr := server.GetError(errRespr, req); respErr != nil { + return nil, respErr + } + beginUpdate = &respr + a.beginUpdate.add(req, beginUpdate) + } + + resp, err := server.PollerResponderNext(beginUpdate, req) + if err != nil { + return nil, err + } + + if !contains([]int{http.StatusOK, http.StatusAccepted}, resp.StatusCode) { + a.beginUpdate.remove(req) + return nil, &nonRetriableError{fmt.Errorf("unexpected status code %d. acceptable values are http.StatusOK, http.StatusAccepted", resp.StatusCode)} + } + if !server.PollerResponderMore(beginUpdate) { + a.beginUpdate.remove(req) + } + + return resp, nil +} + +// set this to conditionally intercept incoming requests to AzureKeyVaultSecretProviderClassesServerTransport +var azureKeyVaultSecretProviderClassesServerTransportInterceptor interface { + // Do returns true if the server transport should use the returned response/error + Do(*http.Request) (*http.Response, error, bool) +} diff --git a/sdk/resourcemanager/secretsstoreextension/armsecretsstoreextension/fake/internal.go b/sdk/resourcemanager/secretsstoreextension/armsecretsstoreextension/fake/internal.go new file mode 100644 index 000000000000..7425b6a669e2 --- /dev/null +++ b/sdk/resourcemanager/secretsstoreextension/armsecretsstoreextension/fake/internal.go @@ -0,0 +1,65 @@ +// 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) Go Code Generator. DO NOT EDIT. + +package fake + +import ( + "github.com/Azure/azure-sdk-for-go/sdk/azcore/fake/server" + "net/http" + "sync" +) + +type result struct { + resp *http.Response + err error +} + +type nonRetriableError struct { + error +} + +func (nonRetriableError) NonRetriable() { + // marker method +} + +func contains[T comparable](s []T, v T) bool { + for _, vv := range s { + if vv == v { + return true + } + } + return false +} + +func newTracker[T any]() *tracker[T] { + return &tracker[T]{ + items: map[string]*T{}, + } +} + +type tracker[T any] struct { + items map[string]*T + mu sync.Mutex +} + +func (p *tracker[T]) get(req *http.Request) *T { + p.mu.Lock() + defer p.mu.Unlock() + if item, ok := p.items[server.SanitizePagerPollerPath(req.URL.Path)]; ok { + return item + } + return nil +} + +func (p *tracker[T]) add(req *http.Request, item *T) { + p.mu.Lock() + defer p.mu.Unlock() + p.items[server.SanitizePagerPollerPath(req.URL.Path)] = item +} + +func (p *tracker[T]) remove(req *http.Request) { + p.mu.Lock() + defer p.mu.Unlock() + delete(p.items, server.SanitizePagerPollerPath(req.URL.Path)) +} diff --git a/sdk/resourcemanager/secretsstoreextension/armsecretsstoreextension/fake/operations_server.go b/sdk/resourcemanager/secretsstoreextension/armsecretsstoreextension/fake/operations_server.go new file mode 100644 index 000000000000..59debc9e96bd --- /dev/null +++ b/sdk/resourcemanager/secretsstoreextension/armsecretsstoreextension/fake/operations_server.go @@ -0,0 +1,117 @@ +// 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) Go Code Generator. DO NOT EDIT. + +package fake + +import ( + "errors" + "fmt" + azfake "github.com/Azure/azure-sdk-for-go/sdk/azcore/fake" + "github.com/Azure/azure-sdk-for-go/sdk/azcore/fake/server" + "github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime" + "github.com/Azure/azure-sdk-for-go/sdk/azcore/to" + "github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/secretsstoreextension/armsecretsstoreextension" + "net/http" +) + +// OperationsServer is a fake server for instances of the armsecretsstoreextension.OperationsClient type. +type OperationsServer struct { + // NewListPager is the fake for method OperationsClient.NewListPager + // HTTP status codes to indicate success: http.StatusOK + NewListPager func(options *armsecretsstoreextension.OperationsClientListOptions) (resp azfake.PagerResponder[armsecretsstoreextension.OperationsClientListResponse]) +} + +// NewOperationsServerTransport creates a new instance of OperationsServerTransport with the provided implementation. +// The returned OperationsServerTransport instance is connected to an instance of armsecretsstoreextension.OperationsClient via the +// azcore.ClientOptions.Transporter field in the client's constructor parameters. +func NewOperationsServerTransport(srv *OperationsServer) *OperationsServerTransport { + return &OperationsServerTransport{ + srv: srv, + newListPager: newTracker[azfake.PagerResponder[armsecretsstoreextension.OperationsClientListResponse]](), + } +} + +// OperationsServerTransport connects instances of armsecretsstoreextension.OperationsClient to instances of OperationsServer. +// Don't use this type directly, use NewOperationsServerTransport instead. +type OperationsServerTransport struct { + srv *OperationsServer + newListPager *tracker[azfake.PagerResponder[armsecretsstoreextension.OperationsClientListResponse]] +} + +// Do implements the policy.Transporter interface for OperationsServerTransport. +func (o *OperationsServerTransport) Do(req *http.Request) (*http.Response, error) { + rawMethod := req.Context().Value(runtime.CtxAPINameKey{}) + method, ok := rawMethod.(string) + if !ok { + return nil, nonRetriableError{errors.New("unable to dispatch request, missing value for CtxAPINameKey")} + } + + return o.dispatchToMethodFake(req, method) +} + +func (o *OperationsServerTransport) dispatchToMethodFake(req *http.Request, method string) (*http.Response, error) { + resultChan := make(chan result) + defer close(resultChan) + + go func() { + var intercepted bool + var res result + if operationsServerTransportInterceptor != nil { + res.resp, res.err, intercepted = operationsServerTransportInterceptor.Do(req) + } + if !intercepted { + switch method { + case "OperationsClient.NewListPager": + res.resp, res.err = o.dispatchNewListPager(req) + default: + res.err = fmt.Errorf("unhandled API %s", method) + } + + } + select { + case resultChan <- res: + case <-req.Context().Done(): + } + }() + + select { + case <-req.Context().Done(): + return nil, req.Context().Err() + case res := <-resultChan: + return res.resp, res.err + } +} + +func (o *OperationsServerTransport) dispatchNewListPager(req *http.Request) (*http.Response, error) { + if o.srv.NewListPager == nil { + return nil, &nonRetriableError{errors.New("fake for method NewListPager not implemented")} + } + newListPager := o.newListPager.get(req) + if newListPager == nil { + resp := o.srv.NewListPager(nil) + newListPager = &resp + o.newListPager.add(req, newListPager) + server.PagerResponderInjectNextLinks(newListPager, req, func(page *armsecretsstoreextension.OperationsClientListResponse, createLink func() string) { + page.NextLink = to.Ptr(createLink()) + }) + } + resp, err := server.PagerResponderNext(newListPager, req) + if err != nil { + return nil, err + } + if !contains([]int{http.StatusOK}, resp.StatusCode) { + o.newListPager.remove(req) + return nil, &nonRetriableError{fmt.Errorf("unexpected status code %d. acceptable values are http.StatusOK", resp.StatusCode)} + } + if !server.PagerResponderMore(newListPager) { + o.newListPager.remove(req) + } + return resp, nil +} + +// set this to conditionally intercept incoming requests to OperationsServerTransport +var operationsServerTransportInterceptor interface { + // Do returns true if the server transport should use the returned response/error + Do(*http.Request) (*http.Response, error, bool) +} diff --git a/sdk/resourcemanager/secretsstoreextension/armsecretsstoreextension/fake/secretsyncs_server.go b/sdk/resourcemanager/secretsstoreextension/armsecretsstoreextension/fake/secretsyncs_server.go new file mode 100644 index 000000000000..f6ad92989cad --- /dev/null +++ b/sdk/resourcemanager/secretsstoreextension/armsecretsstoreextension/fake/secretsyncs_server.go @@ -0,0 +1,374 @@ +// 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) Go Code Generator. DO NOT EDIT. + +package fake + +import ( + "context" + "errors" + "fmt" + azfake "github.com/Azure/azure-sdk-for-go/sdk/azcore/fake" + "github.com/Azure/azure-sdk-for-go/sdk/azcore/fake/server" + "github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime" + "github.com/Azure/azure-sdk-for-go/sdk/azcore/to" + "github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/secretsstoreextension/armsecretsstoreextension" + "net/http" + "net/url" + "regexp" +) + +// SecretSyncsServer is a fake server for instances of the armsecretsstoreextension.SecretSyncsClient type. +type SecretSyncsServer struct { + // BeginCreateOrUpdate is the fake for method SecretSyncsClient.BeginCreateOrUpdate + // HTTP status codes to indicate success: http.StatusOK, http.StatusCreated + BeginCreateOrUpdate func(ctx context.Context, resourceGroupName string, secretSyncName string, resource armsecretsstoreextension.SecretSync, options *armsecretsstoreextension.SecretSyncsClientBeginCreateOrUpdateOptions) (resp azfake.PollerResponder[armsecretsstoreextension.SecretSyncsClientCreateOrUpdateResponse], errResp azfake.ErrorResponder) + + // BeginDelete is the fake for method SecretSyncsClient.BeginDelete + // HTTP status codes to indicate success: http.StatusOK, http.StatusAccepted, http.StatusNoContent + BeginDelete func(ctx context.Context, resourceGroupName string, secretSyncName string, options *armsecretsstoreextension.SecretSyncsClientBeginDeleteOptions) (resp azfake.PollerResponder[armsecretsstoreextension.SecretSyncsClientDeleteResponse], errResp azfake.ErrorResponder) + + // Get is the fake for method SecretSyncsClient.Get + // HTTP status codes to indicate success: http.StatusOK + Get func(ctx context.Context, resourceGroupName string, secretSyncName string, options *armsecretsstoreextension.SecretSyncsClientGetOptions) (resp azfake.Responder[armsecretsstoreextension.SecretSyncsClientGetResponse], errResp azfake.ErrorResponder) + + // NewListByResourceGroupPager is the fake for method SecretSyncsClient.NewListByResourceGroupPager + // HTTP status codes to indicate success: http.StatusOK + NewListByResourceGroupPager func(resourceGroupName string, options *armsecretsstoreextension.SecretSyncsClientListByResourceGroupOptions) (resp azfake.PagerResponder[armsecretsstoreextension.SecretSyncsClientListByResourceGroupResponse]) + + // NewListBySubscriptionPager is the fake for method SecretSyncsClient.NewListBySubscriptionPager + // HTTP status codes to indicate success: http.StatusOK + NewListBySubscriptionPager func(options *armsecretsstoreextension.SecretSyncsClientListBySubscriptionOptions) (resp azfake.PagerResponder[armsecretsstoreextension.SecretSyncsClientListBySubscriptionResponse]) + + // BeginUpdate is the fake for method SecretSyncsClient.BeginUpdate + // HTTP status codes to indicate success: http.StatusOK, http.StatusAccepted + BeginUpdate func(ctx context.Context, resourceGroupName string, secretSyncName string, properties armsecretsstoreextension.SecretSyncUpdate, options *armsecretsstoreextension.SecretSyncsClientBeginUpdateOptions) (resp azfake.PollerResponder[armsecretsstoreextension.SecretSyncsClientUpdateResponse], errResp azfake.ErrorResponder) +} + +// NewSecretSyncsServerTransport creates a new instance of SecretSyncsServerTransport with the provided implementation. +// The returned SecretSyncsServerTransport instance is connected to an instance of armsecretsstoreextension.SecretSyncsClient via the +// azcore.ClientOptions.Transporter field in the client's constructor parameters. +func NewSecretSyncsServerTransport(srv *SecretSyncsServer) *SecretSyncsServerTransport { + return &SecretSyncsServerTransport{ + srv: srv, + beginCreateOrUpdate: newTracker[azfake.PollerResponder[armsecretsstoreextension.SecretSyncsClientCreateOrUpdateResponse]](), + beginDelete: newTracker[azfake.PollerResponder[armsecretsstoreextension.SecretSyncsClientDeleteResponse]](), + newListByResourceGroupPager: newTracker[azfake.PagerResponder[armsecretsstoreextension.SecretSyncsClientListByResourceGroupResponse]](), + newListBySubscriptionPager: newTracker[azfake.PagerResponder[armsecretsstoreextension.SecretSyncsClientListBySubscriptionResponse]](), + beginUpdate: newTracker[azfake.PollerResponder[armsecretsstoreextension.SecretSyncsClientUpdateResponse]](), + } +} + +// SecretSyncsServerTransport connects instances of armsecretsstoreextension.SecretSyncsClient to instances of SecretSyncsServer. +// Don't use this type directly, use NewSecretSyncsServerTransport instead. +type SecretSyncsServerTransport struct { + srv *SecretSyncsServer + beginCreateOrUpdate *tracker[azfake.PollerResponder[armsecretsstoreextension.SecretSyncsClientCreateOrUpdateResponse]] + beginDelete *tracker[azfake.PollerResponder[armsecretsstoreextension.SecretSyncsClientDeleteResponse]] + newListByResourceGroupPager *tracker[azfake.PagerResponder[armsecretsstoreextension.SecretSyncsClientListByResourceGroupResponse]] + newListBySubscriptionPager *tracker[azfake.PagerResponder[armsecretsstoreextension.SecretSyncsClientListBySubscriptionResponse]] + beginUpdate *tracker[azfake.PollerResponder[armsecretsstoreextension.SecretSyncsClientUpdateResponse]] +} + +// Do implements the policy.Transporter interface for SecretSyncsServerTransport. +func (s *SecretSyncsServerTransport) Do(req *http.Request) (*http.Response, error) { + rawMethod := req.Context().Value(runtime.CtxAPINameKey{}) + method, ok := rawMethod.(string) + if !ok { + return nil, nonRetriableError{errors.New("unable to dispatch request, missing value for CtxAPINameKey")} + } + + return s.dispatchToMethodFake(req, method) +} + +func (s *SecretSyncsServerTransport) dispatchToMethodFake(req *http.Request, method string) (*http.Response, error) { + resultChan := make(chan result) + defer close(resultChan) + + go func() { + var intercepted bool + var res result + if secretSyncsServerTransportInterceptor != nil { + res.resp, res.err, intercepted = secretSyncsServerTransportInterceptor.Do(req) + } + if !intercepted { + switch method { + case "SecretSyncsClient.BeginCreateOrUpdate": + res.resp, res.err = s.dispatchBeginCreateOrUpdate(req) + case "SecretSyncsClient.BeginDelete": + res.resp, res.err = s.dispatchBeginDelete(req) + case "SecretSyncsClient.Get": + res.resp, res.err = s.dispatchGet(req) + case "SecretSyncsClient.NewListByResourceGroupPager": + res.resp, res.err = s.dispatchNewListByResourceGroupPager(req) + case "SecretSyncsClient.NewListBySubscriptionPager": + res.resp, res.err = s.dispatchNewListBySubscriptionPager(req) + case "SecretSyncsClient.BeginUpdate": + res.resp, res.err = s.dispatchBeginUpdate(req) + default: + res.err = fmt.Errorf("unhandled API %s", method) + } + + } + select { + case resultChan <- res: + case <-req.Context().Done(): + } + }() + + select { + case <-req.Context().Done(): + return nil, req.Context().Err() + case res := <-resultChan: + return res.resp, res.err + } +} + +func (s *SecretSyncsServerTransport) dispatchBeginCreateOrUpdate(req *http.Request) (*http.Response, error) { + if s.srv.BeginCreateOrUpdate == nil { + return nil, &nonRetriableError{errors.New("fake for method BeginCreateOrUpdate not implemented")} + } + beginCreateOrUpdate := s.beginCreateOrUpdate.get(req) + if beginCreateOrUpdate == nil { + const regexStr = `/subscriptions/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/resourceGroups/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/providers/Microsoft\.SecretSyncController/secretSyncs/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)` + regex := regexp.MustCompile(regexStr) + matches := regex.FindStringSubmatch(req.URL.EscapedPath()) + if len(matches) < 4 { + return nil, fmt.Errorf("failed to parse path %s", req.URL.Path) + } + body, err := server.UnmarshalRequestAsJSON[armsecretsstoreextension.SecretSync](req) + if err != nil { + return nil, err + } + resourceGroupNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("resourceGroupName")]) + if err != nil { + return nil, err + } + secretSyncNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("secretSyncName")]) + if err != nil { + return nil, err + } + respr, errRespr := s.srv.BeginCreateOrUpdate(req.Context(), resourceGroupNameParam, secretSyncNameParam, body, nil) + if respErr := server.GetError(errRespr, req); respErr != nil { + return nil, respErr + } + beginCreateOrUpdate = &respr + s.beginCreateOrUpdate.add(req, beginCreateOrUpdate) + } + + resp, err := server.PollerResponderNext(beginCreateOrUpdate, req) + if err != nil { + return nil, err + } + + if !contains([]int{http.StatusOK, http.StatusCreated}, resp.StatusCode) { + s.beginCreateOrUpdate.remove(req) + return nil, &nonRetriableError{fmt.Errorf("unexpected status code %d. acceptable values are http.StatusOK, http.StatusCreated", resp.StatusCode)} + } + if !server.PollerResponderMore(beginCreateOrUpdate) { + s.beginCreateOrUpdate.remove(req) + } + + return resp, nil +} + +func (s *SecretSyncsServerTransport) dispatchBeginDelete(req *http.Request) (*http.Response, error) { + if s.srv.BeginDelete == nil { + return nil, &nonRetriableError{errors.New("fake for method BeginDelete not implemented")} + } + beginDelete := s.beginDelete.get(req) + if beginDelete == nil { + const regexStr = `/subscriptions/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/resourceGroups/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/providers/Microsoft\.SecretSyncController/secretSyncs/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)` + regex := regexp.MustCompile(regexStr) + matches := regex.FindStringSubmatch(req.URL.EscapedPath()) + if len(matches) < 4 { + return nil, fmt.Errorf("failed to parse path %s", req.URL.Path) + } + resourceGroupNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("resourceGroupName")]) + if err != nil { + return nil, err + } + secretSyncNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("secretSyncName")]) + if err != nil { + return nil, err + } + respr, errRespr := s.srv.BeginDelete(req.Context(), resourceGroupNameParam, secretSyncNameParam, nil) + if respErr := server.GetError(errRespr, req); respErr != nil { + return nil, respErr + } + beginDelete = &respr + s.beginDelete.add(req, beginDelete) + } + + resp, err := server.PollerResponderNext(beginDelete, req) + if err != nil { + return nil, err + } + + if !contains([]int{http.StatusOK, http.StatusAccepted, http.StatusNoContent}, resp.StatusCode) { + s.beginDelete.remove(req) + return nil, &nonRetriableError{fmt.Errorf("unexpected status code %d. acceptable values are http.StatusOK, http.StatusAccepted, http.StatusNoContent", resp.StatusCode)} + } + if !server.PollerResponderMore(beginDelete) { + s.beginDelete.remove(req) + } + + return resp, nil +} + +func (s *SecretSyncsServerTransport) dispatchGet(req *http.Request) (*http.Response, error) { + if s.srv.Get == nil { + return nil, &nonRetriableError{errors.New("fake for method Get not implemented")} + } + const regexStr = `/subscriptions/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/resourceGroups/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/providers/Microsoft\.SecretSyncController/secretSyncs/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)` + regex := regexp.MustCompile(regexStr) + matches := regex.FindStringSubmatch(req.URL.EscapedPath()) + if len(matches) < 4 { + return nil, fmt.Errorf("failed to parse path %s", req.URL.Path) + } + resourceGroupNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("resourceGroupName")]) + if err != nil { + return nil, err + } + secretSyncNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("secretSyncName")]) + if err != nil { + return nil, err + } + respr, errRespr := s.srv.Get(req.Context(), resourceGroupNameParam, secretSyncNameParam, nil) + if respErr := server.GetError(errRespr, req); respErr != nil { + return nil, respErr + } + respContent := server.GetResponseContent(respr) + if !contains([]int{http.StatusOK}, respContent.HTTPStatus) { + return nil, &nonRetriableError{fmt.Errorf("unexpected status code %d. acceptable values are http.StatusOK", respContent.HTTPStatus)} + } + resp, err := server.MarshalResponseAsJSON(respContent, server.GetResponse(respr).SecretSync, req) + if err != nil { + return nil, err + } + return resp, nil +} + +func (s *SecretSyncsServerTransport) dispatchNewListByResourceGroupPager(req *http.Request) (*http.Response, error) { + if s.srv.NewListByResourceGroupPager == nil { + return nil, &nonRetriableError{errors.New("fake for method NewListByResourceGroupPager not implemented")} + } + newListByResourceGroupPager := s.newListByResourceGroupPager.get(req) + if newListByResourceGroupPager == nil { + const regexStr = `/subscriptions/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/resourceGroups/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/providers/Microsoft\.SecretSyncController/secretSyncs` + regex := regexp.MustCompile(regexStr) + matches := regex.FindStringSubmatch(req.URL.EscapedPath()) + if len(matches) < 3 { + return nil, fmt.Errorf("failed to parse path %s", req.URL.Path) + } + resourceGroupNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("resourceGroupName")]) + if err != nil { + return nil, err + } + resp := s.srv.NewListByResourceGroupPager(resourceGroupNameParam, nil) + newListByResourceGroupPager = &resp + s.newListByResourceGroupPager.add(req, newListByResourceGroupPager) + server.PagerResponderInjectNextLinks(newListByResourceGroupPager, req, func(page *armsecretsstoreextension.SecretSyncsClientListByResourceGroupResponse, createLink func() string) { + page.NextLink = to.Ptr(createLink()) + }) + } + resp, err := server.PagerResponderNext(newListByResourceGroupPager, req) + if err != nil { + return nil, err + } + if !contains([]int{http.StatusOK}, resp.StatusCode) { + s.newListByResourceGroupPager.remove(req) + return nil, &nonRetriableError{fmt.Errorf("unexpected status code %d. acceptable values are http.StatusOK", resp.StatusCode)} + } + if !server.PagerResponderMore(newListByResourceGroupPager) { + s.newListByResourceGroupPager.remove(req) + } + return resp, nil +} + +func (s *SecretSyncsServerTransport) dispatchNewListBySubscriptionPager(req *http.Request) (*http.Response, error) { + if s.srv.NewListBySubscriptionPager == nil { + return nil, &nonRetriableError{errors.New("fake for method NewListBySubscriptionPager not implemented")} + } + newListBySubscriptionPager := s.newListBySubscriptionPager.get(req) + if newListBySubscriptionPager == nil { + const regexStr = `/subscriptions/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/providers/Microsoft\.SecretSyncController/secretSyncs` + regex := regexp.MustCompile(regexStr) + matches := regex.FindStringSubmatch(req.URL.EscapedPath()) + if len(matches) < 2 { + return nil, fmt.Errorf("failed to parse path %s", req.URL.Path) + } + resp := s.srv.NewListBySubscriptionPager(nil) + newListBySubscriptionPager = &resp + s.newListBySubscriptionPager.add(req, newListBySubscriptionPager) + server.PagerResponderInjectNextLinks(newListBySubscriptionPager, req, func(page *armsecretsstoreextension.SecretSyncsClientListBySubscriptionResponse, createLink func() string) { + page.NextLink = to.Ptr(createLink()) + }) + } + resp, err := server.PagerResponderNext(newListBySubscriptionPager, req) + if err != nil { + return nil, err + } + if !contains([]int{http.StatusOK}, resp.StatusCode) { + s.newListBySubscriptionPager.remove(req) + return nil, &nonRetriableError{fmt.Errorf("unexpected status code %d. acceptable values are http.StatusOK", resp.StatusCode)} + } + if !server.PagerResponderMore(newListBySubscriptionPager) { + s.newListBySubscriptionPager.remove(req) + } + return resp, nil +} + +func (s *SecretSyncsServerTransport) dispatchBeginUpdate(req *http.Request) (*http.Response, error) { + if s.srv.BeginUpdate == nil { + return nil, &nonRetriableError{errors.New("fake for method BeginUpdate not implemented")} + } + beginUpdate := s.beginUpdate.get(req) + if beginUpdate == nil { + const regexStr = `/subscriptions/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/resourceGroups/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/providers/Microsoft\.SecretSyncController/secretSyncs/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)` + regex := regexp.MustCompile(regexStr) + matches := regex.FindStringSubmatch(req.URL.EscapedPath()) + if len(matches) < 4 { + return nil, fmt.Errorf("failed to parse path %s", req.URL.Path) + } + body, err := server.UnmarshalRequestAsJSON[armsecretsstoreextension.SecretSyncUpdate](req) + if err != nil { + return nil, err + } + resourceGroupNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("resourceGroupName")]) + if err != nil { + return nil, err + } + secretSyncNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("secretSyncName")]) + if err != nil { + return nil, err + } + respr, errRespr := s.srv.BeginUpdate(req.Context(), resourceGroupNameParam, secretSyncNameParam, body, nil) + if respErr := server.GetError(errRespr, req); respErr != nil { + return nil, respErr + } + beginUpdate = &respr + s.beginUpdate.add(req, beginUpdate) + } + + resp, err := server.PollerResponderNext(beginUpdate, req) + if err != nil { + return nil, err + } + + if !contains([]int{http.StatusOK, http.StatusAccepted}, resp.StatusCode) { + s.beginUpdate.remove(req) + return nil, &nonRetriableError{fmt.Errorf("unexpected status code %d. acceptable values are http.StatusOK, http.StatusAccepted", resp.StatusCode)} + } + if !server.PollerResponderMore(beginUpdate) { + s.beginUpdate.remove(req) + } + + return resp, nil +} + +// set this to conditionally intercept incoming requests to SecretSyncsServerTransport +var secretSyncsServerTransportInterceptor interface { + // Do returns true if the server transport should use the returned response/error + Do(*http.Request) (*http.Response, error, bool) +} diff --git a/sdk/resourcemanager/secretsstoreextension/armsecretsstoreextension/fake/server_factory.go b/sdk/resourcemanager/secretsstoreextension/armsecretsstoreextension/fake/server_factory.go new file mode 100644 index 000000000000..a92593f4a904 --- /dev/null +++ b/sdk/resourcemanager/secretsstoreextension/armsecretsstoreextension/fake/server_factory.go @@ -0,0 +1,88 @@ +// 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) Go Code Generator. DO NOT EDIT. + +package fake + +import ( + "errors" + "fmt" + "github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime" + "net/http" + "strings" + "sync" +) + +// ServerFactory is a fake server for instances of the armsecretsstoreextension.ClientFactory type. +type ServerFactory struct { + // AzureKeyVaultSecretProviderClassesServer contains the fakes for client AzureKeyVaultSecretProviderClassesClient + AzureKeyVaultSecretProviderClassesServer AzureKeyVaultSecretProviderClassesServer + + // OperationsServer contains the fakes for client OperationsClient + OperationsServer OperationsServer + + // SecretSyncsServer contains the fakes for client SecretSyncsClient + SecretSyncsServer SecretSyncsServer +} + +// NewServerFactoryTransport creates a new instance of ServerFactoryTransport with the provided implementation. +// The returned ServerFactoryTransport instance is connected to an instance of armsecretsstoreextension.ClientFactory via the +// azcore.ClientOptions.Transporter field in the client's constructor parameters. +func NewServerFactoryTransport(srv *ServerFactory) *ServerFactoryTransport { + return &ServerFactoryTransport{ + srv: srv, + } +} + +// ServerFactoryTransport connects instances of armsecretsstoreextension.ClientFactory to instances of ServerFactory. +// Don't use this type directly, use NewServerFactoryTransport instead. +type ServerFactoryTransport struct { + srv *ServerFactory + trMu sync.Mutex + trAzureKeyVaultSecretProviderClassesServer *AzureKeyVaultSecretProviderClassesServerTransport + trOperationsServer *OperationsServerTransport + trSecretSyncsServer *SecretSyncsServerTransport +} + +// Do implements the policy.Transporter interface for ServerFactoryTransport. +func (s *ServerFactoryTransport) Do(req *http.Request) (*http.Response, error) { + rawMethod := req.Context().Value(runtime.CtxAPINameKey{}) + method, ok := rawMethod.(string) + if !ok { + return nil, nonRetriableError{errors.New("unable to dispatch request, missing value for CtxAPINameKey")} + } + + client := method[:strings.Index(method, ".")] + var resp *http.Response + var err error + + switch client { + case "AzureKeyVaultSecretProviderClassesClient": + initServer(s, &s.trAzureKeyVaultSecretProviderClassesServer, func() *AzureKeyVaultSecretProviderClassesServerTransport { + return NewAzureKeyVaultSecretProviderClassesServerTransport(&s.srv.AzureKeyVaultSecretProviderClassesServer) + }) + resp, err = s.trAzureKeyVaultSecretProviderClassesServer.Do(req) + case "OperationsClient": + initServer(s, &s.trOperationsServer, func() *OperationsServerTransport { return NewOperationsServerTransport(&s.srv.OperationsServer) }) + resp, err = s.trOperationsServer.Do(req) + case "SecretSyncsClient": + initServer(s, &s.trSecretSyncsServer, func() *SecretSyncsServerTransport { return NewSecretSyncsServerTransport(&s.srv.SecretSyncsServer) }) + resp, err = s.trSecretSyncsServer.Do(req) + default: + err = fmt.Errorf("unhandled client %s", client) + } + + if err != nil { + return nil, err + } + + return resp, nil +} + +func initServer[T any](s *ServerFactoryTransport, dst **T, src func() *T) { + s.trMu.Lock() + if *dst == nil { + *dst = src() + } + s.trMu.Unlock() +} diff --git a/sdk/resourcemanager/secretsstoreextension/armsecretsstoreextension/go.mod b/sdk/resourcemanager/secretsstoreextension/armsecretsstoreextension/go.mod new file mode 100644 index 000000000000..398df583aef4 --- /dev/null +++ b/sdk/resourcemanager/secretsstoreextension/armsecretsstoreextension/go.mod @@ -0,0 +1,23 @@ +module github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/secretsstoreextension/armsecretsstoreextension + +go 1.23.0 + +toolchain go1.23.8 + +require ( + github.com/Azure/azure-sdk-for-go/sdk/azcore v1.17.1 + github.com/Azure/azure-sdk-for-go/sdk/azidentity v1.7.0 +) + +require ( + github.com/Azure/azure-sdk-for-go/sdk/internal v1.10.0 // indirect + github.com/AzureAD/microsoft-authentication-library-for-go v1.2.2 // indirect + github.com/golang-jwt/jwt/v5 v5.2.1 // indirect + github.com/google/uuid v1.6.0 // indirect + github.com/kylelemons/godebug v1.1.0 // indirect + github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c // indirect + golang.org/x/crypto v0.36.0 // indirect + golang.org/x/net v0.37.0 // indirect + golang.org/x/sys v0.31.0 // indirect + golang.org/x/text v0.23.0 // indirect +) diff --git a/sdk/resourcemanager/secretsstoreextension/armsecretsstoreextension/go.sum b/sdk/resourcemanager/secretsstoreextension/armsecretsstoreextension/go.sum new file mode 100644 index 000000000000..1f92486fbbcf --- /dev/null +++ b/sdk/resourcemanager/secretsstoreextension/armsecretsstoreextension/go.sum @@ -0,0 +1,33 @@ +github.com/Azure/azure-sdk-for-go/sdk/azcore v1.17.1 h1:DSDNVxqkoXJiko6x8a90zidoYqnYYa6c1MTzDKzKkTo= +github.com/Azure/azure-sdk-for-go/sdk/azcore v1.17.1/go.mod h1:zGqV2R4Cr/k8Uye5w+dgQ06WJtEcbQG/8J7BB6hnCr4= +github.com/Azure/azure-sdk-for-go/sdk/azidentity v1.7.0 h1:tfLQ34V6F7tVSwoTf/4lH5sE0o6eCJuNDTmH09nDpbc= +github.com/Azure/azure-sdk-for-go/sdk/azidentity v1.7.0/go.mod h1:9kIvujWAA58nmPmWB1m23fyWic1kYZMxD9CxaWn4Qpg= +github.com/Azure/azure-sdk-for-go/sdk/internal v1.10.0 h1:ywEEhmNahHBihViHepv3xPBn1663uRv2t2q/ESv9seY= +github.com/Azure/azure-sdk-for-go/sdk/internal v1.10.0/go.mod h1:iZDifYGJTIgIIkYRNWPENUnqx6bJ2xnSDFI2tjwZNuY= +github.com/AzureAD/microsoft-authentication-library-for-go v1.2.2 h1:XHOnouVk1mxXfQidrMEnLlPk9UMeRtyBTnEFtxkV0kU= +github.com/AzureAD/microsoft-authentication-library-for-go v1.2.2/go.mod h1:wP83P5OoQ5p6ip3ScPr0BAq0BvuPAvacpEuSzyouqAI= +github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= +github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/golang-jwt/jwt/v5 v5.2.1 h1:OuVbFODueb089Lh128TAcimifWaLhJwVflnrgM17wHk= +github.com/golang-jwt/jwt/v5 v5.2.1/go.mod h1:pqrtFR0X4osieyHYxtmOUWsAWrfe1Q5UVIyoH402zdk= +github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= +github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= +github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0SNc= +github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw= +github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c h1:+mdjkGKdHQG3305AYmdv1U2eRNDiU2ErMBj1gwrq8eQ= +github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c/go.mod h1:7rwL4CYBLnjLxUqIJNnCWiEdr3bn6IUYi15bNlnbCCU= +github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= +github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA= +github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= +golang.org/x/crypto v0.36.0 h1:AnAEvhDddvBdpY+uR+MyHmuZzzNqXSe/GvuDeob5L34= +golang.org/x/crypto v0.36.0/go.mod h1:Y4J0ReaxCR1IMaabaSMugxJES1EpwhBHhv2bDHklZvc= +golang.org/x/net v0.37.0 h1:1zLorHbz+LYj7MQlSf1+2tPIIgibq2eL5xkrGk6f+2c= +golang.org/x/net v0.37.0/go.mod h1:ivrbrMbzFq5J41QOQh0siUuly180yBYtLp+CKbEaFx8= +golang.org/x/sys v0.1.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.31.0 h1:ioabZlmFYtWhL+TRYpcnNlLwhyxaM9kWTDEmfnprqik= +golang.org/x/sys v0.31.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k= +golang.org/x/text v0.23.0 h1:D71I7dUrlY+VX0gQShAThNGHFxZ13dGLBHQLVl1mJlY= +golang.org/x/text v0.23.0/go.mod h1:/BLNzu4aZCJ1+kcD0DNRotWKage4q2rGVAg4o22unh4= +gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= +gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= diff --git a/sdk/resourcemanager/secretsstoreextension/armsecretsstoreextension/models.go b/sdk/resourcemanager/secretsstoreextension/armsecretsstoreextension/models.go new file mode 100644 index 000000000000..a8ab7196c4dd --- /dev/null +++ b/sdk/resourcemanager/secretsstoreextension/armsecretsstoreextension/models.go @@ -0,0 +1,314 @@ +// 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) Go Code Generator. DO NOT EDIT. + +package armsecretsstoreextension + +import "time" + +// AzureKeyVaultSecretProviderClass - The AzureKeyVaultSecretProviderClass resource. +type AzureKeyVaultSecretProviderClass struct { + // REQUIRED; The geo-location where the resource lives + Location *string + + // READ-ONLY; The name of the AzureKeyVaultSecretProviderClass + Name *string + ExtendedLocation *ExtendedLocation + + // The resource-specific properties for this resource. + Properties *AzureKeyVaultSecretProviderClassProperties + + // Resource tags. + Tags map[string]*string + + // READ-ONLY; Fully qualified resource ID for the resource. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName} + ID *string + + // READ-ONLY; Azure Resource Manager metadata containing createdBy and modifiedBy information. + SystemData *SystemData + + // READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts" + Type *string +} + +// AzureKeyVaultSecretProviderClassListResult - The response of a AzureKeyVaultSecretProviderClass list operation. +type AzureKeyVaultSecretProviderClassListResult struct { + // REQUIRED; The AzureKeyVaultSecretProviderClass items on this page + Value []*AzureKeyVaultSecretProviderClass + + // The link to the next page of items + NextLink *string +} + +// AzureKeyVaultSecretProviderClassProperties - The properties of the AzureKeyVaultSecretProviderClass. +type AzureKeyVaultSecretProviderClassProperties struct { + // REQUIRED; The user assigned managed identity client ID that should be used to access the Azure Key Vault. + ClientID *string + + // REQUIRED; The name of the Azure Key Vault to sync secrets from. + KeyvaultName *string + + // REQUIRED; The Azure Active Directory tenant ID that should be used for authenticating requests to the Azure Key Vault. + TenantID *string + + // Objects defines the desired state of synced K8s secret objects + Objects *string + + // READ-ONLY; Provisioning state of the AzureKeyVaultSecretProviderClass instance. + ProvisioningState *ProvisioningState +} + +// AzureKeyVaultSecretProviderClassUpdate - The type used for update operations of the AzureKeyVaultSecretProviderClass. +type AzureKeyVaultSecretProviderClassUpdate struct { + // The resource-specific properties for this resource. + Properties *AzureKeyVaultSecretProviderClassUpdateProperties + + // Resource tags. + Tags map[string]*string +} + +// AzureKeyVaultSecretProviderClassUpdateProperties - The updatable properties of the AzureKeyVaultSecretProviderClass. +type AzureKeyVaultSecretProviderClassUpdateProperties struct { + // The user assigned managed identity client ID that should be used to access the Azure Key Vault. + ClientID *string + + // The name of the Azure Key Vault to sync secrets from. + KeyvaultName *string + + // Objects defines the desired state of synced K8s secret objects + Objects *string + + // The Azure Active Directory tenant ID that should be used for authenticating requests to the Azure Key Vault. + TenantID *string +} + +// ExtendedLocation - The complex type of the extended location. +type ExtendedLocation struct { + // REQUIRED; The name of the extended location. + Name *string + + // REQUIRED; The type of the extended location. + Type *ExtendedLocationType +} + +// KubernetesSecretObjectMapping - Properties defining the mapping between a cloud secret store object and a Kubernetes Secret. +type KubernetesSecretObjectMapping struct { + // REQUIRED; SourcePath is the identifier for the secret data as defined by the external secret provider. This is the key + // or path to the secret in the provider's system, which gets mounted to a specific path in the pod. The value should match + // the name of the secret as specified in the SecretProviderClass's objects array. + SourcePath *string + + // REQUIRED; TargetKey is the key in the Kubernetes secret's data field where the secret value will be stored. This key is + // used to reference the secret data within Kubernetes, and it should be unique within the secret. + TargetKey *string +} + +// Operation - REST API Operation +// +// Details of a REST API operation, returned from the Resource Provider Operations API +type Operation struct { + // Localized display information for this particular operation. + Display *OperationDisplay + + // READ-ONLY; Extensible enum. Indicates the action type. "Internal" refers to actions that are for internal only APIs. + ActionType *ActionType + + // READ-ONLY; Whether the operation applies to data-plane. This is "true" for data-plane operations and "false" for Azure + // Resource Manager/control-plane operations. + IsDataAction *bool + + // READ-ONLY; The name of the operation, as per Resource-Based Access Control (RBAC). Examples: "Microsoft.Compute/virtualMachines/write", + // "Microsoft.Compute/virtualMachines/capture/action" + Name *string + + // READ-ONLY; The intended executor of the operation; as in Resource Based Access Control (RBAC) and audit logs UX. Default + // value is "user,system" + Origin *Origin +} + +// OperationDisplay - Localized display information for and operation. +type OperationDisplay struct { + // READ-ONLY; The short, localized friendly description of the operation; suitable for tool tips and detailed views. + Description *string + + // READ-ONLY; The concise, localized friendly name for the operation; suitable for dropdowns. E.g. "Create or Update Virtual + // Machine", "Restart Virtual Machine". + Operation *string + + // READ-ONLY; The localized friendly form of the resource provider name, e.g. "Microsoft Monitoring Insights" or "Microsoft + // Compute". + Provider *string + + // READ-ONLY; The localized friendly name of the resource type related to this operation. E.g. "Virtual Machines" or "Job + // Schedule Collections". + Resource *string +} + +// OperationListResult - A list of REST API operations supported by an Azure Resource Provider. It contains an URL link to +// get the next set of results. +type OperationListResult struct { + // REQUIRED; The Operation items on this page + Value []*Operation + + // The link to the next page of items + NextLink *string +} + +// SecretSync - The SecretSync resource. +type SecretSync struct { + // REQUIRED; The geo-location where the resource lives + Location *string + + // READ-ONLY; The name of the SecretSync + Name *string + ExtendedLocation *ExtendedLocation + + // The resource-specific properties for this resource. + Properties *SecretSyncProperties + + // Resource tags. + Tags map[string]*string + + // READ-ONLY; Fully qualified resource ID for the resource. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName} + ID *string + + // READ-ONLY; Azure Resource Manager metadata containing createdBy and modifiedBy information. + SystemData *SystemData + + // READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts" + Type *string +} + +// SecretSyncCondition - A condition represents the status of the secret create and update processes. +type SecretSyncCondition struct { + // READ-ONLY; Message is a human readable message indicating details about the transition. This may be an empty string. + Message *string + + // READ-ONLY; Reason contains a programmatic identifier indicating the reason for the condition's last transition. Producers + // of specific condition types may define expected values and meanings for this field, and whether the values are considered + // a guaranteed API. The value should be a CamelCase string. This field may not be empty. + Reason *string + + // READ-ONLY; Status of the condition, one of True, False, Unknown. + Status *StatusConditionType + + // READ-ONLY; Type of condition in CamelCase or in foo.example.com/CamelCase. Many .condition.type values are consistent across + // resources like Available, but because arbitrary conditions can be useful (see .node.status.conditions), the ability to + // de-conflict is important. The regex it matches is (dns1123SubdomainFmt/)?(qualifiedNameFmt) + Type *string + + // READ-ONLY; LastTransitionTime is the last time the condition transitioned from one status to another. This should be when + // the underlying condition changed. If that is not known, then using the time when the API field changed is acceptable. + LastTransitionTime *time.Time + + // READ-ONLY; ObservedGeneration represents the .metadata.generation that the condition was set based upon. For instance, + // if .metadata.generation is currently 12, but the .status.conditions[x].observedGeneration is 9, the condition is out of + // date with respect to the current state of the instance. + ObservedGeneration *int64 +} + +// SecretSyncListResult - The response of a SecretSync list operation. +type SecretSyncListResult struct { + // REQUIRED; The SecretSync items on this page + Value []*SecretSync + + // The link to the next page of items + NextLink *string +} + +// SecretSyncProperties - The properties of the SecretSync instance. +type SecretSyncProperties struct { + // REQUIRED; Type specifies the type of the Kubernetes secret object, e.g. "Opaque" or"kubernetes.io/tls". The controller + // must have permission to create secrets of the specified type. + KubernetesSecretType *KubernetesSecretType + + // REQUIRED; An array of SecretObjectData that maps secret data from the external secret provider to the Kubernetes secret. + // Each entry specifies the source secret in the external provider and the corresponding key in the Kubernetes secret. + ObjectSecretMapping []*KubernetesSecretObjectMapping + + // REQUIRED; SecretProviderClassName specifies the name of the SecretProviderClass resource, which contains the information + // needed to access the cloud provider secret store. + SecretProviderClassName *string + + // REQUIRED; ServiceAccountName specifies the name of the service account used to access the cloud provider secret store. + // The audience field in the service account token must be passed as parameter in the controller configuration. The audience + // is used when requesting a token from the API server for the service account; the supported audiences are defined by each + // provider. + ServiceAccountName *string + + // ForceSynchronization can be used to force the secret synchronization. The secret synchronization is triggered by changing + // the value in this field. This field is not used to resolve synchronization conflicts. + ForceSynchronization *string + + // READ-ONLY; Provisioning state of the SecretSync instance. + ProvisioningState *ProvisioningState + + // READ-ONLY; SecretSyncStatus defines the observed state of the secret synchronization process. + Status *SecretSyncStatus +} + +// SecretSyncStatus defines the observed state of the secret synchronization process. +type SecretSyncStatus struct { + // READ-ONLY; Conditions represent the status of the secret create and update processes. The status can be True, False, or + // Unknown with various reasons and messages explaining the state. Examples of reasons include CreateSucceeded, ProviderError, + // InvalidClusterSecretLabelError, InvalidClusterSecretAnnotationError, UnknownError, ValidatingAdmissionPolicyCheckFailed, + // UserInputValidationFailed, ControllerSpcError, ControllerInternalError, NoValueChange, and ValueChangeOrForceUpdateDetected. + Conditions []*SecretSyncCondition + + // READ-ONLY; LastSuccessfulSyncTime represents the last time the secret was retrieved from the Provider and updated. + LastSuccessfulSyncTime *time.Time +} + +// SecretSyncUpdate - The type used for update operations of the SecretSync. +type SecretSyncUpdate struct { + // The resource-specific properties for this resource. + Properties *SecretSyncUpdateProperties + + // Resource tags. + Tags map[string]*string +} + +// SecretSyncUpdateProperties - The updatable properties of the SecretSync. +type SecretSyncUpdateProperties struct { + // ForceSynchronization can be used to force the secret synchronization. The secret synchronization is triggered by changing + // the value in this field. This field is not used to resolve synchronization conflicts. + ForceSynchronization *string + + // Type specifies the type of the Kubernetes secret object, e.g. "Opaque" or"kubernetes.io/tls". The controller must have + // permission to create secrets of the specified type. + KubernetesSecretType *KubernetesSecretType + + // An array of SecretObjectData that maps secret data from the external secret provider to the Kubernetes secret. Each entry + // specifies the source secret in the external provider and the corresponding key in the Kubernetes secret. + ObjectSecretMapping []*KubernetesSecretObjectMapping + + // SecretProviderClassName specifies the name of the SecretProviderClass resource, which contains the information needed to + // access the cloud provider secret store. + SecretProviderClassName *string + + // ServiceAccountName specifies the name of the service account used to access the cloud provider secret store. The audience + // field in the service account token must be passed as parameter in the controller configuration. The audience is used when + // requesting a token from the API server for the service account; the supported audiences are defined by each provider. + ServiceAccountName *string +} + +// SystemData - Metadata pertaining to creation and last modification of the resource. +type SystemData struct { + // The timestamp of resource creation (UTC). + CreatedAt *time.Time + + // The identity that created the resource. + CreatedBy *string + + // The type of identity that created the resource. + CreatedByType *CreatedByType + + // The timestamp of resource last modification (UTC) + LastModifiedAt *time.Time + + // The identity that last modified the resource. + LastModifiedBy *string + + // The type of identity that last modified the resource. + LastModifiedByType *CreatedByType +} diff --git a/sdk/resourcemanager/secretsstoreextension/armsecretsstoreextension/models_serde.go b/sdk/resourcemanager/secretsstoreextension/armsecretsstoreextension/models_serde.go new file mode 100644 index 000000000000..f26b176dc81c --- /dev/null +++ b/sdk/resourcemanager/secretsstoreextension/armsecretsstoreextension/models_serde.go @@ -0,0 +1,742 @@ +// 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) Go Code Generator. DO NOT EDIT. + +package armsecretsstoreextension + +import ( + "encoding/json" + "fmt" + "github.com/Azure/azure-sdk-for-go/sdk/azcore" + "reflect" +) + +// MarshalJSON implements the json.Marshaller interface for type AzureKeyVaultSecretProviderClass. +func (a AzureKeyVaultSecretProviderClass) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "extendedLocation", a.ExtendedLocation) + populate(objectMap, "id", a.ID) + populate(objectMap, "location", a.Location) + populate(objectMap, "name", a.Name) + populate(objectMap, "properties", a.Properties) + populate(objectMap, "systemData", a.SystemData) + populate(objectMap, "tags", a.Tags) + populate(objectMap, "type", a.Type) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type AzureKeyVaultSecretProviderClass. +func (a *AzureKeyVaultSecretProviderClass) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", a, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "extendedLocation": + err = unpopulate(val, "ExtendedLocation", &a.ExtendedLocation) + delete(rawMsg, key) + case "id": + err = unpopulate(val, "ID", &a.ID) + delete(rawMsg, key) + case "location": + err = unpopulate(val, "Location", &a.Location) + delete(rawMsg, key) + case "name": + err = unpopulate(val, "Name", &a.Name) + delete(rawMsg, key) + case "properties": + err = unpopulate(val, "Properties", &a.Properties) + delete(rawMsg, key) + case "systemData": + err = unpopulate(val, "SystemData", &a.SystemData) + delete(rawMsg, key) + case "tags": + err = unpopulate(val, "Tags", &a.Tags) + delete(rawMsg, key) + case "type": + err = unpopulate(val, "Type", &a.Type) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", a, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type AzureKeyVaultSecretProviderClassListResult. +func (a AzureKeyVaultSecretProviderClassListResult) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "nextLink", a.NextLink) + populate(objectMap, "value", a.Value) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type AzureKeyVaultSecretProviderClassListResult. +func (a *AzureKeyVaultSecretProviderClassListResult) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", a, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "nextLink": + err = unpopulate(val, "NextLink", &a.NextLink) + delete(rawMsg, key) + case "value": + err = unpopulate(val, "Value", &a.Value) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", a, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type AzureKeyVaultSecretProviderClassProperties. +func (a AzureKeyVaultSecretProviderClassProperties) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "clientId", a.ClientID) + populate(objectMap, "keyvaultName", a.KeyvaultName) + populate(objectMap, "objects", a.Objects) + populate(objectMap, "provisioningState", a.ProvisioningState) + populate(objectMap, "tenantId", a.TenantID) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type AzureKeyVaultSecretProviderClassProperties. +func (a *AzureKeyVaultSecretProviderClassProperties) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", a, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "clientId": + err = unpopulate(val, "ClientID", &a.ClientID) + delete(rawMsg, key) + case "keyvaultName": + err = unpopulate(val, "KeyvaultName", &a.KeyvaultName) + delete(rawMsg, key) + case "objects": + err = unpopulate(val, "Objects", &a.Objects) + delete(rawMsg, key) + case "provisioningState": + err = unpopulate(val, "ProvisioningState", &a.ProvisioningState) + delete(rawMsg, key) + case "tenantId": + err = unpopulate(val, "TenantID", &a.TenantID) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", a, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type AzureKeyVaultSecretProviderClassUpdate. +func (a AzureKeyVaultSecretProviderClassUpdate) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "properties", a.Properties) + populate(objectMap, "tags", a.Tags) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type AzureKeyVaultSecretProviderClassUpdate. +func (a *AzureKeyVaultSecretProviderClassUpdate) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", a, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "properties": + err = unpopulate(val, "Properties", &a.Properties) + delete(rawMsg, key) + case "tags": + err = unpopulate(val, "Tags", &a.Tags) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", a, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type AzureKeyVaultSecretProviderClassUpdateProperties. +func (a AzureKeyVaultSecretProviderClassUpdateProperties) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "clientId", a.ClientID) + populate(objectMap, "keyvaultName", a.KeyvaultName) + populate(objectMap, "objects", a.Objects) + populate(objectMap, "tenantId", a.TenantID) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type AzureKeyVaultSecretProviderClassUpdateProperties. +func (a *AzureKeyVaultSecretProviderClassUpdateProperties) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", a, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "clientId": + err = unpopulate(val, "ClientID", &a.ClientID) + delete(rawMsg, key) + case "keyvaultName": + err = unpopulate(val, "KeyvaultName", &a.KeyvaultName) + delete(rawMsg, key) + case "objects": + err = unpopulate(val, "Objects", &a.Objects) + delete(rawMsg, key) + case "tenantId": + err = unpopulate(val, "TenantID", &a.TenantID) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", a, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type ExtendedLocation. +func (e ExtendedLocation) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "name", e.Name) + populate(objectMap, "type", e.Type) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type ExtendedLocation. +func (e *ExtendedLocation) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", e, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "name": + err = unpopulate(val, "Name", &e.Name) + delete(rawMsg, key) + case "type": + err = unpopulate(val, "Type", &e.Type) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", e, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type KubernetesSecretObjectMapping. +func (k KubernetesSecretObjectMapping) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "sourcePath", k.SourcePath) + populate(objectMap, "targetKey", k.TargetKey) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type KubernetesSecretObjectMapping. +func (k *KubernetesSecretObjectMapping) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", k, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "sourcePath": + err = unpopulate(val, "SourcePath", &k.SourcePath) + delete(rawMsg, key) + case "targetKey": + err = unpopulate(val, "TargetKey", &k.TargetKey) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", k, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type Operation. +func (o Operation) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "actionType", o.ActionType) + populate(objectMap, "display", o.Display) + populate(objectMap, "isDataAction", o.IsDataAction) + populate(objectMap, "name", o.Name) + populate(objectMap, "origin", o.Origin) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type Operation. +func (o *Operation) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", o, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "actionType": + err = unpopulate(val, "ActionType", &o.ActionType) + delete(rawMsg, key) + case "display": + err = unpopulate(val, "Display", &o.Display) + delete(rawMsg, key) + case "isDataAction": + err = unpopulate(val, "IsDataAction", &o.IsDataAction) + delete(rawMsg, key) + case "name": + err = unpopulate(val, "Name", &o.Name) + delete(rawMsg, key) + case "origin": + err = unpopulate(val, "Origin", &o.Origin) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", o, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type OperationDisplay. +func (o OperationDisplay) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "description", o.Description) + populate(objectMap, "operation", o.Operation) + populate(objectMap, "provider", o.Provider) + populate(objectMap, "resource", o.Resource) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type OperationDisplay. +func (o *OperationDisplay) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", o, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "description": + err = unpopulate(val, "Description", &o.Description) + delete(rawMsg, key) + case "operation": + err = unpopulate(val, "Operation", &o.Operation) + delete(rawMsg, key) + case "provider": + err = unpopulate(val, "Provider", &o.Provider) + delete(rawMsg, key) + case "resource": + err = unpopulate(val, "Resource", &o.Resource) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", o, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type OperationListResult. +func (o OperationListResult) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "nextLink", o.NextLink) + populate(objectMap, "value", o.Value) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type OperationListResult. +func (o *OperationListResult) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", o, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "nextLink": + err = unpopulate(val, "NextLink", &o.NextLink) + delete(rawMsg, key) + case "value": + err = unpopulate(val, "Value", &o.Value) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", o, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type SecretSync. +func (s SecretSync) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "extendedLocation", s.ExtendedLocation) + populate(objectMap, "id", s.ID) + populate(objectMap, "location", s.Location) + populate(objectMap, "name", s.Name) + populate(objectMap, "properties", s.Properties) + populate(objectMap, "systemData", s.SystemData) + populate(objectMap, "tags", s.Tags) + populate(objectMap, "type", s.Type) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type SecretSync. +func (s *SecretSync) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "extendedLocation": + err = unpopulate(val, "ExtendedLocation", &s.ExtendedLocation) + delete(rawMsg, key) + case "id": + err = unpopulate(val, "ID", &s.ID) + delete(rawMsg, key) + case "location": + err = unpopulate(val, "Location", &s.Location) + delete(rawMsg, key) + case "name": + err = unpopulate(val, "Name", &s.Name) + delete(rawMsg, key) + case "properties": + err = unpopulate(val, "Properties", &s.Properties) + delete(rawMsg, key) + case "systemData": + err = unpopulate(val, "SystemData", &s.SystemData) + delete(rawMsg, key) + case "tags": + err = unpopulate(val, "Tags", &s.Tags) + delete(rawMsg, key) + case "type": + err = unpopulate(val, "Type", &s.Type) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type SecretSyncCondition. +func (s SecretSyncCondition) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populateDateTimeRFC3339(objectMap, "lastTransitionTime", s.LastTransitionTime) + populate(objectMap, "message", s.Message) + populate(objectMap, "observedGeneration", s.ObservedGeneration) + populate(objectMap, "reason", s.Reason) + populate(objectMap, "status", s.Status) + populate(objectMap, "type", s.Type) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type SecretSyncCondition. +func (s *SecretSyncCondition) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "lastTransitionTime": + err = unpopulateDateTimeRFC3339(val, "LastTransitionTime", &s.LastTransitionTime) + delete(rawMsg, key) + case "message": + err = unpopulate(val, "Message", &s.Message) + delete(rawMsg, key) + case "observedGeneration": + err = unpopulate(val, "ObservedGeneration", &s.ObservedGeneration) + delete(rawMsg, key) + case "reason": + err = unpopulate(val, "Reason", &s.Reason) + delete(rawMsg, key) + case "status": + err = unpopulate(val, "Status", &s.Status) + delete(rawMsg, key) + case "type": + err = unpopulate(val, "Type", &s.Type) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type SecretSyncListResult. +func (s SecretSyncListResult) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "nextLink", s.NextLink) + populate(objectMap, "value", s.Value) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type SecretSyncListResult. +func (s *SecretSyncListResult) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "nextLink": + err = unpopulate(val, "NextLink", &s.NextLink) + delete(rawMsg, key) + case "value": + err = unpopulate(val, "Value", &s.Value) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type SecretSyncProperties. +func (s SecretSyncProperties) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "forceSynchronization", s.ForceSynchronization) + populate(objectMap, "kubernetesSecretType", s.KubernetesSecretType) + populate(objectMap, "objectSecretMapping", s.ObjectSecretMapping) + populate(objectMap, "provisioningState", s.ProvisioningState) + populate(objectMap, "secretProviderClassName", s.SecretProviderClassName) + populate(objectMap, "serviceAccountName", s.ServiceAccountName) + populate(objectMap, "status", s.Status) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type SecretSyncProperties. +func (s *SecretSyncProperties) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "forceSynchronization": + err = unpopulate(val, "ForceSynchronization", &s.ForceSynchronization) + delete(rawMsg, key) + case "kubernetesSecretType": + err = unpopulate(val, "KubernetesSecretType", &s.KubernetesSecretType) + delete(rawMsg, key) + case "objectSecretMapping": + err = unpopulate(val, "ObjectSecretMapping", &s.ObjectSecretMapping) + delete(rawMsg, key) + case "provisioningState": + err = unpopulate(val, "ProvisioningState", &s.ProvisioningState) + delete(rawMsg, key) + case "secretProviderClassName": + err = unpopulate(val, "SecretProviderClassName", &s.SecretProviderClassName) + delete(rawMsg, key) + case "serviceAccountName": + err = unpopulate(val, "ServiceAccountName", &s.ServiceAccountName) + delete(rawMsg, key) + case "status": + err = unpopulate(val, "Status", &s.Status) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type SecretSyncStatus. +func (s SecretSyncStatus) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "conditions", s.Conditions) + populateDateTimeRFC3339(objectMap, "lastSuccessfulSyncTime", s.LastSuccessfulSyncTime) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type SecretSyncStatus. +func (s *SecretSyncStatus) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "conditions": + err = unpopulate(val, "Conditions", &s.Conditions) + delete(rawMsg, key) + case "lastSuccessfulSyncTime": + err = unpopulateDateTimeRFC3339(val, "LastSuccessfulSyncTime", &s.LastSuccessfulSyncTime) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type SecretSyncUpdate. +func (s SecretSyncUpdate) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "properties", s.Properties) + populate(objectMap, "tags", s.Tags) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type SecretSyncUpdate. +func (s *SecretSyncUpdate) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "properties": + err = unpopulate(val, "Properties", &s.Properties) + delete(rawMsg, key) + case "tags": + err = unpopulate(val, "Tags", &s.Tags) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type SecretSyncUpdateProperties. +func (s SecretSyncUpdateProperties) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "forceSynchronization", s.ForceSynchronization) + populate(objectMap, "kubernetesSecretType", s.KubernetesSecretType) + populate(objectMap, "objectSecretMapping", s.ObjectSecretMapping) + populate(objectMap, "secretProviderClassName", s.SecretProviderClassName) + populate(objectMap, "serviceAccountName", s.ServiceAccountName) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type SecretSyncUpdateProperties. +func (s *SecretSyncUpdateProperties) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "forceSynchronization": + err = unpopulate(val, "ForceSynchronization", &s.ForceSynchronization) + delete(rawMsg, key) + case "kubernetesSecretType": + err = unpopulate(val, "KubernetesSecretType", &s.KubernetesSecretType) + delete(rawMsg, key) + case "objectSecretMapping": + err = unpopulate(val, "ObjectSecretMapping", &s.ObjectSecretMapping) + delete(rawMsg, key) + case "secretProviderClassName": + err = unpopulate(val, "SecretProviderClassName", &s.SecretProviderClassName) + delete(rawMsg, key) + case "serviceAccountName": + err = unpopulate(val, "ServiceAccountName", &s.ServiceAccountName) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type SystemData. +func (s SystemData) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populateDateTimeRFC3339(objectMap, "createdAt", s.CreatedAt) + populate(objectMap, "createdBy", s.CreatedBy) + populate(objectMap, "createdByType", s.CreatedByType) + populateDateTimeRFC3339(objectMap, "lastModifiedAt", s.LastModifiedAt) + populate(objectMap, "lastModifiedBy", s.LastModifiedBy) + populate(objectMap, "lastModifiedByType", s.LastModifiedByType) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type SystemData. +func (s *SystemData) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "createdAt": + err = unpopulateDateTimeRFC3339(val, "CreatedAt", &s.CreatedAt) + delete(rawMsg, key) + case "createdBy": + err = unpopulate(val, "CreatedBy", &s.CreatedBy) + delete(rawMsg, key) + case "createdByType": + err = unpopulate(val, "CreatedByType", &s.CreatedByType) + delete(rawMsg, key) + case "lastModifiedAt": + err = unpopulateDateTimeRFC3339(val, "LastModifiedAt", &s.LastModifiedAt) + delete(rawMsg, key) + case "lastModifiedBy": + err = unpopulate(val, "LastModifiedBy", &s.LastModifiedBy) + delete(rawMsg, key) + case "lastModifiedByType": + err = unpopulate(val, "LastModifiedByType", &s.LastModifiedByType) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + } + return nil +} + +func populate(m map[string]any, k string, v any) { + if v == nil { + return + } else if azcore.IsNullValue(v) { + m[k] = nil + } else if !reflect.ValueOf(v).IsNil() { + m[k] = v + } +} + +func unpopulate(data json.RawMessage, fn string, v any) error { + if data == nil || string(data) == "null" { + return nil + } + if err := json.Unmarshal(data, v); err != nil { + return fmt.Errorf("struct field %s: %v", fn, err) + } + return nil +} diff --git a/sdk/resourcemanager/secretsstoreextension/armsecretsstoreextension/operations_client.go b/sdk/resourcemanager/secretsstoreextension/armsecretsstoreextension/operations_client.go new file mode 100644 index 000000000000..fdf660e999c2 --- /dev/null +++ b/sdk/resourcemanager/secretsstoreextension/armsecretsstoreextension/operations_client.go @@ -0,0 +1,84 @@ +// 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) Go Code Generator. DO NOT EDIT. + +package armsecretsstoreextension + +import ( + "context" + "github.com/Azure/azure-sdk-for-go/sdk/azcore" + "github.com/Azure/azure-sdk-for-go/sdk/azcore/arm" + "github.com/Azure/azure-sdk-for-go/sdk/azcore/policy" + "github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime" + "net/http" +) + +// OperationsClient contains the methods for the Operations group. +// Don't use this type directly, use NewOperationsClient() instead. +type OperationsClient struct { + internal *arm.Client +} + +// NewOperationsClient creates a new instance of OperationsClient with the specified values. +// - credential - used to authorize requests. Usually a credential from azidentity. +// - options - pass nil to accept the default values. +func NewOperationsClient(credential azcore.TokenCredential, options *arm.ClientOptions) (*OperationsClient, error) { + cl, err := arm.NewClient(moduleName, moduleVersion, credential, options) + if err != nil { + return nil, err + } + client := &OperationsClient{ + internal: cl, + } + return client, nil +} + +// NewListPager - List the operations for the provider +// +// Generated from API version 2024-08-21-preview +// - options - OperationsClientListOptions contains the optional parameters for the OperationsClient.NewListPager method. +func (client *OperationsClient) NewListPager(options *OperationsClientListOptions) *runtime.Pager[OperationsClientListResponse] { + return runtime.NewPager(runtime.PagingHandler[OperationsClientListResponse]{ + More: func(page OperationsClientListResponse) bool { + return page.NextLink != nil && len(*page.NextLink) > 0 + }, + Fetcher: func(ctx context.Context, page *OperationsClientListResponse) (OperationsClientListResponse, error) { + ctx = context.WithValue(ctx, runtime.CtxAPINameKey{}, "OperationsClient.NewListPager") + nextLink := "" + if page != nil { + nextLink = *page.NextLink + } + resp, err := runtime.FetcherForNextLink(ctx, client.internal.Pipeline(), nextLink, func(ctx context.Context) (*policy.Request, error) { + return client.listCreateRequest(ctx, options) + }, nil) + if err != nil { + return OperationsClientListResponse{}, err + } + return client.listHandleResponse(resp) + }, + Tracer: client.internal.Tracer(), + }) +} + +// listCreateRequest creates the List request. +func (client *OperationsClient) listCreateRequest(ctx context.Context, _ *OperationsClientListOptions) (*policy.Request, error) { + urlPath := "/providers/Microsoft.SecretSyncController/operations" + req, err := runtime.NewRequest(ctx, http.MethodGet, runtime.JoinPaths(client.internal.Endpoint(), urlPath)) + if err != nil { + return nil, err + } + reqQP := req.Raw().URL.Query() + reqQP.Set("api-version", "2024-08-21-preview") + req.Raw().URL.RawQuery = reqQP.Encode() + req.Raw().Header["Accept"] = []string{"application/json"} + return req, nil +} + +// listHandleResponse handles the List response. +func (client *OperationsClient) listHandleResponse(resp *http.Response) (OperationsClientListResponse, error) { + result := OperationsClientListResponse{} + if err := runtime.UnmarshalAsJSON(resp, &result.OperationListResult); err != nil { + return OperationsClientListResponse{}, err + } + return result, nil +} diff --git a/sdk/resourcemanager/secretsstoreextension/armsecretsstoreextension/operations_client_example_test.go b/sdk/resourcemanager/secretsstoreextension/armsecretsstoreextension/operations_client_example_test.go new file mode 100644 index 000000000000..4433a8a43e68 --- /dev/null +++ b/sdk/resourcemanager/secretsstoreextension/armsecretsstoreextension/operations_client_example_test.go @@ -0,0 +1,56 @@ +// 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) Go Code Generator. DO NOT EDIT. + +package armsecretsstoreextension_test + +import ( + "context" + "github.com/Azure/azure-sdk-for-go/sdk/azidentity" + "github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/secretsstoreextension/armsecretsstoreextension" + "log" +) + +// Generated from example definition: 2024-08-21-preview/Operations_List_MaximumSet_Gen.json +func ExampleOperationsClient_NewListPager() { + cred, err := azidentity.NewDefaultAzureCredential(nil) + if err != nil { + log.Fatalf("failed to obtain a credential: %v", err) + } + ctx := context.Background() + clientFactory, err := armsecretsstoreextension.NewClientFactory("", cred, nil) + if err != nil { + log.Fatalf("failed to create client: %v", err) + } + pager := clientFactory.NewOperationsClient().NewListPager(nil) + for pager.More() { + page, err := pager.NextPage(ctx) + if err != nil { + log.Fatalf("failed to advance page: %v", err) + } + for _, v := range page.Value { + // You could use page here. We use blank identifier for just demo purposes. + _ = v + } + // If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes. + // page = armsecretsstoreextension.OperationsClientListResponse{ + // OperationListResult: armsecretsstoreextension.OperationListResult{ + // Value: []*armsecretsstoreextension.Operation{ + // { + // Name: to.Ptr("Microsoft.SecretSyncController/SecretSyncs/write"), + // IsDataAction: to.Ptr(true), + // Display: &armsecretsstoreextension.OperationDisplay{ + // Provider: to.Ptr("Microsoft.SecretSyncController"), + // Resource: to.Ptr("SecretSyncs"), + // Operation: to.Ptr("write"), + // Description: to.Ptr("write SecretSyncs resource"), + // }, + // Origin: to.Ptr(armsecretsstoreextension.OriginUser), + // ActionType: to.Ptr(armsecretsstoreextension.ActionTypeInternal), + // }, + // }, + // NextLink: to.Ptr("https://microsoft.com/aolkmb"), + // }, + // } + } +} diff --git a/sdk/resourcemanager/secretsstoreextension/armsecretsstoreextension/options.go b/sdk/resourcemanager/secretsstoreextension/armsecretsstoreextension/options.go new file mode 100644 index 000000000000..ba83d0bb407e --- /dev/null +++ b/sdk/resourcemanager/secretsstoreextension/armsecretsstoreextension/options.go @@ -0,0 +1,85 @@ +// 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) Go Code Generator. DO NOT EDIT. + +package armsecretsstoreextension + +// AzureKeyVaultSecretProviderClassesClientBeginCreateOrUpdateOptions contains the optional parameters for the AzureKeyVaultSecretProviderClassesClient.BeginCreateOrUpdate +// method. +type AzureKeyVaultSecretProviderClassesClientBeginCreateOrUpdateOptions struct { + // Resumes the long-running operation from the provided token. + ResumeToken string +} + +// AzureKeyVaultSecretProviderClassesClientBeginDeleteOptions contains the optional parameters for the AzureKeyVaultSecretProviderClassesClient.BeginDelete +// method. +type AzureKeyVaultSecretProviderClassesClientBeginDeleteOptions struct { + // Resumes the long-running operation from the provided token. + ResumeToken string +} + +// AzureKeyVaultSecretProviderClassesClientBeginUpdateOptions contains the optional parameters for the AzureKeyVaultSecretProviderClassesClient.BeginUpdate +// method. +type AzureKeyVaultSecretProviderClassesClientBeginUpdateOptions struct { + // Resumes the long-running operation from the provided token. + ResumeToken string +} + +// AzureKeyVaultSecretProviderClassesClientGetOptions contains the optional parameters for the AzureKeyVaultSecretProviderClassesClient.Get +// method. +type AzureKeyVaultSecretProviderClassesClientGetOptions struct { + // placeholder for future optional parameters +} + +// AzureKeyVaultSecretProviderClassesClientListByResourceGroupOptions contains the optional parameters for the AzureKeyVaultSecretProviderClassesClient.NewListByResourceGroupPager +// method. +type AzureKeyVaultSecretProviderClassesClientListByResourceGroupOptions struct { + // placeholder for future optional parameters +} + +// AzureKeyVaultSecretProviderClassesClientListBySubscriptionOptions contains the optional parameters for the AzureKeyVaultSecretProviderClassesClient.NewListBySubscriptionPager +// method. +type AzureKeyVaultSecretProviderClassesClientListBySubscriptionOptions struct { + // placeholder for future optional parameters +} + +// OperationsClientListOptions contains the optional parameters for the OperationsClient.NewListPager method. +type OperationsClientListOptions struct { + // placeholder for future optional parameters +} + +// SecretSyncsClientBeginCreateOrUpdateOptions contains the optional parameters for the SecretSyncsClient.BeginCreateOrUpdate +// method. +type SecretSyncsClientBeginCreateOrUpdateOptions struct { + // Resumes the long-running operation from the provided token. + ResumeToken string +} + +// SecretSyncsClientBeginDeleteOptions contains the optional parameters for the SecretSyncsClient.BeginDelete method. +type SecretSyncsClientBeginDeleteOptions struct { + // Resumes the long-running operation from the provided token. + ResumeToken string +} + +// SecretSyncsClientBeginUpdateOptions contains the optional parameters for the SecretSyncsClient.BeginUpdate method. +type SecretSyncsClientBeginUpdateOptions struct { + // Resumes the long-running operation from the provided token. + ResumeToken string +} + +// SecretSyncsClientGetOptions contains the optional parameters for the SecretSyncsClient.Get method. +type SecretSyncsClientGetOptions struct { + // placeholder for future optional parameters +} + +// SecretSyncsClientListByResourceGroupOptions contains the optional parameters for the SecretSyncsClient.NewListByResourceGroupPager +// method. +type SecretSyncsClientListByResourceGroupOptions struct { + // placeholder for future optional parameters +} + +// SecretSyncsClientListBySubscriptionOptions contains the optional parameters for the SecretSyncsClient.NewListBySubscriptionPager +// method. +type SecretSyncsClientListBySubscriptionOptions struct { + // placeholder for future optional parameters +} diff --git a/sdk/resourcemanager/secretsstoreextension/armsecretsstoreextension/responses.go b/sdk/resourcemanager/secretsstoreextension/armsecretsstoreextension/responses.go new file mode 100644 index 000000000000..e46dd963dbe9 --- /dev/null +++ b/sdk/resourcemanager/secretsstoreextension/armsecretsstoreextension/responses.go @@ -0,0 +1,81 @@ +// 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) Go Code Generator. DO NOT EDIT. + +package armsecretsstoreextension + +// AzureKeyVaultSecretProviderClassesClientCreateOrUpdateResponse contains the response from method AzureKeyVaultSecretProviderClassesClient.BeginCreateOrUpdate. +type AzureKeyVaultSecretProviderClassesClientCreateOrUpdateResponse struct { + // The AzureKeyVaultSecretProviderClass resource. + AzureKeyVaultSecretProviderClass +} + +// AzureKeyVaultSecretProviderClassesClientDeleteResponse contains the response from method AzureKeyVaultSecretProviderClassesClient.BeginDelete. +type AzureKeyVaultSecretProviderClassesClientDeleteResponse struct { + // placeholder for future response values +} + +// AzureKeyVaultSecretProviderClassesClientGetResponse contains the response from method AzureKeyVaultSecretProviderClassesClient.Get. +type AzureKeyVaultSecretProviderClassesClientGetResponse struct { + // The AzureKeyVaultSecretProviderClass resource. + AzureKeyVaultSecretProviderClass +} + +// AzureKeyVaultSecretProviderClassesClientListByResourceGroupResponse contains the response from method AzureKeyVaultSecretProviderClassesClient.NewListByResourceGroupPager. +type AzureKeyVaultSecretProviderClassesClientListByResourceGroupResponse struct { + // The response of a AzureKeyVaultSecretProviderClass list operation. + AzureKeyVaultSecretProviderClassListResult +} + +// AzureKeyVaultSecretProviderClassesClientListBySubscriptionResponse contains the response from method AzureKeyVaultSecretProviderClassesClient.NewListBySubscriptionPager. +type AzureKeyVaultSecretProviderClassesClientListBySubscriptionResponse struct { + // The response of a AzureKeyVaultSecretProviderClass list operation. + AzureKeyVaultSecretProviderClassListResult +} + +// AzureKeyVaultSecretProviderClassesClientUpdateResponse contains the response from method AzureKeyVaultSecretProviderClassesClient.BeginUpdate. +type AzureKeyVaultSecretProviderClassesClientUpdateResponse struct { + // The AzureKeyVaultSecretProviderClass resource. + AzureKeyVaultSecretProviderClass +} + +// OperationsClientListResponse contains the response from method OperationsClient.NewListPager. +type OperationsClientListResponse struct { + // A list of REST API operations supported by an Azure Resource Provider. It contains an URL link to get the next set of results. + OperationListResult +} + +// SecretSyncsClientCreateOrUpdateResponse contains the response from method SecretSyncsClient.BeginCreateOrUpdate. +type SecretSyncsClientCreateOrUpdateResponse struct { + // The SecretSync resource. + SecretSync +} + +// SecretSyncsClientDeleteResponse contains the response from method SecretSyncsClient.BeginDelete. +type SecretSyncsClientDeleteResponse struct { + // placeholder for future response values +} + +// SecretSyncsClientGetResponse contains the response from method SecretSyncsClient.Get. +type SecretSyncsClientGetResponse struct { + // The SecretSync resource. + SecretSync +} + +// SecretSyncsClientListByResourceGroupResponse contains the response from method SecretSyncsClient.NewListByResourceGroupPager. +type SecretSyncsClientListByResourceGroupResponse struct { + // The response of a SecretSync list operation. + SecretSyncListResult +} + +// SecretSyncsClientListBySubscriptionResponse contains the response from method SecretSyncsClient.NewListBySubscriptionPager. +type SecretSyncsClientListBySubscriptionResponse struct { + // The response of a SecretSync list operation. + SecretSyncListResult +} + +// SecretSyncsClientUpdateResponse contains the response from method SecretSyncsClient.BeginUpdate. +type SecretSyncsClientUpdateResponse struct { + // The SecretSync resource. + SecretSync +} diff --git a/sdk/resourcemanager/secretsstoreextension/armsecretsstoreextension/secretsyncs_client.go b/sdk/resourcemanager/secretsstoreextension/armsecretsstoreextension/secretsyncs_client.go new file mode 100644 index 000000000000..bd31366f73dc --- /dev/null +++ b/sdk/resourcemanager/secretsstoreextension/armsecretsstoreextension/secretsyncs_client.go @@ -0,0 +1,455 @@ +// 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) Go Code Generator. DO NOT EDIT. + +package armsecretsstoreextension + +import ( + "context" + "errors" + "github.com/Azure/azure-sdk-for-go/sdk/azcore" + "github.com/Azure/azure-sdk-for-go/sdk/azcore/arm" + "github.com/Azure/azure-sdk-for-go/sdk/azcore/policy" + "github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime" + "net/http" + "net/url" + "strings" +) + +// SecretSyncsClient contains the methods for the SecretSyncs group. +// Don't use this type directly, use NewSecretSyncsClient() instead. +type SecretSyncsClient struct { + internal *arm.Client + subscriptionID string +} + +// NewSecretSyncsClient creates a new instance of SecretSyncsClient with the specified values. +// - subscriptionID - The ID of the target subscription. The value must be an UUID. +// - credential - used to authorize requests. Usually a credential from azidentity. +// - options - pass nil to accept the default values. +func NewSecretSyncsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*SecretSyncsClient, error) { + cl, err := arm.NewClient(moduleName, moduleVersion, credential, options) + if err != nil { + return nil, err + } + client := &SecretSyncsClient{ + subscriptionID: subscriptionID, + internal: cl, + } + return client, nil +} + +// BeginCreateOrUpdate - Creates new or updates a SecretSync instance. +// If the operation fails it returns an *azcore.ResponseError type. +// +// Generated from API version 2024-08-21-preview +// - resourceGroupName - The name of the resource group. The name is case insensitive. +// - secretSyncName - The name of the SecretSync +// - resource - Resource create parameters. +// - options - SecretSyncsClientBeginCreateOrUpdateOptions contains the optional parameters for the SecretSyncsClient.BeginCreateOrUpdate +// method. +func (client *SecretSyncsClient) BeginCreateOrUpdate(ctx context.Context, resourceGroupName string, secretSyncName string, resource SecretSync, options *SecretSyncsClientBeginCreateOrUpdateOptions) (*runtime.Poller[SecretSyncsClientCreateOrUpdateResponse], error) { + if options == nil || options.ResumeToken == "" { + resp, err := client.createOrUpdate(ctx, resourceGroupName, secretSyncName, resource, options) + if err != nil { + return nil, err + } + poller, err := runtime.NewPoller(resp, client.internal.Pipeline(), &runtime.NewPollerOptions[SecretSyncsClientCreateOrUpdateResponse]{ + Tracer: client.internal.Tracer(), + }) + return poller, err + } else { + return runtime.NewPollerFromResumeToken(options.ResumeToken, client.internal.Pipeline(), &runtime.NewPollerFromResumeTokenOptions[SecretSyncsClientCreateOrUpdateResponse]{ + Tracer: client.internal.Tracer(), + }) + } +} + +// CreateOrUpdate - Creates new or updates a SecretSync instance. +// If the operation fails it returns an *azcore.ResponseError type. +// +// Generated from API version 2024-08-21-preview +func (client *SecretSyncsClient) createOrUpdate(ctx context.Context, resourceGroupName string, secretSyncName string, resource SecretSync, options *SecretSyncsClientBeginCreateOrUpdateOptions) (*http.Response, error) { + var err error + const operationName = "SecretSyncsClient.BeginCreateOrUpdate" + ctx = context.WithValue(ctx, runtime.CtxAPINameKey{}, operationName) + ctx, endSpan := runtime.StartSpan(ctx, operationName, client.internal.Tracer(), nil) + defer func() { endSpan(err) }() + req, err := client.createOrUpdateCreateRequest(ctx, resourceGroupName, secretSyncName, resource, options) + if err != nil { + return nil, err + } + httpResp, err := client.internal.Pipeline().Do(req) + if err != nil { + return nil, err + } + if !runtime.HasStatusCode(httpResp, http.StatusOK, http.StatusCreated) { + err = runtime.NewResponseError(httpResp) + return nil, err + } + return httpResp, nil +} + +// createOrUpdateCreateRequest creates the CreateOrUpdate request. +func (client *SecretSyncsClient) createOrUpdateCreateRequest(ctx context.Context, resourceGroupName string, secretSyncName string, resource SecretSync, _ *SecretSyncsClientBeginCreateOrUpdateOptions) (*policy.Request, error) { + urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.SecretSyncController/secretSyncs/{secretSyncName}" + if client.subscriptionID == "" { + return nil, errors.New("parameter client.subscriptionID cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) + if resourceGroupName == "" { + return nil, errors.New("parameter resourceGroupName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName)) + if secretSyncName == "" { + return nil, errors.New("parameter secretSyncName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{secretSyncName}", url.PathEscape(secretSyncName)) + req, err := runtime.NewRequest(ctx, http.MethodPut, runtime.JoinPaths(client.internal.Endpoint(), urlPath)) + if err != nil { + return nil, err + } + reqQP := req.Raw().URL.Query() + reqQP.Set("api-version", "2024-08-21-preview") + req.Raw().URL.RawQuery = reqQP.Encode() + req.Raw().Header["Accept"] = []string{"application/json"} + req.Raw().Header["Content-Type"] = []string{"application/json"} + if err := runtime.MarshalAsJSON(req, resource); err != nil { + return nil, err + } + return req, nil +} + +// BeginDelete - Deletes a SecretSync instance. +// If the operation fails it returns an *azcore.ResponseError type. +// +// Generated from API version 2024-08-21-preview +// - resourceGroupName - The name of the resource group. The name is case insensitive. +// - secretSyncName - The name of the SecretSync +// - options - SecretSyncsClientBeginDeleteOptions contains the optional parameters for the SecretSyncsClient.BeginDelete method. +func (client *SecretSyncsClient) BeginDelete(ctx context.Context, resourceGroupName string, secretSyncName string, options *SecretSyncsClientBeginDeleteOptions) (*runtime.Poller[SecretSyncsClientDeleteResponse], error) { + if options == nil || options.ResumeToken == "" { + resp, err := client.deleteOperation(ctx, resourceGroupName, secretSyncName, options) + if err != nil { + return nil, err + } + poller, err := runtime.NewPoller(resp, client.internal.Pipeline(), &runtime.NewPollerOptions[SecretSyncsClientDeleteResponse]{ + Tracer: client.internal.Tracer(), + }) + return poller, err + } else { + return runtime.NewPollerFromResumeToken(options.ResumeToken, client.internal.Pipeline(), &runtime.NewPollerFromResumeTokenOptions[SecretSyncsClientDeleteResponse]{ + Tracer: client.internal.Tracer(), + }) + } +} + +// Delete - Deletes a SecretSync instance. +// If the operation fails it returns an *azcore.ResponseError type. +// +// Generated from API version 2024-08-21-preview +func (client *SecretSyncsClient) deleteOperation(ctx context.Context, resourceGroupName string, secretSyncName string, options *SecretSyncsClientBeginDeleteOptions) (*http.Response, error) { + var err error + const operationName = "SecretSyncsClient.BeginDelete" + ctx = context.WithValue(ctx, runtime.CtxAPINameKey{}, operationName) + ctx, endSpan := runtime.StartSpan(ctx, operationName, client.internal.Tracer(), nil) + defer func() { endSpan(err) }() + req, err := client.deleteCreateRequest(ctx, resourceGroupName, secretSyncName, options) + if err != nil { + return nil, err + } + httpResp, err := client.internal.Pipeline().Do(req) + if err != nil { + return nil, err + } + if !runtime.HasStatusCode(httpResp, http.StatusAccepted, http.StatusNoContent) { + err = runtime.NewResponseError(httpResp) + return nil, err + } + return httpResp, nil +} + +// deleteCreateRequest creates the Delete request. +func (client *SecretSyncsClient) deleteCreateRequest(ctx context.Context, resourceGroupName string, secretSyncName string, _ *SecretSyncsClientBeginDeleteOptions) (*policy.Request, error) { + urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.SecretSyncController/secretSyncs/{secretSyncName}" + if client.subscriptionID == "" { + return nil, errors.New("parameter client.subscriptionID cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) + if resourceGroupName == "" { + return nil, errors.New("parameter resourceGroupName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName)) + if secretSyncName == "" { + return nil, errors.New("parameter secretSyncName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{secretSyncName}", url.PathEscape(secretSyncName)) + req, err := runtime.NewRequest(ctx, http.MethodDelete, runtime.JoinPaths(client.internal.Endpoint(), urlPath)) + if err != nil { + return nil, err + } + reqQP := req.Raw().URL.Query() + reqQP.Set("api-version", "2024-08-21-preview") + req.Raw().URL.RawQuery = reqQP.Encode() + req.Raw().Header["Accept"] = []string{"application/json"} + return req, nil +} + +// Get - Gets the properties of a SecretSync instance. +// If the operation fails it returns an *azcore.ResponseError type. +// +// Generated from API version 2024-08-21-preview +// - resourceGroupName - The name of the resource group. The name is case insensitive. +// - secretSyncName - The name of the SecretSync +// - options - SecretSyncsClientGetOptions contains the optional parameters for the SecretSyncsClient.Get method. +func (client *SecretSyncsClient) Get(ctx context.Context, resourceGroupName string, secretSyncName string, options *SecretSyncsClientGetOptions) (SecretSyncsClientGetResponse, error) { + var err error + const operationName = "SecretSyncsClient.Get" + ctx = context.WithValue(ctx, runtime.CtxAPINameKey{}, operationName) + ctx, endSpan := runtime.StartSpan(ctx, operationName, client.internal.Tracer(), nil) + defer func() { endSpan(err) }() + req, err := client.getCreateRequest(ctx, resourceGroupName, secretSyncName, options) + if err != nil { + return SecretSyncsClientGetResponse{}, err + } + httpResp, err := client.internal.Pipeline().Do(req) + if err != nil { + return SecretSyncsClientGetResponse{}, err + } + if !runtime.HasStatusCode(httpResp, http.StatusOK) { + err = runtime.NewResponseError(httpResp) + return SecretSyncsClientGetResponse{}, err + } + resp, err := client.getHandleResponse(httpResp) + return resp, err +} + +// getCreateRequest creates the Get request. +func (client *SecretSyncsClient) getCreateRequest(ctx context.Context, resourceGroupName string, secretSyncName string, _ *SecretSyncsClientGetOptions) (*policy.Request, error) { + urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.SecretSyncController/secretSyncs/{secretSyncName}" + if client.subscriptionID == "" { + return nil, errors.New("parameter client.subscriptionID cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) + if resourceGroupName == "" { + return nil, errors.New("parameter resourceGroupName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName)) + if secretSyncName == "" { + return nil, errors.New("parameter secretSyncName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{secretSyncName}", url.PathEscape(secretSyncName)) + req, err := runtime.NewRequest(ctx, http.MethodGet, runtime.JoinPaths(client.internal.Endpoint(), urlPath)) + if err != nil { + return nil, err + } + reqQP := req.Raw().URL.Query() + reqQP.Set("api-version", "2024-08-21-preview") + req.Raw().URL.RawQuery = reqQP.Encode() + req.Raw().Header["Accept"] = []string{"application/json"} + return req, nil +} + +// getHandleResponse handles the Get response. +func (client *SecretSyncsClient) getHandleResponse(resp *http.Response) (SecretSyncsClientGetResponse, error) { + result := SecretSyncsClientGetResponse{} + if err := runtime.UnmarshalAsJSON(resp, &result.SecretSync); err != nil { + return SecretSyncsClientGetResponse{}, err + } + return result, nil +} + +// NewListByResourceGroupPager - Lists the SecretSync instances within a resource group. +// +// Generated from API version 2024-08-21-preview +// - resourceGroupName - The name of the resource group. The name is case insensitive. +// - options - SecretSyncsClientListByResourceGroupOptions contains the optional parameters for the SecretSyncsClient.NewListByResourceGroupPager +// method. +func (client *SecretSyncsClient) NewListByResourceGroupPager(resourceGroupName string, options *SecretSyncsClientListByResourceGroupOptions) *runtime.Pager[SecretSyncsClientListByResourceGroupResponse] { + return runtime.NewPager(runtime.PagingHandler[SecretSyncsClientListByResourceGroupResponse]{ + More: func(page SecretSyncsClientListByResourceGroupResponse) bool { + return page.NextLink != nil && len(*page.NextLink) > 0 + }, + Fetcher: func(ctx context.Context, page *SecretSyncsClientListByResourceGroupResponse) (SecretSyncsClientListByResourceGroupResponse, error) { + ctx = context.WithValue(ctx, runtime.CtxAPINameKey{}, "SecretSyncsClient.NewListByResourceGroupPager") + nextLink := "" + if page != nil { + nextLink = *page.NextLink + } + resp, err := runtime.FetcherForNextLink(ctx, client.internal.Pipeline(), nextLink, func(ctx context.Context) (*policy.Request, error) { + return client.listByResourceGroupCreateRequest(ctx, resourceGroupName, options) + }, nil) + if err != nil { + return SecretSyncsClientListByResourceGroupResponse{}, err + } + return client.listByResourceGroupHandleResponse(resp) + }, + Tracer: client.internal.Tracer(), + }) +} + +// listByResourceGroupCreateRequest creates the ListByResourceGroup request. +func (client *SecretSyncsClient) listByResourceGroupCreateRequest(ctx context.Context, resourceGroupName string, _ *SecretSyncsClientListByResourceGroupOptions) (*policy.Request, error) { + urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.SecretSyncController/secretSyncs" + if client.subscriptionID == "" { + return nil, errors.New("parameter client.subscriptionID cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) + if resourceGroupName == "" { + return nil, errors.New("parameter resourceGroupName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName)) + req, err := runtime.NewRequest(ctx, http.MethodGet, runtime.JoinPaths(client.internal.Endpoint(), urlPath)) + if err != nil { + return nil, err + } + reqQP := req.Raw().URL.Query() + reqQP.Set("api-version", "2024-08-21-preview") + req.Raw().URL.RawQuery = reqQP.Encode() + req.Raw().Header["Accept"] = []string{"application/json"} + return req, nil +} + +// listByResourceGroupHandleResponse handles the ListByResourceGroup response. +func (client *SecretSyncsClient) listByResourceGroupHandleResponse(resp *http.Response) (SecretSyncsClientListByResourceGroupResponse, error) { + result := SecretSyncsClientListByResourceGroupResponse{} + if err := runtime.UnmarshalAsJSON(resp, &result.SecretSyncListResult); err != nil { + return SecretSyncsClientListByResourceGroupResponse{}, err + } + return result, nil +} + +// NewListBySubscriptionPager - Lists the SecretSync instances within an Azure subscription. +// +// Generated from API version 2024-08-21-preview +// - options - SecretSyncsClientListBySubscriptionOptions contains the optional parameters for the SecretSyncsClient.NewListBySubscriptionPager +// method. +func (client *SecretSyncsClient) NewListBySubscriptionPager(options *SecretSyncsClientListBySubscriptionOptions) *runtime.Pager[SecretSyncsClientListBySubscriptionResponse] { + return runtime.NewPager(runtime.PagingHandler[SecretSyncsClientListBySubscriptionResponse]{ + More: func(page SecretSyncsClientListBySubscriptionResponse) bool { + return page.NextLink != nil && len(*page.NextLink) > 0 + }, + Fetcher: func(ctx context.Context, page *SecretSyncsClientListBySubscriptionResponse) (SecretSyncsClientListBySubscriptionResponse, error) { + ctx = context.WithValue(ctx, runtime.CtxAPINameKey{}, "SecretSyncsClient.NewListBySubscriptionPager") + nextLink := "" + if page != nil { + nextLink = *page.NextLink + } + resp, err := runtime.FetcherForNextLink(ctx, client.internal.Pipeline(), nextLink, func(ctx context.Context) (*policy.Request, error) { + return client.listBySubscriptionCreateRequest(ctx, options) + }, nil) + if err != nil { + return SecretSyncsClientListBySubscriptionResponse{}, err + } + return client.listBySubscriptionHandleResponse(resp) + }, + Tracer: client.internal.Tracer(), + }) +} + +// listBySubscriptionCreateRequest creates the ListBySubscription request. +func (client *SecretSyncsClient) listBySubscriptionCreateRequest(ctx context.Context, _ *SecretSyncsClientListBySubscriptionOptions) (*policy.Request, error) { + urlPath := "/subscriptions/{subscriptionId}/providers/Microsoft.SecretSyncController/secretSyncs" + if client.subscriptionID == "" { + return nil, errors.New("parameter client.subscriptionID cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) + req, err := runtime.NewRequest(ctx, http.MethodGet, runtime.JoinPaths(client.internal.Endpoint(), urlPath)) + if err != nil { + return nil, err + } + reqQP := req.Raw().URL.Query() + reqQP.Set("api-version", "2024-08-21-preview") + req.Raw().URL.RawQuery = reqQP.Encode() + req.Raw().Header["Accept"] = []string{"application/json"} + return req, nil +} + +// listBySubscriptionHandleResponse handles the ListBySubscription response. +func (client *SecretSyncsClient) listBySubscriptionHandleResponse(resp *http.Response) (SecretSyncsClientListBySubscriptionResponse, error) { + result := SecretSyncsClientListBySubscriptionResponse{} + if err := runtime.UnmarshalAsJSON(resp, &result.SecretSyncListResult); err != nil { + return SecretSyncsClientListBySubscriptionResponse{}, err + } + return result, nil +} + +// BeginUpdate - Updates a SecretSync instance. +// If the operation fails it returns an *azcore.ResponseError type. +// +// Generated from API version 2024-08-21-preview +// - resourceGroupName - The name of the resource group. The name is case insensitive. +// - secretSyncName - The name of the SecretSync +// - properties - The resource properties to be updated. +// - options - SecretSyncsClientBeginUpdateOptions contains the optional parameters for the SecretSyncsClient.BeginUpdate method. +func (client *SecretSyncsClient) BeginUpdate(ctx context.Context, resourceGroupName string, secretSyncName string, properties SecretSyncUpdate, options *SecretSyncsClientBeginUpdateOptions) (*runtime.Poller[SecretSyncsClientUpdateResponse], error) { + if options == nil || options.ResumeToken == "" { + resp, err := client.update(ctx, resourceGroupName, secretSyncName, properties, options) + if err != nil { + return nil, err + } + poller, err := runtime.NewPoller(resp, client.internal.Pipeline(), &runtime.NewPollerOptions[SecretSyncsClientUpdateResponse]{ + Tracer: client.internal.Tracer(), + }) + return poller, err + } else { + return runtime.NewPollerFromResumeToken(options.ResumeToken, client.internal.Pipeline(), &runtime.NewPollerFromResumeTokenOptions[SecretSyncsClientUpdateResponse]{ + Tracer: client.internal.Tracer(), + }) + } +} + +// Update - Updates a SecretSync instance. +// If the operation fails it returns an *azcore.ResponseError type. +// +// Generated from API version 2024-08-21-preview +func (client *SecretSyncsClient) update(ctx context.Context, resourceGroupName string, secretSyncName string, properties SecretSyncUpdate, options *SecretSyncsClientBeginUpdateOptions) (*http.Response, error) { + var err error + const operationName = "SecretSyncsClient.BeginUpdate" + ctx = context.WithValue(ctx, runtime.CtxAPINameKey{}, operationName) + ctx, endSpan := runtime.StartSpan(ctx, operationName, client.internal.Tracer(), nil) + defer func() { endSpan(err) }() + req, err := client.updateCreateRequest(ctx, resourceGroupName, secretSyncName, properties, options) + if err != nil { + return nil, err + } + httpResp, err := client.internal.Pipeline().Do(req) + if err != nil { + return nil, err + } + if !runtime.HasStatusCode(httpResp, http.StatusOK, http.StatusAccepted) { + err = runtime.NewResponseError(httpResp) + return nil, err + } + return httpResp, nil +} + +// updateCreateRequest creates the Update request. +func (client *SecretSyncsClient) updateCreateRequest(ctx context.Context, resourceGroupName string, secretSyncName string, properties SecretSyncUpdate, _ *SecretSyncsClientBeginUpdateOptions) (*policy.Request, error) { + urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.SecretSyncController/secretSyncs/{secretSyncName}" + if client.subscriptionID == "" { + return nil, errors.New("parameter client.subscriptionID cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) + if resourceGroupName == "" { + return nil, errors.New("parameter resourceGroupName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName)) + if secretSyncName == "" { + return nil, errors.New("parameter secretSyncName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{secretSyncName}", url.PathEscape(secretSyncName)) + req, err := runtime.NewRequest(ctx, http.MethodPatch, runtime.JoinPaths(client.internal.Endpoint(), urlPath)) + if err != nil { + return nil, err + } + reqQP := req.Raw().URL.Query() + reqQP.Set("api-version", "2024-08-21-preview") + req.Raw().URL.RawQuery = reqQP.Encode() + req.Raw().Header["Accept"] = []string{"application/json"} + req.Raw().Header["Content-Type"] = []string{"application/json"} + if err := runtime.MarshalAsJSON(req, properties); err != nil { + return nil, err + } + return req, nil +} diff --git a/sdk/resourcemanager/secretsstoreextension/armsecretsstoreextension/secretsyncs_client_example_test.go b/sdk/resourcemanager/secretsstoreextension/armsecretsstoreextension/secretsyncs_client_example_test.go new file mode 100644 index 000000000000..5567e742ae59 --- /dev/null +++ b/sdk/resourcemanager/secretsstoreextension/armsecretsstoreextension/secretsyncs_client_example_test.go @@ -0,0 +1,397 @@ +// 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) Go Code Generator. DO NOT EDIT. + +package armsecretsstoreextension_test + +import ( + "context" + "github.com/Azure/azure-sdk-for-go/sdk/azcore/to" + "github.com/Azure/azure-sdk-for-go/sdk/azidentity" + "github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/secretsstoreextension/armsecretsstoreextension" + "log" +) + +// Generated from example definition: 2024-08-21-preview/SecretSyncs_CreateOrUpdate_MaximumSet_Gen.json +func ExampleSecretSyncsClient_BeginCreateOrUpdate() { + cred, err := azidentity.NewDefaultAzureCredential(nil) + if err != nil { + log.Fatalf("failed to obtain a credential: %v", err) + } + ctx := context.Background() + clientFactory, err := armsecretsstoreextension.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil) + if err != nil { + log.Fatalf("failed to create client: %v", err) + } + poller, err := clientFactory.NewSecretSyncsClient().BeginCreateOrUpdate(ctx, "rg-ssc-example", "secretsync-ssc-example", armsecretsstoreextension.SecretSync{ + Properties: &armsecretsstoreextension.SecretSyncProperties{ + SecretProviderClassName: to.Ptr("akvspc-ssc-example"), + ServiceAccountName: to.Ptr("example-k8s-sa-name"), + KubernetesSecretType: to.Ptr(armsecretsstoreextension.KubernetesSecretTypeOpaque), + ObjectSecretMapping: []*armsecretsstoreextension.KubernetesSecretObjectMapping{ + { + SourcePath: to.Ptr("kv-secret-name/0"), + TargetKey: to.Ptr("kv-secret-name/0"), + }, + }, + }, + ExtendedLocation: &armsecretsstoreextension.ExtendedLocation{ + Name: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg-ssc-example/providers/Microsoft.ExtendedLocation/customLocations/example-custom-location"), + Type: to.Ptr(armsecretsstoreextension.ExtendedLocationTypeCustomLocation), + }, + Tags: map[string]*string{ + "example-tag": to.Ptr("example-tag-value"), + }, + Location: to.Ptr("eastus"), + }, nil) + if err != nil { + log.Fatalf("failed to finish the request: %v", err) + } + res, err := poller.PollUntilDone(ctx, nil) + if err != nil { + log.Fatalf("failed to pull the result: %v", err) + } + // You could use response here. We use blank identifier for just demo purposes. + _ = res + // If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes. + // res = armsecretsstoreextension.SecretSyncsClientCreateOrUpdateResponse{ + // SecretSync: &armsecretsstoreextension.SecretSync{ + // Properties: &armsecretsstoreextension.SecretSyncProperties{ + // ProvisioningState: to.Ptr(armsecretsstoreextension.ProvisioningStateSucceeded), + // SecretProviderClassName: to.Ptr("akvspc-ssc-example"), + // ServiceAccountName: to.Ptr("example-k8s-sa-name"), + // KubernetesSecretType: to.Ptr(armsecretsstoreextension.KubernetesSecretTypeOpaque), + // ObjectSecretMapping: []*armsecretsstoreextension.KubernetesSecretObjectMapping{ + // { + // SourcePath: to.Ptr("kv-secret-name/0"), + // TargetKey: to.Ptr("kv-secret-name/0"), + // }, + // }, + // Status: &armsecretsstoreextension.SecretSyncStatus{ + // Conditions: []*armsecretsstoreextension.SecretSyncCondition{ + // { + // LastTransitionTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-08-02T12:50:34Z"); return t}()), + // Message: to.Ptr("Secret created successfully."), + // ObservedGeneration: to.Ptr[int64](25), + // Reason: to.Ptr("CreateSucceeded"), + // Status: to.Ptr(armsecretsstoreextension.StatusConditionTypeTrue), + // Type: to.Ptr("Create"), + // }, + // }, + // LastSuccessfulSyncTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-07-28T18:12:04Z"); return t}()), + // }, + // }, + // ExtendedLocation: &armsecretsstoreextension.ExtendedLocation{ + // Name: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg-ssc-example/providers/Microsoft.ExtendedLocation/customLocations/example-custom-location"), + // Type: to.Ptr(armsecretsstoreextension.ExtendedLocationTypeCustomLocation), + // }, + // Tags: map[string]*string{ + // "example-tag": to.Ptr("example-tag-value"), + // }, + // Location: to.Ptr("eastus"), + // ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg-ssc-example/providers/Microsoft.SecretSyncController/secretsync/secretsync-ssc-example"), + // Name: to.Ptr("secretsync-ssc-example"), + // }, + // } +} + +// Generated from example definition: 2024-08-21-preview/SecretSyncs_Delete_MaximumSet_Gen.json +func ExampleSecretSyncsClient_BeginDelete() { + cred, err := azidentity.NewDefaultAzureCredential(nil) + if err != nil { + log.Fatalf("failed to obtain a credential: %v", err) + } + ctx := context.Background() + clientFactory, err := armsecretsstoreextension.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil) + if err != nil { + log.Fatalf("failed to create client: %v", err) + } + poller, err := clientFactory.NewSecretSyncsClient().BeginDelete(ctx, "rg-ssc-example", "secretsync-ssc-example", nil) + if err != nil { + log.Fatalf("failed to finish the request: %v", err) + } + _, err = poller.PollUntilDone(ctx, nil) + if err != nil { + log.Fatalf("failed to pull the result: %v", err) + } +} + +// Generated from example definition: 2024-08-21-preview/SecretSyncs_Get_MaximumSet_Gen.json +func ExampleSecretSyncsClient_Get() { + cred, err := azidentity.NewDefaultAzureCredential(nil) + if err != nil { + log.Fatalf("failed to obtain a credential: %v", err) + } + ctx := context.Background() + clientFactory, err := armsecretsstoreextension.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil) + if err != nil { + log.Fatalf("failed to create client: %v", err) + } + res, err := clientFactory.NewSecretSyncsClient().Get(ctx, "rg-ssc-example", "secretsync-ssc-example", nil) + if err != nil { + log.Fatalf("failed to finish the request: %v", err) + } + // You could use response here. We use blank identifier for just demo purposes. + _ = res + // If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes. + // res = armsecretsstoreextension.SecretSyncsClientGetResponse{ + // SecretSync: &armsecretsstoreextension.SecretSync{ + // Properties: &armsecretsstoreextension.SecretSyncProperties{ + // ProvisioningState: to.Ptr(armsecretsstoreextension.ProvisioningStateSucceeded), + // SecretProviderClassName: to.Ptr("akvspc-ssc-example"), + // ServiceAccountName: to.Ptr("example-k8s-sa-name"), + // KubernetesSecretType: to.Ptr(armsecretsstoreextension.KubernetesSecretTypeOpaque), + // ObjectSecretMapping: []*armsecretsstoreextension.KubernetesSecretObjectMapping{ + // { + // SourcePath: to.Ptr("kv-secret-name/0"), + // TargetKey: to.Ptr("kv-secret-name/0"), + // }, + // }, + // ForceSynchronization: to.Ptr("arbitrarystring"), + // Status: &armsecretsstoreextension.SecretSyncStatus{ + // Conditions: []*armsecretsstoreextension.SecretSyncCondition{ + // { + // LastTransitionTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-08-02T12:50:34Z"); return t}()), + // Message: to.Ptr("Secret created successfully."), + // ObservedGeneration: to.Ptr[int64](25), + // Reason: to.Ptr("CreateSucceeded"), + // Status: to.Ptr(armsecretsstoreextension.StatusConditionTypeTrue), + // Type: to.Ptr("Create"), + // }, + // }, + // LastSuccessfulSyncTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-07-28T18:12:04Z"); return t}()), + // }, + // }, + // ExtendedLocation: &armsecretsstoreextension.ExtendedLocation{ + // Name: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg-ssc-example/providers/Microsoft.ExtendedLocation/customLocations/example-custom-location"), + // Type: to.Ptr(armsecretsstoreextension.ExtendedLocationTypeCustomLocation), + // }, + // Tags: map[string]*string{ + // "example-tag": to.Ptr("example-tag-value"), + // }, + // Location: to.Ptr("eastus"), + // ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg-ssc-example/providers/Microsoft.SecretSyncController/secretsync/secretsync-ssc-example"), + // Name: to.Ptr("secretsync-ssc-example"), + // }, + // } +} + +// Generated from example definition: 2024-08-21-preview/SecretSyncs_ListByResourceGroup_MaximumSet_Gen.json +func ExampleSecretSyncsClient_NewListByResourceGroupPager() { + cred, err := azidentity.NewDefaultAzureCredential(nil) + if err != nil { + log.Fatalf("failed to obtain a credential: %v", err) + } + ctx := context.Background() + clientFactory, err := armsecretsstoreextension.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil) + if err != nil { + log.Fatalf("failed to create client: %v", err) + } + pager := clientFactory.NewSecretSyncsClient().NewListByResourceGroupPager("rg-ssc-example", nil) + for pager.More() { + page, err := pager.NextPage(ctx) + if err != nil { + log.Fatalf("failed to advance page: %v", err) + } + for _, v := range page.Value { + // You could use page here. We use blank identifier for just demo purposes. + _ = v + } + // If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes. + // page = armsecretsstoreextension.SecretSyncsClientListByResourceGroupResponse{ + // SecretSyncListResult: armsecretsstoreextension.SecretSyncListResult{ + // Value: []*armsecretsstoreextension.SecretSync{ + // { + // Properties: &armsecretsstoreextension.SecretSyncProperties{ + // ProvisioningState: to.Ptr(armsecretsstoreextension.ProvisioningStateSucceeded), + // SecretProviderClassName: to.Ptr("akvspc-ssc-example"), + // ServiceAccountName: to.Ptr("example-k8s-sa-name"), + // KubernetesSecretType: to.Ptr(armsecretsstoreextension.KubernetesSecretTypeOpaque), + // ObjectSecretMapping: []*armsecretsstoreextension.KubernetesSecretObjectMapping{ + // { + // SourcePath: to.Ptr("kv-secret-name/0"), + // TargetKey: to.Ptr("kv-secret-name/0"), + // }, + // }, + // ForceSynchronization: to.Ptr("arbitrarystring"), + // Status: &armsecretsstoreextension.SecretSyncStatus{ + // Conditions: []*armsecretsstoreextension.SecretSyncCondition{ + // { + // LastTransitionTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-08-02T12:50:34Z"); return t}()), + // Message: to.Ptr("Secret created successfully."), + // ObservedGeneration: to.Ptr[int64](25), + // Reason: to.Ptr("CreateSucceeded"), + // Status: to.Ptr(armsecretsstoreextension.StatusConditionTypeTrue), + // Type: to.Ptr("Create"), + // }, + // }, + // LastSuccessfulSyncTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-07-28T18:12:04Z"); return t}()), + // }, + // }, + // ExtendedLocation: &armsecretsstoreextension.ExtendedLocation{ + // Name: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg-ssc-example/providers/Microsoft.ExtendedLocation/customLocations/example-custom-location"), + // Type: to.Ptr(armsecretsstoreextension.ExtendedLocationTypeCustomLocation), + // }, + // Tags: map[string]*string{ + // "example-tag": to.Ptr("example-tag-value"), + // }, + // Location: to.Ptr("eastus"), + // ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg-ssc-example/providers/Microsoft.SecretSyncController/secretsync/secretsync-ssc-example"), + // Name: to.Ptr("secretsync-ssc-example"), + // }, + // }, + // NextLink: to.Ptr("https://microsoft.com/aolkmb"), + // }, + // } + } +} + +// Generated from example definition: 2024-08-21-preview/SecretSyncs_ListBySubscription_MaximumSet_Gen.json +func ExampleSecretSyncsClient_NewListBySubscriptionPager() { + cred, err := azidentity.NewDefaultAzureCredential(nil) + if err != nil { + log.Fatalf("failed to obtain a credential: %v", err) + } + ctx := context.Background() + clientFactory, err := armsecretsstoreextension.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil) + if err != nil { + log.Fatalf("failed to create client: %v", err) + } + pager := clientFactory.NewSecretSyncsClient().NewListBySubscriptionPager(nil) + for pager.More() { + page, err := pager.NextPage(ctx) + if err != nil { + log.Fatalf("failed to advance page: %v", err) + } + for _, v := range page.Value { + // You could use page here. We use blank identifier for just demo purposes. + _ = v + } + // If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes. + // page = armsecretsstoreextension.SecretSyncsClientListBySubscriptionResponse{ + // SecretSyncListResult: armsecretsstoreextension.SecretSyncListResult{ + // Value: []*armsecretsstoreextension.SecretSync{ + // { + // Properties: &armsecretsstoreextension.SecretSyncProperties{ + // ProvisioningState: to.Ptr(armsecretsstoreextension.ProvisioningStateSucceeded), + // SecretProviderClassName: to.Ptr("akvspc-ssc-example"), + // ServiceAccountName: to.Ptr("example-k8s-sa-name"), + // KubernetesSecretType: to.Ptr(armsecretsstoreextension.KubernetesSecretTypeOpaque), + // ObjectSecretMapping: []*armsecretsstoreextension.KubernetesSecretObjectMapping{ + // { + // SourcePath: to.Ptr("kv-secret-name/0"), + // TargetKey: to.Ptr("kv-secret-name/0"), + // }, + // }, + // ForceSynchronization: to.Ptr("arbitrarystring"), + // Status: &armsecretsstoreextension.SecretSyncStatus{ + // Conditions: []*armsecretsstoreextension.SecretSyncCondition{ + // { + // LastTransitionTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-08-02T12:50:34Z"); return t}()), + // Message: to.Ptr("Secret created successfully."), + // ObservedGeneration: to.Ptr[int64](25), + // Reason: to.Ptr("CreateSucceeded"), + // Status: to.Ptr(armsecretsstoreextension.StatusConditionTypeTrue), + // Type: to.Ptr("Create"), + // }, + // }, + // LastSuccessfulSyncTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-07-28T18:12:04Z"); return t}()), + // }, + // }, + // ExtendedLocation: &armsecretsstoreextension.ExtendedLocation{ + // Name: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg-ssc-example/providers/Microsoft.ExtendedLocation/customLocations/example-custom-location"), + // Type: to.Ptr(armsecretsstoreextension.ExtendedLocationTypeCustomLocation), + // }, + // Tags: map[string]*string{ + // "example-tag": to.Ptr("example-tag-value"), + // }, + // Location: to.Ptr("eastus"), + // ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg-ssc-example/providers/Microsoft.SecretSyncController/secretsync/secretsync-ssc-example"), + // Name: to.Ptr("secretsync-ssc-example"), + // }, + // }, + // NextLink: to.Ptr("https://microsoft.com/aolkmb"), + // }, + // } + } +} + +// Generated from example definition: 2024-08-21-preview/SecretSyncs_Update_MaximumSet_Gen.json +func ExampleSecretSyncsClient_BeginUpdate() { + cred, err := azidentity.NewDefaultAzureCredential(nil) + if err != nil { + log.Fatalf("failed to obtain a credential: %v", err) + } + ctx := context.Background() + clientFactory, err := armsecretsstoreextension.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil) + if err != nil { + log.Fatalf("failed to create client: %v", err) + } + poller, err := clientFactory.NewSecretSyncsClient().BeginUpdate(ctx, "rg-ssc-example", "secretsync-ssc-example", armsecretsstoreextension.SecretSyncUpdate{ + Tags: map[string]*string{ + "example-tag": to.Ptr("example-tag-value"), + }, + Properties: &armsecretsstoreextension.SecretSyncUpdateProperties{ + SecretProviderClassName: to.Ptr("jttlpenhtpxfrrlxdsmqqvmvtmgqrficvqngkggjwciilrexenlstxncyvkqcydxrivkioujssncoaiysdklfouukczzdbxniipbyiqsarqaespuqrbbydwtdaulllostoomntkadklihemfpeffvuyvyilequiqewzspaootvkibrynbqrsbiptjdhywynvydaadprdc"), + ServiceAccountName: to.Ptr("fcldqfdfpktndlntuoxicsftelhefevovmlycflfwzckvamiqjnjugandqaqqeccsbzztfmmeunvhsafgerbcsdbnmsyqivygornebbkusuvphwghgouxvcbvmbydqjzoxextnyowsnyymadniwdrrxtogeveldpejixmsrzzfqkquaxdpzwvecevqwasxgxxchrfa"), + KubernetesSecretType: to.Ptr(armsecretsstoreextension.KubernetesSecretTypeOpaque), + ObjectSecretMapping: []*armsecretsstoreextension.KubernetesSecretObjectMapping{ + { + SourcePath: to.Ptr("ssrzmbvdiomkvzrdsyilwlfzicfydnbjwjsnohrppkukjddrunfslkrnexunuckmghixdssposvndpiqchpqrkjuqbapoisvqdvgstvdonsmlpsmticfvuhqlofpaxfdg"), + TargetKey: to.Ptr("lojegeqiqfjxyblfxhxloccqzwgpgcelrwqwsbsltcjvjvceejgdrmxhenokxrylhynkltvqntjcvujjrppzvcxyivxeksgmzhifrcklizbpntdepzdl"), + }, + }, + ForceSynchronization: to.Ptr("arbitrarystring"), + }, + }, nil) + if err != nil { + log.Fatalf("failed to finish the request: %v", err) + } + res, err := poller.PollUntilDone(ctx, nil) + if err != nil { + log.Fatalf("failed to pull the result: %v", err) + } + // You could use response here. We use blank identifier for just demo purposes. + _ = res + // If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes. + // res = armsecretsstoreextension.SecretSyncsClientUpdateResponse{ + // SecretSync: &armsecretsstoreextension.SecretSync{ + // Properties: &armsecretsstoreextension.SecretSyncProperties{ + // ProvisioningState: to.Ptr(armsecretsstoreextension.ProvisioningStateSucceeded), + // SecretProviderClassName: to.Ptr("akvspc-ssc-example"), + // ServiceAccountName: to.Ptr("example-k8s-sa-name"), + // KubernetesSecretType: to.Ptr(armsecretsstoreextension.KubernetesSecretTypeOpaque), + // ObjectSecretMapping: []*armsecretsstoreextension.KubernetesSecretObjectMapping{ + // { + // SourcePath: to.Ptr("kv-secret-name/0"), + // TargetKey: to.Ptr("kv-secret-name/0"), + // }, + // }, + // ForceSynchronization: to.Ptr("arbitrarystring"), + // Status: &armsecretsstoreextension.SecretSyncStatus{ + // Conditions: []*armsecretsstoreextension.SecretSyncCondition{ + // { + // LastTransitionTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-08-02T12:50:34Z"); return t}()), + // Message: to.Ptr("Secret created successfully."), + // ObservedGeneration: to.Ptr[int64](25), + // Reason: to.Ptr("CreateSucceeded"), + // Status: to.Ptr(armsecretsstoreextension.StatusConditionTypeTrue), + // Type: to.Ptr("Create"), + // }, + // }, + // LastSuccessfulSyncTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-07-28T18:12:04Z"); return t}()), + // }, + // }, + // ExtendedLocation: &armsecretsstoreextension.ExtendedLocation{ + // Name: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg-ssc-example/providers/Microsoft.ExtendedLocation/customLocations/example-custom-location"), + // Type: to.Ptr(armsecretsstoreextension.ExtendedLocationTypeCustomLocation), + // }, + // Tags: map[string]*string{ + // "example-tag": to.Ptr("example-tag-value"), + // }, + // Location: to.Ptr("eastus"), + // ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg-ssc-example/providers/Microsoft.SecretSyncController/secretsync/secretsync-ssc-example"), + // Name: to.Ptr("secretsync-ssc-example"), + // }, + // } +} diff --git a/sdk/resourcemanager/secretsstoreextension/armsecretsstoreextension/time_rfc3339.go b/sdk/resourcemanager/secretsstoreextension/armsecretsstoreextension/time_rfc3339.go new file mode 100644 index 000000000000..17297915e66d --- /dev/null +++ b/sdk/resourcemanager/secretsstoreextension/armsecretsstoreextension/time_rfc3339.go @@ -0,0 +1,109 @@ +// 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) Go Code Generator. DO NOT EDIT. + +package armsecretsstoreextension + +import ( + "encoding/json" + "fmt" + "github.com/Azure/azure-sdk-for-go/sdk/azcore" + "reflect" + "regexp" + "strings" + "time" +) + +// Azure reports time in UTC but it doesn't include the 'Z' time zone suffix in some cases. +var tzOffsetRegex = regexp.MustCompile(`(?:Z|z|\+|-)(?:\d+:\d+)*"*$`) + +const ( + utcDateTime = "2006-01-02T15:04:05.999999999" + utcDateTimeJSON = `"` + utcDateTime + `"` + utcDateTimeNoT = "2006-01-02 15:04:05.999999999" + utcDateTimeJSONNoT = `"` + utcDateTimeNoT + `"` + dateTimeNoT = `2006-01-02 15:04:05.999999999Z07:00` + dateTimeJSON = `"` + time.RFC3339Nano + `"` + dateTimeJSONNoT = `"` + dateTimeNoT + `"` +) + +type dateTimeRFC3339 time.Time + +func (t dateTimeRFC3339) MarshalJSON() ([]byte, error) { + tt := time.Time(t) + return tt.MarshalJSON() +} + +func (t dateTimeRFC3339) MarshalText() ([]byte, error) { + tt := time.Time(t) + return tt.MarshalText() +} + +func (t *dateTimeRFC3339) UnmarshalJSON(data []byte) error { + tzOffset := tzOffsetRegex.Match(data) + hasT := strings.Contains(string(data), "T") || strings.Contains(string(data), "t") + var layout string + if tzOffset && hasT { + layout = dateTimeJSON + } else if tzOffset { + layout = dateTimeJSONNoT + } else if hasT { + layout = utcDateTimeJSON + } else { + layout = utcDateTimeJSONNoT + } + return t.Parse(layout, string(data)) +} + +func (t *dateTimeRFC3339) UnmarshalText(data []byte) error { + if len(data) == 0 { + return nil + } + tzOffset := tzOffsetRegex.Match(data) + hasT := strings.Contains(string(data), "T") || strings.Contains(string(data), "t") + var layout string + if tzOffset && hasT { + layout = time.RFC3339Nano + } else if tzOffset { + layout = dateTimeNoT + } else if hasT { + layout = utcDateTime + } else { + layout = utcDateTimeNoT + } + return t.Parse(layout, string(data)) +} + +func (t *dateTimeRFC3339) Parse(layout, value string) error { + p, err := time.Parse(layout, strings.ToUpper(value)) + *t = dateTimeRFC3339(p) + return err +} + +func (t dateTimeRFC3339) String() string { + return time.Time(t).Format(time.RFC3339Nano) +} + +func populateDateTimeRFC3339(m map[string]any, k string, t *time.Time) { + if t == nil { + return + } else if azcore.IsNullValue(t) { + m[k] = nil + return + } else if reflect.ValueOf(t).IsNil() { + return + } + m[k] = (*dateTimeRFC3339)(t) +} + +func unpopulateDateTimeRFC3339(data json.RawMessage, fn string, t **time.Time) error { + if data == nil || string(data) == "null" { + return nil + } + var aux dateTimeRFC3339 + if err := json.Unmarshal(data, &aux); err != nil { + return fmt.Errorf("struct field %s: %v", fn, err) + } + *t = (*time.Time)(&aux) + return nil +} diff --git a/sdk/resourcemanager/secretsstoreextension/armsecretsstoreextension/tsp-location.yaml b/sdk/resourcemanager/secretsstoreextension/armsecretsstoreextension/tsp-location.yaml new file mode 100644 index 000000000000..d0410d09864e --- /dev/null +++ b/sdk/resourcemanager/secretsstoreextension/armsecretsstoreextension/tsp-location.yaml @@ -0,0 +1,4 @@ +directory: specification/ews/SecretSyncController.Management +commit: e80784b9c77ec082a22deedd236ee78b872db334 +repo: Azure/azure-rest-api-specs +additionalDirectories: