com.azure.resourcemanager.storage.implementation.StorageAccountsClientImpl Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of azure-resourcemanager-storage Show documentation
Show all versions of azure-resourcemanager-storage Show documentation
This package contains Microsoft Azure Storage Management SDK.
// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License.
// Code generated by Microsoft (R) AutoRest Code Generator.
package com.azure.resourcemanager.storage.implementation;
import com.azure.core.annotation.BodyParam;
import com.azure.core.annotation.Delete;
import com.azure.core.annotation.ExpectedResponses;
import com.azure.core.annotation.Get;
import com.azure.core.annotation.HeaderParam;
import com.azure.core.annotation.Headers;
import com.azure.core.annotation.Host;
import com.azure.core.annotation.HostParam;
import com.azure.core.annotation.Patch;
import com.azure.core.annotation.PathParam;
import com.azure.core.annotation.Post;
import com.azure.core.annotation.Put;
import com.azure.core.annotation.QueryParam;
import com.azure.core.annotation.ReturnType;
import com.azure.core.annotation.ServiceInterface;
import com.azure.core.annotation.ServiceMethod;
import com.azure.core.annotation.UnexpectedResponseExceptionType;
import com.azure.core.http.rest.PagedFlux;
import com.azure.core.http.rest.PagedIterable;
import com.azure.core.http.rest.PagedResponse;
import com.azure.core.http.rest.PagedResponseBase;
import com.azure.core.http.rest.Response;
import com.azure.core.http.rest.RestProxy;
import com.azure.core.management.exception.ManagementException;
import com.azure.core.management.polling.PollResult;
import com.azure.core.util.Context;
import com.azure.core.util.FluxUtil;
import com.azure.core.util.polling.PollerFlux;
import com.azure.core.util.polling.SyncPoller;
import com.azure.resourcemanager.resources.fluentcore.collection.InnerSupportsDelete;
import com.azure.resourcemanager.resources.fluentcore.collection.InnerSupportsGet;
import com.azure.resourcemanager.resources.fluentcore.collection.InnerSupportsListing;
import com.azure.resourcemanager.storage.fluent.StorageAccountsClient;
import com.azure.resourcemanager.storage.fluent.models.BlobRestoreStatusInner;
import com.azure.resourcemanager.storage.fluent.models.CheckNameAvailabilityResultInner;
import com.azure.resourcemanager.storage.fluent.models.ListAccountSasResponseInner;
import com.azure.resourcemanager.storage.fluent.models.ListServiceSasResponseInner;
import com.azure.resourcemanager.storage.fluent.models.StorageAccountInner;
import com.azure.resourcemanager.storage.fluent.models.StorageAccountListKeysResultInner;
import com.azure.resourcemanager.storage.models.AccountSasParameters;
import com.azure.resourcemanager.storage.models.BlobRestoreParameters;
import com.azure.resourcemanager.storage.models.FailoverType;
import com.azure.resourcemanager.storage.models.ListKeyExpand;
import com.azure.resourcemanager.storage.models.ServiceSasParameters;
import com.azure.resourcemanager.storage.models.StorageAccountCheckNameAvailabilityParameters;
import com.azure.resourcemanager.storage.models.StorageAccountCreateParameters;
import com.azure.resourcemanager.storage.models.StorageAccountExpand;
import com.azure.resourcemanager.storage.models.StorageAccountListResult;
import com.azure.resourcemanager.storage.models.StorageAccountRegenerateKeyParameters;
import com.azure.resourcemanager.storage.models.StorageAccountUpdateParameters;
import java.nio.ByteBuffer;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
/** An instance of this class provides access to all the operations defined in StorageAccountsClient. */
public final class StorageAccountsClientImpl
implements InnerSupportsGet,
InnerSupportsListing,
InnerSupportsDelete,
StorageAccountsClient {
/** The proxy service used to perform REST calls. */
private final StorageAccountsService service;
/** The service client containing this operation class. */
private final StorageManagementClientImpl client;
/**
* Initializes an instance of StorageAccountsClientImpl.
*
* @param client the instance of the service client containing this operation class.
*/
StorageAccountsClientImpl(StorageManagementClientImpl client) {
this.service =
RestProxy.create(StorageAccountsService.class, client.getHttpPipeline(), client.getSerializerAdapter());
this.client = client;
}
/**
* The interface defining all the services for StorageManagementClientStorageAccounts to be used by the proxy
* service to perform REST calls.
*/
@Host("{$host}")
@ServiceInterface(name = "StorageManagementCli")
private interface StorageAccountsService {
@Headers({"Content-Type: application/json"})
@Post("/subscriptions/{subscriptionId}/providers/Microsoft.Storage/checkNameAvailability")
@ExpectedResponses({200})
@UnexpectedResponseExceptionType(ManagementException.class)
Mono> checkNameAvailability(
@HostParam("$host") String endpoint,
@QueryParam("api-version") String apiVersion,
@PathParam("subscriptionId") String subscriptionId,
@BodyParam("application/json") StorageAccountCheckNameAvailabilityParameters accountName,
@HeaderParam("Accept") String accept,
Context context);
@Headers({"Content-Type: application/json"})
@Put(
"/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage"
+ "/storageAccounts/{accountName}")
@ExpectedResponses({200, 202})
@UnexpectedResponseExceptionType(ManagementException.class)
Mono>> create(
@HostParam("$host") String endpoint,
@PathParam("resourceGroupName") String resourceGroupName,
@PathParam("accountName") String accountName,
@QueryParam("api-version") String apiVersion,
@PathParam("subscriptionId") String subscriptionId,
@BodyParam("application/json") StorageAccountCreateParameters parameters,
@HeaderParam("Accept") String accept,
Context context);
@Headers({"Accept: application/json;q=0.9", "Content-Type: application/json"})
@Delete(
"/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage"
+ "/storageAccounts/{accountName}")
@ExpectedResponses({200, 204})
@UnexpectedResponseExceptionType(ManagementException.class)
Mono> delete(
@HostParam("$host") String endpoint,
@PathParam("resourceGroupName") String resourceGroupName,
@PathParam("accountName") String accountName,
@QueryParam("api-version") String apiVersion,
@PathParam("subscriptionId") String subscriptionId,
Context context);
@Headers({"Content-Type: application/json"})
@Get(
"/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage"
+ "/storageAccounts/{accountName}")
@ExpectedResponses({200})
@UnexpectedResponseExceptionType(ManagementException.class)
Mono> getByResourceGroup(
@HostParam("$host") String endpoint,
@PathParam("resourceGroupName") String resourceGroupName,
@PathParam("accountName") String accountName,
@QueryParam("api-version") String apiVersion,
@PathParam("subscriptionId") String subscriptionId,
@QueryParam("$expand") StorageAccountExpand expand,
@HeaderParam("Accept") String accept,
Context context);
@Headers({"Content-Type: application/json"})
@Patch(
"/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage"
+ "/storageAccounts/{accountName}")
@ExpectedResponses({200})
@UnexpectedResponseExceptionType(ManagementException.class)
Mono> update(
@HostParam("$host") String endpoint,
@PathParam("resourceGroupName") String resourceGroupName,
@PathParam("accountName") String accountName,
@QueryParam("api-version") String apiVersion,
@PathParam("subscriptionId") String subscriptionId,
@BodyParam("application/json") StorageAccountUpdateParameters parameters,
@HeaderParam("Accept") String accept,
Context context);
@Headers({"Content-Type: application/json"})
@Get("/subscriptions/{subscriptionId}/providers/Microsoft.Storage/storageAccounts")
@ExpectedResponses({200})
@UnexpectedResponseExceptionType(ManagementException.class)
Mono> list(
@HostParam("$host") String endpoint,
@QueryParam("api-version") String apiVersion,
@PathParam("subscriptionId") String subscriptionId,
@HeaderParam("Accept") String accept,
Context context);
@Headers({"Content-Type: application/json"})
@Get(
"/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage"
+ "/storageAccounts")
@ExpectedResponses({200})
@UnexpectedResponseExceptionType(ManagementException.class)
Mono> listByResourceGroup(
@HostParam("$host") String endpoint,
@PathParam("resourceGroupName") String resourceGroupName,
@QueryParam("api-version") String apiVersion,
@PathParam("subscriptionId") String subscriptionId,
@HeaderParam("Accept") String accept,
Context context);
@Headers({"Content-Type: application/json"})
@Post(
"/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage"
+ "/storageAccounts/{accountName}/listKeys")
@ExpectedResponses({200})
@UnexpectedResponseExceptionType(ManagementException.class)
Mono> listKeys(
@HostParam("$host") String endpoint,
@PathParam("resourceGroupName") String resourceGroupName,
@PathParam("accountName") String accountName,
@QueryParam("api-version") String apiVersion,
@PathParam("subscriptionId") String subscriptionId,
@QueryParam("$expand") ListKeyExpand expand,
@HeaderParam("Accept") String accept,
Context context);
@Headers({"Content-Type: application/json"})
@Post(
"/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage"
+ "/storageAccounts/{accountName}/regenerateKey")
@ExpectedResponses({200})
@UnexpectedResponseExceptionType(ManagementException.class)
Mono> regenerateKey(
@HostParam("$host") String endpoint,
@PathParam("resourceGroupName") String resourceGroupName,
@PathParam("accountName") String accountName,
@QueryParam("api-version") String apiVersion,
@PathParam("subscriptionId") String subscriptionId,
@BodyParam("application/json") StorageAccountRegenerateKeyParameters regenerateKey,
@HeaderParam("Accept") String accept,
Context context);
@Headers({"Content-Type: application/json"})
@Post(
"/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage"
+ "/storageAccounts/{accountName}/ListAccountSas")
@ExpectedResponses({200})
@UnexpectedResponseExceptionType(ManagementException.class)
Mono> listAccountSas(
@HostParam("$host") String endpoint,
@PathParam("resourceGroupName") String resourceGroupName,
@PathParam("accountName") String accountName,
@QueryParam("api-version") String apiVersion,
@PathParam("subscriptionId") String subscriptionId,
@BodyParam("application/json") AccountSasParameters parameters,
@HeaderParam("Accept") String accept,
Context context);
@Headers({"Content-Type: application/json"})
@Post(
"/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage"
+ "/storageAccounts/{accountName}/ListServiceSas")
@ExpectedResponses({200})
@UnexpectedResponseExceptionType(ManagementException.class)
Mono> listServiceSas(
@HostParam("$host") String endpoint,
@PathParam("resourceGroupName") String resourceGroupName,
@PathParam("accountName") String accountName,
@QueryParam("api-version") String apiVersion,
@PathParam("subscriptionId") String subscriptionId,
@BodyParam("application/json") ServiceSasParameters parameters,
@HeaderParam("Accept") String accept,
Context context);
@Headers({"Accept: application/json;q=0.9", "Content-Type: application/json"})
@Post(
"/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage"
+ "/storageAccounts/{accountName}/failover")
@ExpectedResponses({200, 202})
@UnexpectedResponseExceptionType(ManagementException.class)
Mono>> failover(
@HostParam("$host") String endpoint,
@PathParam("resourceGroupName") String resourceGroupName,
@PathParam("accountName") String accountName,
@QueryParam("api-version") String apiVersion,
@PathParam("subscriptionId") String subscriptionId,
@QueryParam("failoverType") FailoverType failoverType,
Context context);
@Headers({"Content-Type: application/json"})
@Post(
"/subscriptions/{subscriptionId}/resourcegroups/{resourceGroupName}/providers/Microsoft.Storage"
+ "/storageAccounts/{accountName}/hnsonmigration")
@ExpectedResponses({200, 202})
@UnexpectedResponseExceptionType(ManagementException.class)
Mono>> hierarchicalNamespaceMigration(
@HostParam("$host") String endpoint,
@PathParam("resourceGroupName") String resourceGroupName,
@PathParam("accountName") String accountName,
@QueryParam("api-version") String apiVersion,
@PathParam("subscriptionId") String subscriptionId,
@QueryParam("requestType") String requestType,
@HeaderParam("Accept") String accept,
Context context);
@Headers({"Content-Type: application/json"})
@Post(
"/subscriptions/{subscriptionId}/resourcegroups/{resourceGroupName}/providers/Microsoft.Storage"
+ "/storageAccounts/{accountName}/aborthnsonmigration")
@ExpectedResponses({200, 202})
@UnexpectedResponseExceptionType(ManagementException.class)
Mono>> abortHierarchicalNamespaceMigration(
@HostParam("$host") String endpoint,
@PathParam("resourceGroupName") String resourceGroupName,
@PathParam("accountName") String accountName,
@QueryParam("api-version") String apiVersion,
@PathParam("subscriptionId") String subscriptionId,
@HeaderParam("Accept") String accept,
Context context);
@Headers({"Content-Type: application/json"})
@Post(
"/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage"
+ "/storageAccounts/{accountName}/restoreBlobRanges")
@ExpectedResponses({200, 202})
@UnexpectedResponseExceptionType(ManagementException.class)
Mono>> restoreBlobRanges(
@HostParam("$host") String endpoint,
@PathParam("resourceGroupName") String resourceGroupName,
@PathParam("accountName") String accountName,
@QueryParam("api-version") String apiVersion,
@PathParam("subscriptionId") String subscriptionId,
@BodyParam("application/json") BlobRestoreParameters parameters,
@HeaderParam("Accept") String accept,
Context context);
@Headers({"Accept: application/json;q=0.9", "Content-Type: application/json"})
@Post(
"/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage"
+ "/storageAccounts/{accountName}/revokeUserDelegationKeys")
@ExpectedResponses({200})
@UnexpectedResponseExceptionType(ManagementException.class)
Mono> revokeUserDelegationKeys(
@HostParam("$host") String endpoint,
@PathParam("resourceGroupName") String resourceGroupName,
@PathParam("accountName") String accountName,
@QueryParam("api-version") String apiVersion,
@PathParam("subscriptionId") String subscriptionId,
Context context);
@Headers({"Content-Type: application/json"})
@Get("{nextLink}")
@ExpectedResponses({200})
@UnexpectedResponseExceptionType(ManagementException.class)
Mono> listNext(
@PathParam(value = "nextLink", encoded = true) String nextLink,
@HostParam("$host") String endpoint,
@HeaderParam("Accept") String accept,
Context context);
@Headers({"Content-Type: application/json"})
@Get("{nextLink}")
@ExpectedResponses({200})
@UnexpectedResponseExceptionType(ManagementException.class)
Mono> listByResourceGroupNext(
@PathParam(value = "nextLink", encoded = true) String nextLink,
@HostParam("$host") String endpoint,
@HeaderParam("Accept") String accept,
Context context);
}
/**
* Checks that the storage account name is valid and is not already in use.
*
* @param accountName The name of the storage account within the specified resource group. Storage account names
* must be between 3 and 24 characters in length and use numbers and lower-case letters only.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return the CheckNameAvailability operation response along with {@link Response} on successful completion of
* {@link Mono}.
*/
@ServiceMethod(returns = ReturnType.SINGLE)
public Mono> checkNameAvailabilityWithResponseAsync(
StorageAccountCheckNameAvailabilityParameters accountName) {
if (this.client.getEndpoint() == null) {
return Mono
.error(
new IllegalArgumentException(
"Parameter this.client.getEndpoint() is required and cannot be null."));
}
if (this.client.getSubscriptionId() == null) {
return Mono
.error(
new IllegalArgumentException(
"Parameter this.client.getSubscriptionId() is required and cannot be null."));
}
if (accountName == null) {
return Mono.error(new IllegalArgumentException("Parameter accountName is required and cannot be null."));
} else {
accountName.validate();
}
final String accept = "application/json";
return FluxUtil
.withContext(
context ->
service
.checkNameAvailability(
this.client.getEndpoint(),
this.client.getApiVersion(),
this.client.getSubscriptionId(),
accountName,
accept,
context))
.contextWrite(context -> context.putAll(FluxUtil.toReactorContext(this.client.getContext()).readOnly()));
}
/**
* Checks that the storage account name is valid and is not already in use.
*
* @param accountName The name of the storage account within the specified resource group. Storage account names
* must be between 3 and 24 characters in length and use numbers and lower-case letters only.
* @param context The context to associate with this operation.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return the CheckNameAvailability operation response along with {@link Response} on successful completion of
* {@link Mono}.
*/
@ServiceMethod(returns = ReturnType.SINGLE)
private Mono> checkNameAvailabilityWithResponseAsync(
StorageAccountCheckNameAvailabilityParameters accountName, Context context) {
if (this.client.getEndpoint() == null) {
return Mono
.error(
new IllegalArgumentException(
"Parameter this.client.getEndpoint() is required and cannot be null."));
}
if (this.client.getSubscriptionId() == null) {
return Mono
.error(
new IllegalArgumentException(
"Parameter this.client.getSubscriptionId() is required and cannot be null."));
}
if (accountName == null) {
return Mono.error(new IllegalArgumentException("Parameter accountName is required and cannot be null."));
} else {
accountName.validate();
}
final String accept = "application/json";
context = this.client.mergeContext(context);
return service
.checkNameAvailability(
this.client.getEndpoint(),
this.client.getApiVersion(),
this.client.getSubscriptionId(),
accountName,
accept,
context);
}
/**
* Checks that the storage account name is valid and is not already in use.
*
* @param accountName The name of the storage account within the specified resource group. Storage account names
* must be between 3 and 24 characters in length and use numbers and lower-case letters only.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return the CheckNameAvailability operation response on successful completion of {@link Mono}.
*/
@ServiceMethod(returns = ReturnType.SINGLE)
public Mono checkNameAvailabilityAsync(
StorageAccountCheckNameAvailabilityParameters accountName) {
return checkNameAvailabilityWithResponseAsync(accountName).flatMap(res -> Mono.justOrEmpty(res.getValue()));
}
/**
* Checks that the storage account name is valid and is not already in use.
*
* @param accountName The name of the storage account within the specified resource group. Storage account names
* must be between 3 and 24 characters in length and use numbers and lower-case letters only.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return the CheckNameAvailability operation response.
*/
@ServiceMethod(returns = ReturnType.SINGLE)
public CheckNameAvailabilityResultInner checkNameAvailability(
StorageAccountCheckNameAvailabilityParameters accountName) {
return checkNameAvailabilityAsync(accountName).block();
}
/**
* Checks that the storage account name is valid and is not already in use.
*
* @param accountName The name of the storage account within the specified resource group. Storage account names
* must be between 3 and 24 characters in length and use numbers and lower-case letters only.
* @param context The context to associate with this operation.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return the CheckNameAvailability operation response along with {@link Response}.
*/
@ServiceMethod(returns = ReturnType.SINGLE)
public Response checkNameAvailabilityWithResponse(
StorageAccountCheckNameAvailabilityParameters accountName, Context context) {
return checkNameAvailabilityWithResponseAsync(accountName, context).block();
}
/**
* Asynchronously creates a new storage account with the specified parameters. If an account is already created and
* a subsequent create request is issued with different properties, the account properties will be updated. If an
* account is already created and a subsequent create or update request is issued with the exact same set of
* properties, the request will succeed.
*
* @param resourceGroupName The name of the resource group within the user's subscription. The name is case
* insensitive.
* @param accountName The name of the storage account within the specified resource group. Storage account names
* must be between 3 and 24 characters in length and use numbers and lower-case letters only.
* @param parameters The parameters to provide for the created account.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return the storage account along with {@link Response} on successful completion of {@link Mono}.
*/
@ServiceMethod(returns = ReturnType.SINGLE)
public Mono>> createWithResponseAsync(
String resourceGroupName, String accountName, StorageAccountCreateParameters parameters) {
if (this.client.getEndpoint() == null) {
return Mono
.error(
new IllegalArgumentException(
"Parameter this.client.getEndpoint() is required and cannot be null."));
}
if (resourceGroupName == null) {
return Mono
.error(new IllegalArgumentException("Parameter resourceGroupName is required and cannot be null."));
}
if (accountName == null) {
return Mono.error(new IllegalArgumentException("Parameter accountName is required and cannot be null."));
}
if (this.client.getSubscriptionId() == null) {
return Mono
.error(
new IllegalArgumentException(
"Parameter this.client.getSubscriptionId() is required and cannot be null."));
}
if (parameters == null) {
return Mono.error(new IllegalArgumentException("Parameter parameters is required and cannot be null."));
} else {
parameters.validate();
}
final String accept = "application/json";
return FluxUtil
.withContext(
context ->
service
.create(
this.client.getEndpoint(),
resourceGroupName,
accountName,
this.client.getApiVersion(),
this.client.getSubscriptionId(),
parameters,
accept,
context))
.contextWrite(context -> context.putAll(FluxUtil.toReactorContext(this.client.getContext()).readOnly()));
}
/**
* Asynchronously creates a new storage account with the specified parameters. If an account is already created and
* a subsequent create request is issued with different properties, the account properties will be updated. If an
* account is already created and a subsequent create or update request is issued with the exact same set of
* properties, the request will succeed.
*
* @param resourceGroupName The name of the resource group within the user's subscription. The name is case
* insensitive.
* @param accountName The name of the storage account within the specified resource group. Storage account names
* must be between 3 and 24 characters in length and use numbers and lower-case letters only.
* @param parameters The parameters to provide for the created account.
* @param context The context to associate with this operation.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return the storage account along with {@link Response} on successful completion of {@link Mono}.
*/
@ServiceMethod(returns = ReturnType.SINGLE)
private Mono>> createWithResponseAsync(
String resourceGroupName, String accountName, StorageAccountCreateParameters parameters, Context context) {
if (this.client.getEndpoint() == null) {
return Mono
.error(
new IllegalArgumentException(
"Parameter this.client.getEndpoint() is required and cannot be null."));
}
if (resourceGroupName == null) {
return Mono
.error(new IllegalArgumentException("Parameter resourceGroupName is required and cannot be null."));
}
if (accountName == null) {
return Mono.error(new IllegalArgumentException("Parameter accountName is required and cannot be null."));
}
if (this.client.getSubscriptionId() == null) {
return Mono
.error(
new IllegalArgumentException(
"Parameter this.client.getSubscriptionId() is required and cannot be null."));
}
if (parameters == null) {
return Mono.error(new IllegalArgumentException("Parameter parameters is required and cannot be null."));
} else {
parameters.validate();
}
final String accept = "application/json";
context = this.client.mergeContext(context);
return service
.create(
this.client.getEndpoint(),
resourceGroupName,
accountName,
this.client.getApiVersion(),
this.client.getSubscriptionId(),
parameters,
accept,
context);
}
/**
* Asynchronously creates a new storage account with the specified parameters. If an account is already created and
* a subsequent create request is issued with different properties, the account properties will be updated. If an
* account is already created and a subsequent create or update request is issued with the exact same set of
* properties, the request will succeed.
*
* @param resourceGroupName The name of the resource group within the user's subscription. The name is case
* insensitive.
* @param accountName The name of the storage account within the specified resource group. Storage account names
* must be between 3 and 24 characters in length and use numbers and lower-case letters only.
* @param parameters The parameters to provide for the created account.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return the {@link PollerFlux} for polling of the storage account.
*/
@ServiceMethod(returns = ReturnType.LONG_RUNNING_OPERATION)
public PollerFlux, StorageAccountInner> beginCreateAsync(
String resourceGroupName, String accountName, StorageAccountCreateParameters parameters) {
Mono>> mono = createWithResponseAsync(resourceGroupName, accountName, parameters);
return this
.client
.getLroResult(
mono,
this.client.getHttpPipeline(),
StorageAccountInner.class,
StorageAccountInner.class,
this.client.getContext());
}
/**
* Asynchronously creates a new storage account with the specified parameters. If an account is already created and
* a subsequent create request is issued with different properties, the account properties will be updated. If an
* account is already created and a subsequent create or update request is issued with the exact same set of
* properties, the request will succeed.
*
* @param resourceGroupName The name of the resource group within the user's subscription. The name is case
* insensitive.
* @param accountName The name of the storage account within the specified resource group. Storage account names
* must be between 3 and 24 characters in length and use numbers and lower-case letters only.
* @param parameters The parameters to provide for the created account.
* @param context The context to associate with this operation.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return the {@link PollerFlux} for polling of the storage account.
*/
@ServiceMethod(returns = ReturnType.LONG_RUNNING_OPERATION)
private PollerFlux, StorageAccountInner> beginCreateAsync(
String resourceGroupName, String accountName, StorageAccountCreateParameters parameters, Context context) {
context = this.client.mergeContext(context);
Mono>> mono =
createWithResponseAsync(resourceGroupName, accountName, parameters, context);
return this
.client
.getLroResult(
mono, this.client.getHttpPipeline(), StorageAccountInner.class, StorageAccountInner.class, context);
}
/**
* Asynchronously creates a new storage account with the specified parameters. If an account is already created and
* a subsequent create request is issued with different properties, the account properties will be updated. If an
* account is already created and a subsequent create or update request is issued with the exact same set of
* properties, the request will succeed.
*
* @param resourceGroupName The name of the resource group within the user's subscription. The name is case
* insensitive.
* @param accountName The name of the storage account within the specified resource group. Storage account names
* must be between 3 and 24 characters in length and use numbers and lower-case letters only.
* @param parameters The parameters to provide for the created account.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return the {@link SyncPoller} for polling of the storage account.
*/
@ServiceMethod(returns = ReturnType.LONG_RUNNING_OPERATION)
public SyncPoller, StorageAccountInner> beginCreate(
String resourceGroupName, String accountName, StorageAccountCreateParameters parameters) {
return beginCreateAsync(resourceGroupName, accountName, parameters).getSyncPoller();
}
/**
* Asynchronously creates a new storage account with the specified parameters. If an account is already created and
* a subsequent create request is issued with different properties, the account properties will be updated. If an
* account is already created and a subsequent create or update request is issued with the exact same set of
* properties, the request will succeed.
*
* @param resourceGroupName The name of the resource group within the user's subscription. The name is case
* insensitive.
* @param accountName The name of the storage account within the specified resource group. Storage account names
* must be between 3 and 24 characters in length and use numbers and lower-case letters only.
* @param parameters The parameters to provide for the created account.
* @param context The context to associate with this operation.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return the {@link SyncPoller} for polling of the storage account.
*/
@ServiceMethod(returns = ReturnType.LONG_RUNNING_OPERATION)
public SyncPoller, StorageAccountInner> beginCreate(
String resourceGroupName, String accountName, StorageAccountCreateParameters parameters, Context context) {
return beginCreateAsync(resourceGroupName, accountName, parameters, context).getSyncPoller();
}
/**
* Asynchronously creates a new storage account with the specified parameters. If an account is already created and
* a subsequent create request is issued with different properties, the account properties will be updated. If an
* account is already created and a subsequent create or update request is issued with the exact same set of
* properties, the request will succeed.
*
* @param resourceGroupName The name of the resource group within the user's subscription. The name is case
* insensitive.
* @param accountName The name of the storage account within the specified resource group. Storage account names
* must be between 3 and 24 characters in length and use numbers and lower-case letters only.
* @param parameters The parameters to provide for the created account.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return the storage account on successful completion of {@link Mono}.
*/
@ServiceMethod(returns = ReturnType.SINGLE)
public Mono createAsync(
String resourceGroupName, String accountName, StorageAccountCreateParameters parameters) {
return beginCreateAsync(resourceGroupName, accountName, parameters)
.last()
.flatMap(this.client::getLroFinalResultOrError);
}
/**
* Asynchronously creates a new storage account with the specified parameters. If an account is already created and
* a subsequent create request is issued with different properties, the account properties will be updated. If an
* account is already created and a subsequent create or update request is issued with the exact same set of
* properties, the request will succeed.
*
* @param resourceGroupName The name of the resource group within the user's subscription. The name is case
* insensitive.
* @param accountName The name of the storage account within the specified resource group. Storage account names
* must be between 3 and 24 characters in length and use numbers and lower-case letters only.
* @param parameters The parameters to provide for the created account.
* @param context The context to associate with this operation.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return the storage account on successful completion of {@link Mono}.
*/
@ServiceMethod(returns = ReturnType.SINGLE)
private Mono createAsync(
String resourceGroupName, String accountName, StorageAccountCreateParameters parameters, Context context) {
return beginCreateAsync(resourceGroupName, accountName, parameters, context)
.last()
.flatMap(this.client::getLroFinalResultOrError);
}
/**
* Asynchronously creates a new storage account with the specified parameters. If an account is already created and
* a subsequent create request is issued with different properties, the account properties will be updated. If an
* account is already created and a subsequent create or update request is issued with the exact same set of
* properties, the request will succeed.
*
* @param resourceGroupName The name of the resource group within the user's subscription. The name is case
* insensitive.
* @param accountName The name of the storage account within the specified resource group. Storage account names
* must be between 3 and 24 characters in length and use numbers and lower-case letters only.
* @param parameters The parameters to provide for the created account.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return the storage account.
*/
@ServiceMethod(returns = ReturnType.SINGLE)
public StorageAccountInner create(
String resourceGroupName, String accountName, StorageAccountCreateParameters parameters) {
return createAsync(resourceGroupName, accountName, parameters).block();
}
/**
* Asynchronously creates a new storage account with the specified parameters. If an account is already created and
* a subsequent create request is issued with different properties, the account properties will be updated. If an
* account is already created and a subsequent create or update request is issued with the exact same set of
* properties, the request will succeed.
*
* @param resourceGroupName The name of the resource group within the user's subscription. The name is case
* insensitive.
* @param accountName The name of the storage account within the specified resource group. Storage account names
* must be between 3 and 24 characters in length and use numbers and lower-case letters only.
* @param parameters The parameters to provide for the created account.
* @param context The context to associate with this operation.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return the storage account.
*/
@ServiceMethod(returns = ReturnType.SINGLE)
public StorageAccountInner create(
String resourceGroupName, String accountName, StorageAccountCreateParameters parameters, Context context) {
return createAsync(resourceGroupName, accountName, parameters, context).block();
}
/**
* Deletes a storage account in Microsoft Azure.
*
* @param resourceGroupName The name of the resource group within the user's subscription. The name is case
* insensitive.
* @param accountName The name of the storage account within the specified resource group. Storage account names
* must be between 3 and 24 characters in length and use numbers and lower-case letters only.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return the {@link Response} on successful completion of {@link Mono}.
*/
@ServiceMethod(returns = ReturnType.SINGLE)
public Mono> deleteWithResponseAsync(String resourceGroupName, String accountName) {
if (this.client.getEndpoint() == null) {
return Mono
.error(
new IllegalArgumentException(
"Parameter this.client.getEndpoint() is required and cannot be null."));
}
if (resourceGroupName == null) {
return Mono
.error(new IllegalArgumentException("Parameter resourceGroupName is required and cannot be null."));
}
if (accountName == null) {
return Mono.error(new IllegalArgumentException("Parameter accountName is required and cannot be null."));
}
if (this.client.getSubscriptionId() == null) {
return Mono
.error(
new IllegalArgumentException(
"Parameter this.client.getSubscriptionId() is required and cannot be null."));
}
return FluxUtil
.withContext(
context ->
service
.delete(
this.client.getEndpoint(),
resourceGroupName,
accountName,
this.client.getApiVersion(),
this.client.getSubscriptionId(),
context))
.contextWrite(context -> context.putAll(FluxUtil.toReactorContext(this.client.getContext()).readOnly()));
}
/**
* Deletes a storage account in Microsoft Azure.
*
* @param resourceGroupName The name of the resource group within the user's subscription. The name is case
* insensitive.
* @param accountName The name of the storage account within the specified resource group. Storage account names
* must be between 3 and 24 characters in length and use numbers and lower-case letters only.
* @param context The context to associate with this operation.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return the {@link Response} on successful completion of {@link Mono}.
*/
@ServiceMethod(returns = ReturnType.SINGLE)
private Mono> deleteWithResponseAsync(
String resourceGroupName, String accountName, Context context) {
if (this.client.getEndpoint() == null) {
return Mono
.error(
new IllegalArgumentException(
"Parameter this.client.getEndpoint() is required and cannot be null."));
}
if (resourceGroupName == null) {
return Mono
.error(new IllegalArgumentException("Parameter resourceGroupName is required and cannot be null."));
}
if (accountName == null) {
return Mono.error(new IllegalArgumentException("Parameter accountName is required and cannot be null."));
}
if (this.client.getSubscriptionId() == null) {
return Mono
.error(
new IllegalArgumentException(
"Parameter this.client.getSubscriptionId() is required and cannot be null."));
}
context = this.client.mergeContext(context);
return service
.delete(
this.client.getEndpoint(),
resourceGroupName,
accountName,
this.client.getApiVersion(),
this.client.getSubscriptionId(),
context);
}
/**
* Deletes a storage account in Microsoft Azure.
*
* @param resourceGroupName The name of the resource group within the user's subscription. The name is case
* insensitive.
* @param accountName The name of the storage account within the specified resource group. Storage account names
* must be between 3 and 24 characters in length and use numbers and lower-case letters only.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return A {@link Mono} that completes when a successful response is received.
*/
@ServiceMethod(returns = ReturnType.SINGLE)
public Mono deleteAsync(String resourceGroupName, String accountName) {
return deleteWithResponseAsync(resourceGroupName, accountName).flatMap(ignored -> Mono.empty());
}
/**
* Deletes a storage account in Microsoft Azure.
*
* @param resourceGroupName The name of the resource group within the user's subscription. The name is case
* insensitive.
* @param accountName The name of the storage account within the specified resource group. Storage account names
* must be between 3 and 24 characters in length and use numbers and lower-case letters only.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
*/
@ServiceMethod(returns = ReturnType.SINGLE)
public void delete(String resourceGroupName, String accountName) {
deleteAsync(resourceGroupName, accountName).block();
}
/**
* Deletes a storage account in Microsoft Azure.
*
* @param resourceGroupName The name of the resource group within the user's subscription. The name is case
* insensitive.
* @param accountName The name of the storage account within the specified resource group. Storage account names
* must be between 3 and 24 characters in length and use numbers and lower-case letters only.
* @param context The context to associate with this operation.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return the {@link Response}.
*/
@ServiceMethod(returns = ReturnType.SINGLE)
public Response deleteWithResponse(String resourceGroupName, String accountName, Context context) {
return deleteWithResponseAsync(resourceGroupName, accountName, context).block();
}
/**
* Returns the properties for the specified storage account including but not limited to name, SKU name, location,
* and account status. The ListKeys operation should be used to retrieve storage keys.
*
* @param resourceGroupName The name of the resource group within the user's subscription. The name is case
* insensitive.
* @param accountName The name of the storage account within the specified resource group. Storage account names
* must be between 3 and 24 characters in length and use numbers and lower-case letters only.
* @param expand May be used to expand the properties within account's properties. By default, data is not included
* when fetching properties. Currently we only support geoReplicationStats and blobRestoreStatus.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return the storage account along with {@link Response} on successful completion of {@link Mono}.
*/
@ServiceMethod(returns = ReturnType.SINGLE)
public Mono> getByResourceGroupWithResponseAsync(
String resourceGroupName, String accountName, StorageAccountExpand expand) {
if (this.client.getEndpoint() == null) {
return Mono
.error(
new IllegalArgumentException(
"Parameter this.client.getEndpoint() is required and cannot be null."));
}
if (resourceGroupName == null) {
return Mono
.error(new IllegalArgumentException("Parameter resourceGroupName is required and cannot be null."));
}
if (accountName == null) {
return Mono.error(new IllegalArgumentException("Parameter accountName is required and cannot be null."));
}
if (this.client.getSubscriptionId() == null) {
return Mono
.error(
new IllegalArgumentException(
"Parameter this.client.getSubscriptionId() is required and cannot be null."));
}
final String accept = "application/json";
return FluxUtil
.withContext(
context ->
service
.getByResourceGroup(
this.client.getEndpoint(),
resourceGroupName,
accountName,
this.client.getApiVersion(),
this.client.getSubscriptionId(),
expand,
accept,
context))
.contextWrite(context -> context.putAll(FluxUtil.toReactorContext(this.client.getContext()).readOnly()));
}
/**
* Returns the properties for the specified storage account including but not limited to name, SKU name, location,
* and account status. The ListKeys operation should be used to retrieve storage keys.
*
* @param resourceGroupName The name of the resource group within the user's subscription. The name is case
* insensitive.
* @param accountName The name of the storage account within the specified resource group. Storage account names
* must be between 3 and 24 characters in length and use numbers and lower-case letters only.
* @param expand May be used to expand the properties within account's properties. By default, data is not included
* when fetching properties. Currently we only support geoReplicationStats and blobRestoreStatus.
* @param context The context to associate with this operation.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return the storage account along with {@link Response} on successful completion of {@link Mono}.
*/
@ServiceMethod(returns = ReturnType.SINGLE)
private Mono> getByResourceGroupWithResponseAsync(
String resourceGroupName, String accountName, StorageAccountExpand expand, Context context) {
if (this.client.getEndpoint() == null) {
return Mono
.error(
new IllegalArgumentException(
"Parameter this.client.getEndpoint() is required and cannot be null."));
}
if (resourceGroupName == null) {
return Mono
.error(new IllegalArgumentException("Parameter resourceGroupName is required and cannot be null."));
}
if (accountName == null) {
return Mono.error(new IllegalArgumentException("Parameter accountName is required and cannot be null."));
}
if (this.client.getSubscriptionId() == null) {
return Mono
.error(
new IllegalArgumentException(
"Parameter this.client.getSubscriptionId() is required and cannot be null."));
}
final String accept = "application/json";
context = this.client.mergeContext(context);
return service
.getByResourceGroup(
this.client.getEndpoint(),
resourceGroupName,
accountName,
this.client.getApiVersion(),
this.client.getSubscriptionId(),
expand,
accept,
context);
}
/**
* Returns the properties for the specified storage account including but not limited to name, SKU name, location,
* and account status. The ListKeys operation should be used to retrieve storage keys.
*
* @param resourceGroupName The name of the resource group within the user's subscription. The name is case
* insensitive.
* @param accountName The name of the storage account within the specified resource group. Storage account names
* must be between 3 and 24 characters in length and use numbers and lower-case letters only.
* @param expand May be used to expand the properties within account's properties. By default, data is not included
* when fetching properties. Currently we only support geoReplicationStats and blobRestoreStatus.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return the storage account on successful completion of {@link Mono}.
*/
@ServiceMethod(returns = ReturnType.SINGLE)
public Mono getByResourceGroupAsync(
String resourceGroupName, String accountName, StorageAccountExpand expand) {
return getByResourceGroupWithResponseAsync(resourceGroupName, accountName, expand)
.flatMap(res -> Mono.justOrEmpty(res.getValue()));
}
/**
* Returns the properties for the specified storage account including but not limited to name, SKU name, location,
* and account status. The ListKeys operation should be used to retrieve storage keys.
*
* @param resourceGroupName The name of the resource group within the user's subscription. The name is case
* insensitive.
* @param accountName The name of the storage account within the specified resource group. Storage account names
* must be between 3 and 24 characters in length and use numbers and lower-case letters only.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return the storage account on successful completion of {@link Mono}.
*/
@ServiceMethod(returns = ReturnType.SINGLE)
public Mono getByResourceGroupAsync(String resourceGroupName, String accountName) {
final StorageAccountExpand expand = null;
return getByResourceGroupWithResponseAsync(resourceGroupName, accountName, expand)
.flatMap(res -> Mono.justOrEmpty(res.getValue()));
}
/**
* Returns the properties for the specified storage account including but not limited to name, SKU name, location,
* and account status. The ListKeys operation should be used to retrieve storage keys.
*
* @param resourceGroupName The name of the resource group within the user's subscription. The name is case
* insensitive.
* @param accountName The name of the storage account within the specified resource group. Storage account names
* must be between 3 and 24 characters in length and use numbers and lower-case letters only.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return the storage account.
*/
@ServiceMethod(returns = ReturnType.SINGLE)
public StorageAccountInner getByResourceGroup(String resourceGroupName, String accountName) {
final StorageAccountExpand expand = null;
return getByResourceGroupAsync(resourceGroupName, accountName, expand).block();
}
/**
* Returns the properties for the specified storage account including but not limited to name, SKU name, location,
* and account status. The ListKeys operation should be used to retrieve storage keys.
*
* @param resourceGroupName The name of the resource group within the user's subscription. The name is case
* insensitive.
* @param accountName The name of the storage account within the specified resource group. Storage account names
* must be between 3 and 24 characters in length and use numbers and lower-case letters only.
* @param expand May be used to expand the properties within account's properties. By default, data is not included
* when fetching properties. Currently we only support geoReplicationStats and blobRestoreStatus.
* @param context The context to associate with this operation.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return the storage account along with {@link Response}.
*/
@ServiceMethod(returns = ReturnType.SINGLE)
public Response getByResourceGroupWithResponse(
String resourceGroupName, String accountName, StorageAccountExpand expand, Context context) {
return getByResourceGroupWithResponseAsync(resourceGroupName, accountName, expand, context).block();
}
/**
* The update operation can be used to update the SKU, encryption, access tier, or tags for a storage account. It
* can also be used to map the account to a custom domain. Only one custom domain is supported per storage account;
* the replacement/change of custom domain is not supported. In order to replace an old custom domain, the old value
* must be cleared/unregistered before a new value can be set. The update of multiple properties is supported. This
* call does not change the storage keys for the account. If you want to change the storage account keys, use the
* regenerate keys operation. The location and name of the storage account cannot be changed after creation.
*
* @param resourceGroupName The name of the resource group within the user's subscription. The name is case
* insensitive.
* @param accountName The name of the storage account within the specified resource group. Storage account names
* must be between 3 and 24 characters in length and use numbers and lower-case letters only.
* @param parameters The parameters to provide for the updated account.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return the storage account along with {@link Response} on successful completion of {@link Mono}.
*/
@ServiceMethod(returns = ReturnType.SINGLE)
public Mono> updateWithResponseAsync(
String resourceGroupName, String accountName, StorageAccountUpdateParameters parameters) {
if (this.client.getEndpoint() == null) {
return Mono
.error(
new IllegalArgumentException(
"Parameter this.client.getEndpoint() is required and cannot be null."));
}
if (resourceGroupName == null) {
return Mono
.error(new IllegalArgumentException("Parameter resourceGroupName is required and cannot be null."));
}
if (accountName == null) {
return Mono.error(new IllegalArgumentException("Parameter accountName is required and cannot be null."));
}
if (this.client.getSubscriptionId() == null) {
return Mono
.error(
new IllegalArgumentException(
"Parameter this.client.getSubscriptionId() is required and cannot be null."));
}
if (parameters == null) {
return Mono.error(new IllegalArgumentException("Parameter parameters is required and cannot be null."));
} else {
parameters.validate();
}
final String accept = "application/json";
return FluxUtil
.withContext(
context ->
service
.update(
this.client.getEndpoint(),
resourceGroupName,
accountName,
this.client.getApiVersion(),
this.client.getSubscriptionId(),
parameters,
accept,
context))
.contextWrite(context -> context.putAll(FluxUtil.toReactorContext(this.client.getContext()).readOnly()));
}
/**
* The update operation can be used to update the SKU, encryption, access tier, or tags for a storage account. It
* can also be used to map the account to a custom domain. Only one custom domain is supported per storage account;
* the replacement/change of custom domain is not supported. In order to replace an old custom domain, the old value
* must be cleared/unregistered before a new value can be set. The update of multiple properties is supported. This
* call does not change the storage keys for the account. If you want to change the storage account keys, use the
* regenerate keys operation. The location and name of the storage account cannot be changed after creation.
*
* @param resourceGroupName The name of the resource group within the user's subscription. The name is case
* insensitive.
* @param accountName The name of the storage account within the specified resource group. Storage account names
* must be between 3 and 24 characters in length and use numbers and lower-case letters only.
* @param parameters The parameters to provide for the updated account.
* @param context The context to associate with this operation.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return the storage account along with {@link Response} on successful completion of {@link Mono}.
*/
@ServiceMethod(returns = ReturnType.SINGLE)
private Mono> updateWithResponseAsync(
String resourceGroupName, String accountName, StorageAccountUpdateParameters parameters, Context context) {
if (this.client.getEndpoint() == null) {
return Mono
.error(
new IllegalArgumentException(
"Parameter this.client.getEndpoint() is required and cannot be null."));
}
if (resourceGroupName == null) {
return Mono
.error(new IllegalArgumentException("Parameter resourceGroupName is required and cannot be null."));
}
if (accountName == null) {
return Mono.error(new IllegalArgumentException("Parameter accountName is required and cannot be null."));
}
if (this.client.getSubscriptionId() == null) {
return Mono
.error(
new IllegalArgumentException(
"Parameter this.client.getSubscriptionId() is required and cannot be null."));
}
if (parameters == null) {
return Mono.error(new IllegalArgumentException("Parameter parameters is required and cannot be null."));
} else {
parameters.validate();
}
final String accept = "application/json";
context = this.client.mergeContext(context);
return service
.update(
this.client.getEndpoint(),
resourceGroupName,
accountName,
this.client.getApiVersion(),
this.client.getSubscriptionId(),
parameters,
accept,
context);
}
/**
* The update operation can be used to update the SKU, encryption, access tier, or tags for a storage account. It
* can also be used to map the account to a custom domain. Only one custom domain is supported per storage account;
* the replacement/change of custom domain is not supported. In order to replace an old custom domain, the old value
* must be cleared/unregistered before a new value can be set. The update of multiple properties is supported. This
* call does not change the storage keys for the account. If you want to change the storage account keys, use the
* regenerate keys operation. The location and name of the storage account cannot be changed after creation.
*
* @param resourceGroupName The name of the resource group within the user's subscription. The name is case
* insensitive.
* @param accountName The name of the storage account within the specified resource group. Storage account names
* must be between 3 and 24 characters in length and use numbers and lower-case letters only.
* @param parameters The parameters to provide for the updated account.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return the storage account on successful completion of {@link Mono}.
*/
@ServiceMethod(returns = ReturnType.SINGLE)
public Mono updateAsync(
String resourceGroupName, String accountName, StorageAccountUpdateParameters parameters) {
return updateWithResponseAsync(resourceGroupName, accountName, parameters)
.flatMap(res -> Mono.justOrEmpty(res.getValue()));
}
/**
* The update operation can be used to update the SKU, encryption, access tier, or tags for a storage account. It
* can also be used to map the account to a custom domain. Only one custom domain is supported per storage account;
* the replacement/change of custom domain is not supported. In order to replace an old custom domain, the old value
* must be cleared/unregistered before a new value can be set. The update of multiple properties is supported. This
* call does not change the storage keys for the account. If you want to change the storage account keys, use the
* regenerate keys operation. The location and name of the storage account cannot be changed after creation.
*
* @param resourceGroupName The name of the resource group within the user's subscription. The name is case
* insensitive.
* @param accountName The name of the storage account within the specified resource group. Storage account names
* must be between 3 and 24 characters in length and use numbers and lower-case letters only.
* @param parameters The parameters to provide for the updated account.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return the storage account.
*/
@ServiceMethod(returns = ReturnType.SINGLE)
public StorageAccountInner update(
String resourceGroupName, String accountName, StorageAccountUpdateParameters parameters) {
return updateAsync(resourceGroupName, accountName, parameters).block();
}
/**
* The update operation can be used to update the SKU, encryption, access tier, or tags for a storage account. It
* can also be used to map the account to a custom domain. Only one custom domain is supported per storage account;
* the replacement/change of custom domain is not supported. In order to replace an old custom domain, the old value
* must be cleared/unregistered before a new value can be set. The update of multiple properties is supported. This
* call does not change the storage keys for the account. If you want to change the storage account keys, use the
* regenerate keys operation. The location and name of the storage account cannot be changed after creation.
*
* @param resourceGroupName The name of the resource group within the user's subscription. The name is case
* insensitive.
* @param accountName The name of the storage account within the specified resource group. Storage account names
* must be between 3 and 24 characters in length and use numbers and lower-case letters only.
* @param parameters The parameters to provide for the updated account.
* @param context The context to associate with this operation.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return the storage account along with {@link Response}.
*/
@ServiceMethod(returns = ReturnType.SINGLE)
public Response updateWithResponse(
String resourceGroupName, String accountName, StorageAccountUpdateParameters parameters, Context context) {
return updateWithResponseAsync(resourceGroupName, accountName, parameters, context).block();
}
/**
* Lists all the storage accounts available under the subscription. Note that storage keys are not returned; use the
* ListKeys operation for this.
*
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return the response from the List Storage Accounts operation along with {@link PagedResponse} on successful
* completion of {@link Mono}.
*/
@ServiceMethod(returns = ReturnType.SINGLE)
private Mono> listSinglePageAsync() {
if (this.client.getEndpoint() == null) {
return Mono
.error(
new IllegalArgumentException(
"Parameter this.client.getEndpoint() is required and cannot be null."));
}
if (this.client.getSubscriptionId() == null) {
return Mono
.error(
new IllegalArgumentException(
"Parameter this.client.getSubscriptionId() is required and cannot be null."));
}
final String accept = "application/json";
return FluxUtil
.withContext(
context ->
service
.list(
this.client.getEndpoint(),
this.client.getApiVersion(),
this.client.getSubscriptionId(),
accept,
context))
.>map(
res ->
new PagedResponseBase<>(
res.getRequest(),
res.getStatusCode(),
res.getHeaders(),
res.getValue().value(),
res.getValue().nextLink(),
null))
.contextWrite(context -> context.putAll(FluxUtil.toReactorContext(this.client.getContext()).readOnly()));
}
/**
* Lists all the storage accounts available under the subscription. Note that storage keys are not returned; use the
* ListKeys operation for this.
*
* @param context The context to associate with this operation.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return the response from the List Storage Accounts operation along with {@link PagedResponse} on successful
* completion of {@link Mono}.
*/
@ServiceMethod(returns = ReturnType.SINGLE)
private Mono> listSinglePageAsync(Context context) {
if (this.client.getEndpoint() == null) {
return Mono
.error(
new IllegalArgumentException(
"Parameter this.client.getEndpoint() is required and cannot be null."));
}
if (this.client.getSubscriptionId() == null) {
return Mono
.error(
new IllegalArgumentException(
"Parameter this.client.getSubscriptionId() is required and cannot be null."));
}
final String accept = "application/json";
context = this.client.mergeContext(context);
return service
.list(
this.client.getEndpoint(),
this.client.getApiVersion(),
this.client.getSubscriptionId(),
accept,
context)
.map(
res ->
new PagedResponseBase<>(
res.getRequest(),
res.getStatusCode(),
res.getHeaders(),
res.getValue().value(),
res.getValue().nextLink(),
null));
}
/**
* Lists all the storage accounts available under the subscription. Note that storage keys are not returned; use the
* ListKeys operation for this.
*
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return the response from the List Storage Accounts operation as paginated response with {@link PagedFlux}.
*/
@ServiceMethod(returns = ReturnType.COLLECTION)
public PagedFlux listAsync() {
return new PagedFlux<>(() -> listSinglePageAsync(), nextLink -> listNextSinglePageAsync(nextLink));
}
/**
* Lists all the storage accounts available under the subscription. Note that storage keys are not returned; use the
* ListKeys operation for this.
*
* @param context The context to associate with this operation.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return the response from the List Storage Accounts operation as paginated response with {@link PagedFlux}.
*/
@ServiceMethod(returns = ReturnType.COLLECTION)
private PagedFlux listAsync(Context context) {
return new PagedFlux<>(
() -> listSinglePageAsync(context), nextLink -> listNextSinglePageAsync(nextLink, context));
}
/**
* Lists all the storage accounts available under the subscription. Note that storage keys are not returned; use the
* ListKeys operation for this.
*
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return the response from the List Storage Accounts operation as paginated response with {@link PagedIterable}.
*/
@ServiceMethod(returns = ReturnType.COLLECTION)
public PagedIterable list() {
return new PagedIterable<>(listAsync());
}
/**
* Lists all the storage accounts available under the subscription. Note that storage keys are not returned; use the
* ListKeys operation for this.
*
* @param context The context to associate with this operation.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return the response from the List Storage Accounts operation as paginated response with {@link PagedIterable}.
*/
@ServiceMethod(returns = ReturnType.COLLECTION)
public PagedIterable list(Context context) {
return new PagedIterable<>(listAsync(context));
}
/**
* Lists all the storage accounts available under the given resource group. Note that storage keys are not returned;
* use the ListKeys operation for this.
*
* @param resourceGroupName The name of the resource group within the user's subscription. The name is case
* insensitive.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return the response from the List Storage Accounts operation along with {@link PagedResponse} on successful
* completion of {@link Mono}.
*/
@ServiceMethod(returns = ReturnType.SINGLE)
private Mono> listByResourceGroupSinglePageAsync(String resourceGroupName) {
if (this.client.getEndpoint() == null) {
return Mono
.error(
new IllegalArgumentException(
"Parameter this.client.getEndpoint() is required and cannot be null."));
}
if (resourceGroupName == null) {
return Mono
.error(new IllegalArgumentException("Parameter resourceGroupName is required and cannot be null."));
}
if (this.client.getSubscriptionId() == null) {
return Mono
.error(
new IllegalArgumentException(
"Parameter this.client.getSubscriptionId() is required and cannot be null."));
}
final String accept = "application/json";
return FluxUtil
.withContext(
context ->
service
.listByResourceGroup(
this.client.getEndpoint(),
resourceGroupName,
this.client.getApiVersion(),
this.client.getSubscriptionId(),
accept,
context))
.>map(
res ->
new PagedResponseBase<>(
res.getRequest(),
res.getStatusCode(),
res.getHeaders(),
res.getValue().value(),
res.getValue().nextLink(),
null))
.contextWrite(context -> context.putAll(FluxUtil.toReactorContext(this.client.getContext()).readOnly()));
}
/**
* Lists all the storage accounts available under the given resource group. Note that storage keys are not returned;
* use the ListKeys operation for this.
*
* @param resourceGroupName The name of the resource group within the user's subscription. The name is case
* insensitive.
* @param context The context to associate with this operation.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return the response from the List Storage Accounts operation along with {@link PagedResponse} on successful
* completion of {@link Mono}.
*/
@ServiceMethod(returns = ReturnType.SINGLE)
private Mono> listByResourceGroupSinglePageAsync(
String resourceGroupName, Context context) {
if (this.client.getEndpoint() == null) {
return Mono
.error(
new IllegalArgumentException(
"Parameter this.client.getEndpoint() is required and cannot be null."));
}
if (resourceGroupName == null) {
return Mono
.error(new IllegalArgumentException("Parameter resourceGroupName is required and cannot be null."));
}
if (this.client.getSubscriptionId() == null) {
return Mono
.error(
new IllegalArgumentException(
"Parameter this.client.getSubscriptionId() is required and cannot be null."));
}
final String accept = "application/json";
context = this.client.mergeContext(context);
return service
.listByResourceGroup(
this.client.getEndpoint(),
resourceGroupName,
this.client.getApiVersion(),
this.client.getSubscriptionId(),
accept,
context)
.map(
res ->
new PagedResponseBase<>(
res.getRequest(),
res.getStatusCode(),
res.getHeaders(),
res.getValue().value(),
res.getValue().nextLink(),
null));
}
/**
* Lists all the storage accounts available under the given resource group. Note that storage keys are not returned;
* use the ListKeys operation for this.
*
* @param resourceGroupName The name of the resource group within the user's subscription. The name is case
* insensitive.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return the response from the List Storage Accounts operation as paginated response with {@link PagedFlux}.
*/
@ServiceMethod(returns = ReturnType.COLLECTION)
public PagedFlux listByResourceGroupAsync(String resourceGroupName) {
return new PagedFlux<>(
() -> listByResourceGroupSinglePageAsync(resourceGroupName),
nextLink -> listByResourceGroupNextSinglePageAsync(nextLink));
}
/**
* Lists all the storage accounts available under the given resource group. Note that storage keys are not returned;
* use the ListKeys operation for this.
*
* @param resourceGroupName The name of the resource group within the user's subscription. The name is case
* insensitive.
* @param context The context to associate with this operation.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return the response from the List Storage Accounts operation as paginated response with {@link PagedFlux}.
*/
@ServiceMethod(returns = ReturnType.COLLECTION)
private PagedFlux listByResourceGroupAsync(String resourceGroupName, Context context) {
return new PagedFlux<>(
() -> listByResourceGroupSinglePageAsync(resourceGroupName, context),
nextLink -> listByResourceGroupNextSinglePageAsync(nextLink, context));
}
/**
* Lists all the storage accounts available under the given resource group. Note that storage keys are not returned;
* use the ListKeys operation for this.
*
* @param resourceGroupName The name of the resource group within the user's subscription. The name is case
* insensitive.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return the response from the List Storage Accounts operation as paginated response with {@link PagedIterable}.
*/
@ServiceMethod(returns = ReturnType.COLLECTION)
public PagedIterable listByResourceGroup(String resourceGroupName) {
return new PagedIterable<>(listByResourceGroupAsync(resourceGroupName));
}
/**
* Lists all the storage accounts available under the given resource group. Note that storage keys are not returned;
* use the ListKeys operation for this.
*
* @param resourceGroupName The name of the resource group within the user's subscription. The name is case
* insensitive.
* @param context The context to associate with this operation.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return the response from the List Storage Accounts operation as paginated response with {@link PagedIterable}.
*/
@ServiceMethod(returns = ReturnType.COLLECTION)
public PagedIterable listByResourceGroup(String resourceGroupName, Context context) {
return new PagedIterable<>(listByResourceGroupAsync(resourceGroupName, context));
}
/**
* Lists the access keys or Kerberos keys (if active directory enabled) for the specified storage account.
*
* @param resourceGroupName The name of the resource group within the user's subscription. The name is case
* insensitive.
* @param accountName The name of the storage account within the specified resource group. Storage account names
* must be between 3 and 24 characters in length and use numbers and lower-case letters only.
* @param expand Specifies type of the key to be listed. Possible value is kerb.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return the response from the ListKeys operation along with {@link Response} on successful completion of {@link
* Mono}.
*/
@ServiceMethod(returns = ReturnType.SINGLE)
public Mono> listKeysWithResponseAsync(
String resourceGroupName, String accountName, ListKeyExpand expand) {
if (this.client.getEndpoint() == null) {
return Mono
.error(
new IllegalArgumentException(
"Parameter this.client.getEndpoint() is required and cannot be null."));
}
if (resourceGroupName == null) {
return Mono
.error(new IllegalArgumentException("Parameter resourceGroupName is required and cannot be null."));
}
if (accountName == null) {
return Mono.error(new IllegalArgumentException("Parameter accountName is required and cannot be null."));
}
if (this.client.getSubscriptionId() == null) {
return Mono
.error(
new IllegalArgumentException(
"Parameter this.client.getSubscriptionId() is required and cannot be null."));
}
final String accept = "application/json";
return FluxUtil
.withContext(
context ->
service
.listKeys(
this.client.getEndpoint(),
resourceGroupName,
accountName,
this.client.getApiVersion(),
this.client.getSubscriptionId(),
expand,
accept,
context))
.contextWrite(context -> context.putAll(FluxUtil.toReactorContext(this.client.getContext()).readOnly()));
}
/**
* Lists the access keys or Kerberos keys (if active directory enabled) for the specified storage account.
*
* @param resourceGroupName The name of the resource group within the user's subscription. The name is case
* insensitive.
* @param accountName The name of the storage account within the specified resource group. Storage account names
* must be between 3 and 24 characters in length and use numbers and lower-case letters only.
* @param expand Specifies type of the key to be listed. Possible value is kerb.
* @param context The context to associate with this operation.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return the response from the ListKeys operation along with {@link Response} on successful completion of {@link
* Mono}.
*/
@ServiceMethod(returns = ReturnType.SINGLE)
private Mono> listKeysWithResponseAsync(
String resourceGroupName, String accountName, ListKeyExpand expand, Context context) {
if (this.client.getEndpoint() == null) {
return Mono
.error(
new IllegalArgumentException(
"Parameter this.client.getEndpoint() is required and cannot be null."));
}
if (resourceGroupName == null) {
return Mono
.error(new IllegalArgumentException("Parameter resourceGroupName is required and cannot be null."));
}
if (accountName == null) {
return Mono.error(new IllegalArgumentException("Parameter accountName is required and cannot be null."));
}
if (this.client.getSubscriptionId() == null) {
return Mono
.error(
new IllegalArgumentException(
"Parameter this.client.getSubscriptionId() is required and cannot be null."));
}
final String accept = "application/json";
context = this.client.mergeContext(context);
return service
.listKeys(
this.client.getEndpoint(),
resourceGroupName,
accountName,
this.client.getApiVersion(),
this.client.getSubscriptionId(),
expand,
accept,
context);
}
/**
* Lists the access keys or Kerberos keys (if active directory enabled) for the specified storage account.
*
* @param resourceGroupName The name of the resource group within the user's subscription. The name is case
* insensitive.
* @param accountName The name of the storage account within the specified resource group. Storage account names
* must be between 3 and 24 characters in length and use numbers and lower-case letters only.
* @param expand Specifies type of the key to be listed. Possible value is kerb.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return the response from the ListKeys operation on successful completion of {@link Mono}.
*/
@ServiceMethod(returns = ReturnType.SINGLE)
public Mono listKeysAsync(
String resourceGroupName, String accountName, ListKeyExpand expand) {
return listKeysWithResponseAsync(resourceGroupName, accountName, expand)
.flatMap(res -> Mono.justOrEmpty(res.getValue()));
}
/**
* Lists the access keys or Kerberos keys (if active directory enabled) for the specified storage account.
*
* @param resourceGroupName The name of the resource group within the user's subscription. The name is case
* insensitive.
* @param accountName The name of the storage account within the specified resource group. Storage account names
* must be between 3 and 24 characters in length and use numbers and lower-case letters only.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return the response from the ListKeys operation on successful completion of {@link Mono}.
*/
@ServiceMethod(returns = ReturnType.SINGLE)
public Mono listKeysAsync(String resourceGroupName, String accountName) {
final ListKeyExpand expand = null;
return listKeysWithResponseAsync(resourceGroupName, accountName, expand)
.flatMap(res -> Mono.justOrEmpty(res.getValue()));
}
/**
* Lists the access keys or Kerberos keys (if active directory enabled) for the specified storage account.
*
* @param resourceGroupName The name of the resource group within the user's subscription. The name is case
* insensitive.
* @param accountName The name of the storage account within the specified resource group. Storage account names
* must be between 3 and 24 characters in length and use numbers and lower-case letters only.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return the response from the ListKeys operation.
*/
@ServiceMethod(returns = ReturnType.SINGLE)
public StorageAccountListKeysResultInner listKeys(String resourceGroupName, String accountName) {
final ListKeyExpand expand = null;
return listKeysAsync(resourceGroupName, accountName, expand).block();
}
/**
* Lists the access keys or Kerberos keys (if active directory enabled) for the specified storage account.
*
* @param resourceGroupName The name of the resource group within the user's subscription. The name is case
* insensitive.
* @param accountName The name of the storage account within the specified resource group. Storage account names
* must be between 3 and 24 characters in length and use numbers and lower-case letters only.
* @param expand Specifies type of the key to be listed. Possible value is kerb.
* @param context The context to associate with this operation.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return the response from the ListKeys operation along with {@link Response}.
*/
@ServiceMethod(returns = ReturnType.SINGLE)
public Response listKeysWithResponse(
String resourceGroupName, String accountName, ListKeyExpand expand, Context context) {
return listKeysWithResponseAsync(resourceGroupName, accountName, expand, context).block();
}
/**
* Regenerates one of the access keys or Kerberos keys for the specified storage account.
*
* @param resourceGroupName The name of the resource group within the user's subscription. The name is case
* insensitive.
* @param accountName The name of the storage account within the specified resource group. Storage account names
* must be between 3 and 24 characters in length and use numbers and lower-case letters only.
* @param regenerateKey Specifies name of the key which should be regenerated -- key1, key2, kerb1, kerb2.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return the response from the ListKeys operation along with {@link Response} on successful completion of {@link
* Mono}.
*/
@ServiceMethod(returns = ReturnType.SINGLE)
public Mono> regenerateKeyWithResponseAsync(
String resourceGroupName, String accountName, StorageAccountRegenerateKeyParameters regenerateKey) {
if (this.client.getEndpoint() == null) {
return Mono
.error(
new IllegalArgumentException(
"Parameter this.client.getEndpoint() is required and cannot be null."));
}
if (resourceGroupName == null) {
return Mono
.error(new IllegalArgumentException("Parameter resourceGroupName is required and cannot be null."));
}
if (accountName == null) {
return Mono.error(new IllegalArgumentException("Parameter accountName is required and cannot be null."));
}
if (this.client.getSubscriptionId() == null) {
return Mono
.error(
new IllegalArgumentException(
"Parameter this.client.getSubscriptionId() is required and cannot be null."));
}
if (regenerateKey == null) {
return Mono.error(new IllegalArgumentException("Parameter regenerateKey is required and cannot be null."));
} else {
regenerateKey.validate();
}
final String accept = "application/json";
return FluxUtil
.withContext(
context ->
service
.regenerateKey(
this.client.getEndpoint(),
resourceGroupName,
accountName,
this.client.getApiVersion(),
this.client.getSubscriptionId(),
regenerateKey,
accept,
context))
.contextWrite(context -> context.putAll(FluxUtil.toReactorContext(this.client.getContext()).readOnly()));
}
/**
* Regenerates one of the access keys or Kerberos keys for the specified storage account.
*
* @param resourceGroupName The name of the resource group within the user's subscription. The name is case
* insensitive.
* @param accountName The name of the storage account within the specified resource group. Storage account names
* must be between 3 and 24 characters in length and use numbers and lower-case letters only.
* @param regenerateKey Specifies name of the key which should be regenerated -- key1, key2, kerb1, kerb2.
* @param context The context to associate with this operation.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return the response from the ListKeys operation along with {@link Response} on successful completion of {@link
* Mono}.
*/
@ServiceMethod(returns = ReturnType.SINGLE)
private Mono> regenerateKeyWithResponseAsync(
String resourceGroupName,
String accountName,
StorageAccountRegenerateKeyParameters regenerateKey,
Context context) {
if (this.client.getEndpoint() == null) {
return Mono
.error(
new IllegalArgumentException(
"Parameter this.client.getEndpoint() is required and cannot be null."));
}
if (resourceGroupName == null) {
return Mono
.error(new IllegalArgumentException("Parameter resourceGroupName is required and cannot be null."));
}
if (accountName == null) {
return Mono.error(new IllegalArgumentException("Parameter accountName is required and cannot be null."));
}
if (this.client.getSubscriptionId() == null) {
return Mono
.error(
new IllegalArgumentException(
"Parameter this.client.getSubscriptionId() is required and cannot be null."));
}
if (regenerateKey == null) {
return Mono.error(new IllegalArgumentException("Parameter regenerateKey is required and cannot be null."));
} else {
regenerateKey.validate();
}
final String accept = "application/json";
context = this.client.mergeContext(context);
return service
.regenerateKey(
this.client.getEndpoint(),
resourceGroupName,
accountName,
this.client.getApiVersion(),
this.client.getSubscriptionId(),
regenerateKey,
accept,
context);
}
/**
* Regenerates one of the access keys or Kerberos keys for the specified storage account.
*
* @param resourceGroupName The name of the resource group within the user's subscription. The name is case
* insensitive.
* @param accountName The name of the storage account within the specified resource group. Storage account names
* must be between 3 and 24 characters in length and use numbers and lower-case letters only.
* @param regenerateKey Specifies name of the key which should be regenerated -- key1, key2, kerb1, kerb2.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return the response from the ListKeys operation on successful completion of {@link Mono}.
*/
@ServiceMethod(returns = ReturnType.SINGLE)
public Mono regenerateKeyAsync(
String resourceGroupName, String accountName, StorageAccountRegenerateKeyParameters regenerateKey) {
return regenerateKeyWithResponseAsync(resourceGroupName, accountName, regenerateKey)
.flatMap(res -> Mono.justOrEmpty(res.getValue()));
}
/**
* Regenerates one of the access keys or Kerberos keys for the specified storage account.
*
* @param resourceGroupName The name of the resource group within the user's subscription. The name is case
* insensitive.
* @param accountName The name of the storage account within the specified resource group. Storage account names
* must be between 3 and 24 characters in length and use numbers and lower-case letters only.
* @param regenerateKey Specifies name of the key which should be regenerated -- key1, key2, kerb1, kerb2.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return the response from the ListKeys operation.
*/
@ServiceMethod(returns = ReturnType.SINGLE)
public StorageAccountListKeysResultInner regenerateKey(
String resourceGroupName, String accountName, StorageAccountRegenerateKeyParameters regenerateKey) {
return regenerateKeyAsync(resourceGroupName, accountName, regenerateKey).block();
}
/**
* Regenerates one of the access keys or Kerberos keys for the specified storage account.
*
* @param resourceGroupName The name of the resource group within the user's subscription. The name is case
* insensitive.
* @param accountName The name of the storage account within the specified resource group. Storage account names
* must be between 3 and 24 characters in length and use numbers and lower-case letters only.
* @param regenerateKey Specifies name of the key which should be regenerated -- key1, key2, kerb1, kerb2.
* @param context The context to associate with this operation.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return the response from the ListKeys operation along with {@link Response}.
*/
@ServiceMethod(returns = ReturnType.SINGLE)
public Response regenerateKeyWithResponse(
String resourceGroupName,
String accountName,
StorageAccountRegenerateKeyParameters regenerateKey,
Context context) {
return regenerateKeyWithResponseAsync(resourceGroupName, accountName, regenerateKey, context).block();
}
/**
* List SAS credentials of a storage account.
*
* @param resourceGroupName The name of the resource group within the user's subscription. The name is case
* insensitive.
* @param accountName The name of the storage account within the specified resource group. Storage account names
* must be between 3 and 24 characters in length and use numbers and lower-case letters only.
* @param parameters The parameters to provide to list SAS credentials for the storage account.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return the List SAS credentials operation response along with {@link Response} on successful completion of
* {@link Mono}.
*/
@ServiceMethod(returns = ReturnType.SINGLE)
public Mono> listAccountSasWithResponseAsync(
String resourceGroupName, String accountName, AccountSasParameters parameters) {
if (this.client.getEndpoint() == null) {
return Mono
.error(
new IllegalArgumentException(
"Parameter this.client.getEndpoint() is required and cannot be null."));
}
if (resourceGroupName == null) {
return Mono
.error(new IllegalArgumentException("Parameter resourceGroupName is required and cannot be null."));
}
if (accountName == null) {
return Mono.error(new IllegalArgumentException("Parameter accountName is required and cannot be null."));
}
if (this.client.getSubscriptionId() == null) {
return Mono
.error(
new IllegalArgumentException(
"Parameter this.client.getSubscriptionId() is required and cannot be null."));
}
if (parameters == null) {
return Mono.error(new IllegalArgumentException("Parameter parameters is required and cannot be null."));
} else {
parameters.validate();
}
final String accept = "application/json";
return FluxUtil
.withContext(
context ->
service
.listAccountSas(
this.client.getEndpoint(),
resourceGroupName,
accountName,
this.client.getApiVersion(),
this.client.getSubscriptionId(),
parameters,
accept,
context))
.contextWrite(context -> context.putAll(FluxUtil.toReactorContext(this.client.getContext()).readOnly()));
}
/**
* List SAS credentials of a storage account.
*
* @param resourceGroupName The name of the resource group within the user's subscription. The name is case
* insensitive.
* @param accountName The name of the storage account within the specified resource group. Storage account names
* must be between 3 and 24 characters in length and use numbers and lower-case letters only.
* @param parameters The parameters to provide to list SAS credentials for the storage account.
* @param context The context to associate with this operation.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return the List SAS credentials operation response along with {@link Response} on successful completion of
* {@link Mono}.
*/
@ServiceMethod(returns = ReturnType.SINGLE)
private Mono> listAccountSasWithResponseAsync(
String resourceGroupName, String accountName, AccountSasParameters parameters, Context context) {
if (this.client.getEndpoint() == null) {
return Mono
.error(
new IllegalArgumentException(
"Parameter this.client.getEndpoint() is required and cannot be null."));
}
if (resourceGroupName == null) {
return Mono
.error(new IllegalArgumentException("Parameter resourceGroupName is required and cannot be null."));
}
if (accountName == null) {
return Mono.error(new IllegalArgumentException("Parameter accountName is required and cannot be null."));
}
if (this.client.getSubscriptionId() == null) {
return Mono
.error(
new IllegalArgumentException(
"Parameter this.client.getSubscriptionId() is required and cannot be null."));
}
if (parameters == null) {
return Mono.error(new IllegalArgumentException("Parameter parameters is required and cannot be null."));
} else {
parameters.validate();
}
final String accept = "application/json";
context = this.client.mergeContext(context);
return service
.listAccountSas(
this.client.getEndpoint(),
resourceGroupName,
accountName,
this.client.getApiVersion(),
this.client.getSubscriptionId(),
parameters,
accept,
context);
}
/**
* List SAS credentials of a storage account.
*
* @param resourceGroupName The name of the resource group within the user's subscription. The name is case
* insensitive.
* @param accountName The name of the storage account within the specified resource group. Storage account names
* must be between 3 and 24 characters in length and use numbers and lower-case letters only.
* @param parameters The parameters to provide to list SAS credentials for the storage account.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return the List SAS credentials operation response on successful completion of {@link Mono}.
*/
@ServiceMethod(returns = ReturnType.SINGLE)
public Mono listAccountSasAsync(
String resourceGroupName, String accountName, AccountSasParameters parameters) {
return listAccountSasWithResponseAsync(resourceGroupName, accountName, parameters)
.flatMap(res -> Mono.justOrEmpty(res.getValue()));
}
/**
* List SAS credentials of a storage account.
*
* @param resourceGroupName The name of the resource group within the user's subscription. The name is case
* insensitive.
* @param accountName The name of the storage account within the specified resource group. Storage account names
* must be between 3 and 24 characters in length and use numbers and lower-case letters only.
* @param parameters The parameters to provide to list SAS credentials for the storage account.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return the List SAS credentials operation response.
*/
@ServiceMethod(returns = ReturnType.SINGLE)
public ListAccountSasResponseInner listAccountSas(
String resourceGroupName, String accountName, AccountSasParameters parameters) {
return listAccountSasAsync(resourceGroupName, accountName, parameters).block();
}
/**
* List SAS credentials of a storage account.
*
* @param resourceGroupName The name of the resource group within the user's subscription. The name is case
* insensitive.
* @param accountName The name of the storage account within the specified resource group. Storage account names
* must be between 3 and 24 characters in length and use numbers and lower-case letters only.
* @param parameters The parameters to provide to list SAS credentials for the storage account.
* @param context The context to associate with this operation.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return the List SAS credentials operation response along with {@link Response}.
*/
@ServiceMethod(returns = ReturnType.SINGLE)
public Response listAccountSasWithResponse(
String resourceGroupName, String accountName, AccountSasParameters parameters, Context context) {
return listAccountSasWithResponseAsync(resourceGroupName, accountName, parameters, context).block();
}
/**
* List service SAS credentials of a specific resource.
*
* @param resourceGroupName The name of the resource group within the user's subscription. The name is case
* insensitive.
* @param accountName The name of the storage account within the specified resource group. Storage account names
* must be between 3 and 24 characters in length and use numbers and lower-case letters only.
* @param parameters The parameters to provide to list service SAS credentials.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return the List service SAS credentials operation response along with {@link Response} on successful completion
* of {@link Mono}.
*/
@ServiceMethod(returns = ReturnType.SINGLE)
public Mono> listServiceSasWithResponseAsync(
String resourceGroupName, String accountName, ServiceSasParameters parameters) {
if (this.client.getEndpoint() == null) {
return Mono
.error(
new IllegalArgumentException(
"Parameter this.client.getEndpoint() is required and cannot be null."));
}
if (resourceGroupName == null) {
return Mono
.error(new IllegalArgumentException("Parameter resourceGroupName is required and cannot be null."));
}
if (accountName == null) {
return Mono.error(new IllegalArgumentException("Parameter accountName is required and cannot be null."));
}
if (this.client.getSubscriptionId() == null) {
return Mono
.error(
new IllegalArgumentException(
"Parameter this.client.getSubscriptionId() is required and cannot be null."));
}
if (parameters == null) {
return Mono.error(new IllegalArgumentException("Parameter parameters is required and cannot be null."));
} else {
parameters.validate();
}
final String accept = "application/json";
return FluxUtil
.withContext(
context ->
service
.listServiceSas(
this.client.getEndpoint(),
resourceGroupName,
accountName,
this.client.getApiVersion(),
this.client.getSubscriptionId(),
parameters,
accept,
context))
.contextWrite(context -> context.putAll(FluxUtil.toReactorContext(this.client.getContext()).readOnly()));
}
/**
* List service SAS credentials of a specific resource.
*
* @param resourceGroupName The name of the resource group within the user's subscription. The name is case
* insensitive.
* @param accountName The name of the storage account within the specified resource group. Storage account names
* must be between 3 and 24 characters in length and use numbers and lower-case letters only.
* @param parameters The parameters to provide to list service SAS credentials.
* @param context The context to associate with this operation.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return the List service SAS credentials operation response along with {@link Response} on successful completion
* of {@link Mono}.
*/
@ServiceMethod(returns = ReturnType.SINGLE)
private Mono> listServiceSasWithResponseAsync(
String resourceGroupName, String accountName, ServiceSasParameters parameters, Context context) {
if (this.client.getEndpoint() == null) {
return Mono
.error(
new IllegalArgumentException(
"Parameter this.client.getEndpoint() is required and cannot be null."));
}
if (resourceGroupName == null) {
return Mono
.error(new IllegalArgumentException("Parameter resourceGroupName is required and cannot be null."));
}
if (accountName == null) {
return Mono.error(new IllegalArgumentException("Parameter accountName is required and cannot be null."));
}
if (this.client.getSubscriptionId() == null) {
return Mono
.error(
new IllegalArgumentException(
"Parameter this.client.getSubscriptionId() is required and cannot be null."));
}
if (parameters == null) {
return Mono.error(new IllegalArgumentException("Parameter parameters is required and cannot be null."));
} else {
parameters.validate();
}
final String accept = "application/json";
context = this.client.mergeContext(context);
return service
.listServiceSas(
this.client.getEndpoint(),
resourceGroupName,
accountName,
this.client.getApiVersion(),
this.client.getSubscriptionId(),
parameters,
accept,
context);
}
/**
* List service SAS credentials of a specific resource.
*
* @param resourceGroupName The name of the resource group within the user's subscription. The name is case
* insensitive.
* @param accountName The name of the storage account within the specified resource group. Storage account names
* must be between 3 and 24 characters in length and use numbers and lower-case letters only.
* @param parameters The parameters to provide to list service SAS credentials.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return the List service SAS credentials operation response on successful completion of {@link Mono}.
*/
@ServiceMethod(returns = ReturnType.SINGLE)
public Mono listServiceSasAsync(
String resourceGroupName, String accountName, ServiceSasParameters parameters) {
return listServiceSasWithResponseAsync(resourceGroupName, accountName, parameters)
.flatMap(res -> Mono.justOrEmpty(res.getValue()));
}
/**
* List service SAS credentials of a specific resource.
*
* @param resourceGroupName The name of the resource group within the user's subscription. The name is case
* insensitive.
* @param accountName The name of the storage account within the specified resource group. Storage account names
* must be between 3 and 24 characters in length and use numbers and lower-case letters only.
* @param parameters The parameters to provide to list service SAS credentials.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return the List service SAS credentials operation response.
*/
@ServiceMethod(returns = ReturnType.SINGLE)
public ListServiceSasResponseInner listServiceSas(
String resourceGroupName, String accountName, ServiceSasParameters parameters) {
return listServiceSasAsync(resourceGroupName, accountName, parameters).block();
}
/**
* List service SAS credentials of a specific resource.
*
* @param resourceGroupName The name of the resource group within the user's subscription. The name is case
* insensitive.
* @param accountName The name of the storage account within the specified resource group. Storage account names
* must be between 3 and 24 characters in length and use numbers and lower-case letters only.
* @param parameters The parameters to provide to list service SAS credentials.
* @param context The context to associate with this operation.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return the List service SAS credentials operation response along with {@link Response}.
*/
@ServiceMethod(returns = ReturnType.SINGLE)
public Response listServiceSasWithResponse(
String resourceGroupName, String accountName, ServiceSasParameters parameters, Context context) {
return listServiceSasWithResponseAsync(resourceGroupName, accountName, parameters, context).block();
}
/**
* A failover request can be triggered for a storage account in the event a primary endpoint becomes unavailable for
* any reason. The failover occurs from the storage account's primary cluster to the secondary cluster for RA-GRS
* accounts. The secondary cluster will become primary after failover and the account is converted to LRS. In the
* case of a Planned Failover, the primary and secondary clusters are swapped after failover and the account remains
* geo-replicated. Failover should continue to be used in the event of availability issues as Planned failover is
* only available while the primary and secondary endpoints are available. The primary use case of a Planned
* Failover is disaster recovery testing drills. This type of failover is invoked by setting FailoverType parameter
* to 'Planned'. Learn more about the failover options here-
* https://learn.microsoft.com/en-us/azure/storage/common/storage-disaster-recovery-guidance.
*
* @param resourceGroupName The name of the resource group within the user's subscription. The name is case
* insensitive.
* @param accountName The name of the storage account within the specified resource group. Storage account names
* must be between 3 and 24 characters in length and use numbers and lower-case letters only.
* @param failoverType The parameter is set to 'Planned' to indicate whether a Planned failover is requested.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return the {@link Response} on successful completion of {@link Mono}.
*/
@ServiceMethod(returns = ReturnType.SINGLE)
public Mono>> failoverWithResponseAsync(
String resourceGroupName, String accountName, FailoverType failoverType) {
if (this.client.getEndpoint() == null) {
return Mono
.error(
new IllegalArgumentException(
"Parameter this.client.getEndpoint() is required and cannot be null."));
}
if (resourceGroupName == null) {
return Mono
.error(new IllegalArgumentException("Parameter resourceGroupName is required and cannot be null."));
}
if (accountName == null) {
return Mono.error(new IllegalArgumentException("Parameter accountName is required and cannot be null."));
}
if (this.client.getSubscriptionId() == null) {
return Mono
.error(
new IllegalArgumentException(
"Parameter this.client.getSubscriptionId() is required and cannot be null."));
}
return FluxUtil
.withContext(
context ->
service
.failover(
this.client.getEndpoint(),
resourceGroupName,
accountName,
this.client.getApiVersion(),
this.client.getSubscriptionId(),
failoverType,
context))
.contextWrite(context -> context.putAll(FluxUtil.toReactorContext(this.client.getContext()).readOnly()));
}
/**
* A failover request can be triggered for a storage account in the event a primary endpoint becomes unavailable for
* any reason. The failover occurs from the storage account's primary cluster to the secondary cluster for RA-GRS
* accounts. The secondary cluster will become primary after failover and the account is converted to LRS. In the
* case of a Planned Failover, the primary and secondary clusters are swapped after failover and the account remains
* geo-replicated. Failover should continue to be used in the event of availability issues as Planned failover is
* only available while the primary and secondary endpoints are available. The primary use case of a Planned
* Failover is disaster recovery testing drills. This type of failover is invoked by setting FailoverType parameter
* to 'Planned'. Learn more about the failover options here-
* https://learn.microsoft.com/en-us/azure/storage/common/storage-disaster-recovery-guidance.
*
* @param resourceGroupName The name of the resource group within the user's subscription. The name is case
* insensitive.
* @param accountName The name of the storage account within the specified resource group. Storage account names
* must be between 3 and 24 characters in length and use numbers and lower-case letters only.
* @param failoverType The parameter is set to 'Planned' to indicate whether a Planned failover is requested.
* @param context The context to associate with this operation.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return the {@link Response} on successful completion of {@link Mono}.
*/
@ServiceMethod(returns = ReturnType.SINGLE)
private Mono>> failoverWithResponseAsync(
String resourceGroupName, String accountName, FailoverType failoverType, Context context) {
if (this.client.getEndpoint() == null) {
return Mono
.error(
new IllegalArgumentException(
"Parameter this.client.getEndpoint() is required and cannot be null."));
}
if (resourceGroupName == null) {
return Mono
.error(new IllegalArgumentException("Parameter resourceGroupName is required and cannot be null."));
}
if (accountName == null) {
return Mono.error(new IllegalArgumentException("Parameter accountName is required and cannot be null."));
}
if (this.client.getSubscriptionId() == null) {
return Mono
.error(
new IllegalArgumentException(
"Parameter this.client.getSubscriptionId() is required and cannot be null."));
}
context = this.client.mergeContext(context);
return service
.failover(
this.client.getEndpoint(),
resourceGroupName,
accountName,
this.client.getApiVersion(),
this.client.getSubscriptionId(),
failoverType,
context);
}
/**
* A failover request can be triggered for a storage account in the event a primary endpoint becomes unavailable for
* any reason. The failover occurs from the storage account's primary cluster to the secondary cluster for RA-GRS
* accounts. The secondary cluster will become primary after failover and the account is converted to LRS. In the
* case of a Planned Failover, the primary and secondary clusters are swapped after failover and the account remains
* geo-replicated. Failover should continue to be used in the event of availability issues as Planned failover is
* only available while the primary and secondary endpoints are available. The primary use case of a Planned
* Failover is disaster recovery testing drills. This type of failover is invoked by setting FailoverType parameter
* to 'Planned'. Learn more about the failover options here-
* https://learn.microsoft.com/en-us/azure/storage/common/storage-disaster-recovery-guidance.
*
* @param resourceGroupName The name of the resource group within the user's subscription. The name is case
* insensitive.
* @param accountName The name of the storage account within the specified resource group. Storage account names
* must be between 3 and 24 characters in length and use numbers and lower-case letters only.
* @param failoverType The parameter is set to 'Planned' to indicate whether a Planned failover is requested.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return the {@link PollerFlux} for polling of long-running operation.
*/
@ServiceMethod(returns = ReturnType.LONG_RUNNING_OPERATION)
public PollerFlux, Void> beginFailoverAsync(
String resourceGroupName, String accountName, FailoverType failoverType) {
Mono>> mono = failoverWithResponseAsync(resourceGroupName, accountName, failoverType);
return this
.client
.getLroResult(
mono, this.client.getHttpPipeline(), Void.class, Void.class, this.client.getContext());
}
/**
* A failover request can be triggered for a storage account in the event a primary endpoint becomes unavailable for
* any reason. The failover occurs from the storage account's primary cluster to the secondary cluster for RA-GRS
* accounts. The secondary cluster will become primary after failover and the account is converted to LRS. In the
* case of a Planned Failover, the primary and secondary clusters are swapped after failover and the account remains
* geo-replicated. Failover should continue to be used in the event of availability issues as Planned failover is
* only available while the primary and secondary endpoints are available. The primary use case of a Planned
* Failover is disaster recovery testing drills. This type of failover is invoked by setting FailoverType parameter
* to 'Planned'. Learn more about the failover options here-
* https://learn.microsoft.com/en-us/azure/storage/common/storage-disaster-recovery-guidance.
*
* @param resourceGroupName The name of the resource group within the user's subscription. The name is case
* insensitive.
* @param accountName The name of the storage account within the specified resource group. Storage account names
* must be between 3 and 24 characters in length and use numbers and lower-case letters only.
* @param failoverType The parameter is set to 'Planned' to indicate whether a Planned failover is requested.
* @param context The context to associate with this operation.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return the {@link PollerFlux} for polling of long-running operation.
*/
@ServiceMethod(returns = ReturnType.LONG_RUNNING_OPERATION)
private PollerFlux, Void> beginFailoverAsync(
String resourceGroupName, String accountName, FailoverType failoverType, Context context) {
context = this.client.mergeContext(context);
Mono>> mono =
failoverWithResponseAsync(resourceGroupName, accountName, failoverType, context);
return this
.client
.getLroResult(mono, this.client.getHttpPipeline(), Void.class, Void.class, context);
}
/**
* A failover request can be triggered for a storage account in the event a primary endpoint becomes unavailable for
* any reason. The failover occurs from the storage account's primary cluster to the secondary cluster for RA-GRS
* accounts. The secondary cluster will become primary after failover and the account is converted to LRS. In the
* case of a Planned Failover, the primary and secondary clusters are swapped after failover and the account remains
* geo-replicated. Failover should continue to be used in the event of availability issues as Planned failover is
* only available while the primary and secondary endpoints are available. The primary use case of a Planned
* Failover is disaster recovery testing drills. This type of failover is invoked by setting FailoverType parameter
* to 'Planned'. Learn more about the failover options here-
* https://learn.microsoft.com/en-us/azure/storage/common/storage-disaster-recovery-guidance.
*
* @param resourceGroupName The name of the resource group within the user's subscription. The name is case
* insensitive.
* @param accountName The name of the storage account within the specified resource group. Storage account names
* must be between 3 and 24 characters in length and use numbers and lower-case letters only.
* @param failoverType The parameter is set to 'Planned' to indicate whether a Planned failover is requested.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return the {@link SyncPoller} for polling of long-running operation.
*/
@ServiceMethod(returns = ReturnType.LONG_RUNNING_OPERATION)
public SyncPoller, Void> beginFailover(
String resourceGroupName, String accountName, FailoverType failoverType) {
return beginFailoverAsync(resourceGroupName, accountName, failoverType).getSyncPoller();
}
/**
* A failover request can be triggered for a storage account in the event a primary endpoint becomes unavailable for
* any reason. The failover occurs from the storage account's primary cluster to the secondary cluster for RA-GRS
* accounts. The secondary cluster will become primary after failover and the account is converted to LRS. In the
* case of a Planned Failover, the primary and secondary clusters are swapped after failover and the account remains
* geo-replicated. Failover should continue to be used in the event of availability issues as Planned failover is
* only available while the primary and secondary endpoints are available. The primary use case of a Planned
* Failover is disaster recovery testing drills. This type of failover is invoked by setting FailoverType parameter
* to 'Planned'. Learn more about the failover options here-
* https://learn.microsoft.com/en-us/azure/storage/common/storage-disaster-recovery-guidance.
*
* @param resourceGroupName The name of the resource group within the user's subscription. The name is case
* insensitive.
* @param accountName The name of the storage account within the specified resource group. Storage account names
* must be between 3 and 24 characters in length and use numbers and lower-case letters only.
* @param failoverType The parameter is set to 'Planned' to indicate whether a Planned failover is requested.
* @param context The context to associate with this operation.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return the {@link SyncPoller} for polling of long-running operation.
*/
@ServiceMethod(returns = ReturnType.LONG_RUNNING_OPERATION)
public SyncPoller, Void> beginFailover(
String resourceGroupName, String accountName, FailoverType failoverType, Context context) {
return beginFailoverAsync(resourceGroupName, accountName, failoverType, context).getSyncPoller();
}
/**
* A failover request can be triggered for a storage account in the event a primary endpoint becomes unavailable for
* any reason. The failover occurs from the storage account's primary cluster to the secondary cluster for RA-GRS
* accounts. The secondary cluster will become primary after failover and the account is converted to LRS. In the
* case of a Planned Failover, the primary and secondary clusters are swapped after failover and the account remains
* geo-replicated. Failover should continue to be used in the event of availability issues as Planned failover is
* only available while the primary and secondary endpoints are available. The primary use case of a Planned
* Failover is disaster recovery testing drills. This type of failover is invoked by setting FailoverType parameter
* to 'Planned'. Learn more about the failover options here-
* https://learn.microsoft.com/en-us/azure/storage/common/storage-disaster-recovery-guidance.
*
* @param resourceGroupName The name of the resource group within the user's subscription. The name is case
* insensitive.
* @param accountName The name of the storage account within the specified resource group. Storage account names
* must be between 3 and 24 characters in length and use numbers and lower-case letters only.
* @param failoverType The parameter is set to 'Planned' to indicate whether a Planned failover is requested.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return A {@link Mono} that completes when a successful response is received.
*/
@ServiceMethod(returns = ReturnType.SINGLE)
public Mono failoverAsync(String resourceGroupName, String accountName, FailoverType failoverType) {
return beginFailoverAsync(resourceGroupName, accountName, failoverType)
.last()
.flatMap(this.client::getLroFinalResultOrError);
}
/**
* A failover request can be triggered for a storage account in the event a primary endpoint becomes unavailable for
* any reason. The failover occurs from the storage account's primary cluster to the secondary cluster for RA-GRS
* accounts. The secondary cluster will become primary after failover and the account is converted to LRS. In the
* case of a Planned Failover, the primary and secondary clusters are swapped after failover and the account remains
* geo-replicated. Failover should continue to be used in the event of availability issues as Planned failover is
* only available while the primary and secondary endpoints are available. The primary use case of a Planned
* Failover is disaster recovery testing drills. This type of failover is invoked by setting FailoverType parameter
* to 'Planned'. Learn more about the failover options here-
* https://learn.microsoft.com/en-us/azure/storage/common/storage-disaster-recovery-guidance.
*
* @param resourceGroupName The name of the resource group within the user's subscription. The name is case
* insensitive.
* @param accountName The name of the storage account within the specified resource group. Storage account names
* must be between 3 and 24 characters in length and use numbers and lower-case letters only.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return A {@link Mono} that completes when a successful response is received.
*/
@ServiceMethod(returns = ReturnType.SINGLE)
public Mono failoverAsync(String resourceGroupName, String accountName) {
final FailoverType failoverType = null;
return beginFailoverAsync(resourceGroupName, accountName, failoverType)
.last()
.flatMap(this.client::getLroFinalResultOrError);
}
/**
* A failover request can be triggered for a storage account in the event a primary endpoint becomes unavailable for
* any reason. The failover occurs from the storage account's primary cluster to the secondary cluster for RA-GRS
* accounts. The secondary cluster will become primary after failover and the account is converted to LRS. In the
* case of a Planned Failover, the primary and secondary clusters are swapped after failover and the account remains
* geo-replicated. Failover should continue to be used in the event of availability issues as Planned failover is
* only available while the primary and secondary endpoints are available. The primary use case of a Planned
* Failover is disaster recovery testing drills. This type of failover is invoked by setting FailoverType parameter
* to 'Planned'. Learn more about the failover options here-
* https://learn.microsoft.com/en-us/azure/storage/common/storage-disaster-recovery-guidance.
*
* @param resourceGroupName The name of the resource group within the user's subscription. The name is case
* insensitive.
* @param accountName The name of the storage account within the specified resource group. Storage account names
* must be between 3 and 24 characters in length and use numbers and lower-case letters only.
* @param failoverType The parameter is set to 'Planned' to indicate whether a Planned failover is requested.
* @param context The context to associate with this operation.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return A {@link Mono} that completes when a successful response is received.
*/
@ServiceMethod(returns = ReturnType.SINGLE)
private Mono failoverAsync(
String resourceGroupName, String accountName, FailoverType failoverType, Context context) {
return beginFailoverAsync(resourceGroupName, accountName, failoverType, context)
.last()
.flatMap(this.client::getLroFinalResultOrError);
}
/**
* A failover request can be triggered for a storage account in the event a primary endpoint becomes unavailable for
* any reason. The failover occurs from the storage account's primary cluster to the secondary cluster for RA-GRS
* accounts. The secondary cluster will become primary after failover and the account is converted to LRS. In the
* case of a Planned Failover, the primary and secondary clusters are swapped after failover and the account remains
* geo-replicated. Failover should continue to be used in the event of availability issues as Planned failover is
* only available while the primary and secondary endpoints are available. The primary use case of a Planned
* Failover is disaster recovery testing drills. This type of failover is invoked by setting FailoverType parameter
* to 'Planned'. Learn more about the failover options here-
* https://learn.microsoft.com/en-us/azure/storage/common/storage-disaster-recovery-guidance.
*
* @param resourceGroupName The name of the resource group within the user's subscription. The name is case
* insensitive.
* @param accountName The name of the storage account within the specified resource group. Storage account names
* must be between 3 and 24 characters in length and use numbers and lower-case letters only.
* @param failoverType The parameter is set to 'Planned' to indicate whether a Planned failover is requested.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
*/
@ServiceMethod(returns = ReturnType.SINGLE)
public void failover(String resourceGroupName, String accountName, FailoverType failoverType) {
failoverAsync(resourceGroupName, accountName, failoverType).block();
}
/**
* A failover request can be triggered for a storage account in the event a primary endpoint becomes unavailable for
* any reason. The failover occurs from the storage account's primary cluster to the secondary cluster for RA-GRS
* accounts. The secondary cluster will become primary after failover and the account is converted to LRS. In the
* case of a Planned Failover, the primary and secondary clusters are swapped after failover and the account remains
* geo-replicated. Failover should continue to be used in the event of availability issues as Planned failover is
* only available while the primary and secondary endpoints are available. The primary use case of a Planned
* Failover is disaster recovery testing drills. This type of failover is invoked by setting FailoverType parameter
* to 'Planned'. Learn more about the failover options here-
* https://learn.microsoft.com/en-us/azure/storage/common/storage-disaster-recovery-guidance.
*
* @param resourceGroupName The name of the resource group within the user's subscription. The name is case
* insensitive.
* @param accountName The name of the storage account within the specified resource group. Storage account names
* must be between 3 and 24 characters in length and use numbers and lower-case letters only.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
*/
@ServiceMethod(returns = ReturnType.SINGLE)
public void failover(String resourceGroupName, String accountName) {
final FailoverType failoverType = null;
failoverAsync(resourceGroupName, accountName, failoverType).block();
}
/**
* A failover request can be triggered for a storage account in the event a primary endpoint becomes unavailable for
* any reason. The failover occurs from the storage account's primary cluster to the secondary cluster for RA-GRS
* accounts. The secondary cluster will become primary after failover and the account is converted to LRS. In the
* case of a Planned Failover, the primary and secondary clusters are swapped after failover and the account remains
* geo-replicated. Failover should continue to be used in the event of availability issues as Planned failover is
* only available while the primary and secondary endpoints are available. The primary use case of a Planned
* Failover is disaster recovery testing drills. This type of failover is invoked by setting FailoverType parameter
* to 'Planned'. Learn more about the failover options here-
* https://learn.microsoft.com/en-us/azure/storage/common/storage-disaster-recovery-guidance.
*
* @param resourceGroupName The name of the resource group within the user's subscription. The name is case
* insensitive.
* @param accountName The name of the storage account within the specified resource group. Storage account names
* must be between 3 and 24 characters in length and use numbers and lower-case letters only.
* @param failoverType The parameter is set to 'Planned' to indicate whether a Planned failover is requested.
* @param context The context to associate with this operation.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
*/
@ServiceMethod(returns = ReturnType.SINGLE)
public void failover(String resourceGroupName, String accountName, FailoverType failoverType, Context context) {
failoverAsync(resourceGroupName, accountName, failoverType, context).block();
}
/**
* Live Migration of storage account to enable Hns.
*
* @param resourceGroupName The name of the resource group within the user's subscription. The name is case
* insensitive.
* @param accountName The name of the storage account within the specified resource group. Storage account names
* must be between 3 and 24 characters in length and use numbers and lower-case letters only.
* @param requestType Required. Hierarchical namespace migration type can either be a hierarchical namespace
* validation request 'HnsOnValidationRequest' or a hydration request 'HnsOnHydrationRequest'. The validation
* request will validate the migration whereas the hydration request will migrate the account.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return the {@link Response} on successful completion of {@link Mono}.
*/
@ServiceMethod(returns = ReturnType.SINGLE)
public Mono>> hierarchicalNamespaceMigrationWithResponseAsync(
String resourceGroupName, String accountName, String requestType) {
if (this.client.getEndpoint() == null) {
return Mono
.error(
new IllegalArgumentException(
"Parameter this.client.getEndpoint() is required and cannot be null."));
}
if (resourceGroupName == null) {
return Mono
.error(new IllegalArgumentException("Parameter resourceGroupName is required and cannot be null."));
}
if (accountName == null) {
return Mono.error(new IllegalArgumentException("Parameter accountName is required and cannot be null."));
}
if (this.client.getSubscriptionId() == null) {
return Mono
.error(
new IllegalArgumentException(
"Parameter this.client.getSubscriptionId() is required and cannot be null."));
}
if (requestType == null) {
return Mono.error(new IllegalArgumentException("Parameter requestType is required and cannot be null."));
}
final String accept = "application/json";
return FluxUtil
.withContext(
context ->
service
.hierarchicalNamespaceMigration(
this.client.getEndpoint(),
resourceGroupName,
accountName,
this.client.getApiVersion(),
this.client.getSubscriptionId(),
requestType,
accept,
context))
.contextWrite(context -> context.putAll(FluxUtil.toReactorContext(this.client.getContext()).readOnly()));
}
/**
* Live Migration of storage account to enable Hns.
*
* @param resourceGroupName The name of the resource group within the user's subscription. The name is case
* insensitive.
* @param accountName The name of the storage account within the specified resource group. Storage account names
* must be between 3 and 24 characters in length and use numbers and lower-case letters only.
* @param requestType Required. Hierarchical namespace migration type can either be a hierarchical namespace
* validation request 'HnsOnValidationRequest' or a hydration request 'HnsOnHydrationRequest'. The validation
* request will validate the migration whereas the hydration request will migrate the account.
* @param context The context to associate with this operation.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return the {@link Response} on successful completion of {@link Mono}.
*/
@ServiceMethod(returns = ReturnType.SINGLE)
private Mono>> hierarchicalNamespaceMigrationWithResponseAsync(
String resourceGroupName, String accountName, String requestType, Context context) {
if (this.client.getEndpoint() == null) {
return Mono
.error(
new IllegalArgumentException(
"Parameter this.client.getEndpoint() is required and cannot be null."));
}
if (resourceGroupName == null) {
return Mono
.error(new IllegalArgumentException("Parameter resourceGroupName is required and cannot be null."));
}
if (accountName == null) {
return Mono.error(new IllegalArgumentException("Parameter accountName is required and cannot be null."));
}
if (this.client.getSubscriptionId() == null) {
return Mono
.error(
new IllegalArgumentException(
"Parameter this.client.getSubscriptionId() is required and cannot be null."));
}
if (requestType == null) {
return Mono.error(new IllegalArgumentException("Parameter requestType is required and cannot be null."));
}
final String accept = "application/json";
context = this.client.mergeContext(context);
return service
.hierarchicalNamespaceMigration(
this.client.getEndpoint(),
resourceGroupName,
accountName,
this.client.getApiVersion(),
this.client.getSubscriptionId(),
requestType,
accept,
context);
}
/**
* Live Migration of storage account to enable Hns.
*
* @param resourceGroupName The name of the resource group within the user's subscription. The name is case
* insensitive.
* @param accountName The name of the storage account within the specified resource group. Storage account names
* must be between 3 and 24 characters in length and use numbers and lower-case letters only.
* @param requestType Required. Hierarchical namespace migration type can either be a hierarchical namespace
* validation request 'HnsOnValidationRequest' or a hydration request 'HnsOnHydrationRequest'. The validation
* request will validate the migration whereas the hydration request will migrate the account.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return the {@link PollerFlux} for polling of long-running operation.
*/
@ServiceMethod(returns = ReturnType.LONG_RUNNING_OPERATION)
public PollerFlux, Void> beginHierarchicalNamespaceMigrationAsync(
String resourceGroupName, String accountName, String requestType) {
Mono>> mono =
hierarchicalNamespaceMigrationWithResponseAsync(resourceGroupName, accountName, requestType);
return this
.client
.getLroResult(
mono, this.client.getHttpPipeline(), Void.class, Void.class, this.client.getContext());
}
/**
* Live Migration of storage account to enable Hns.
*
* @param resourceGroupName The name of the resource group within the user's subscription. The name is case
* insensitive.
* @param accountName The name of the storage account within the specified resource group. Storage account names
* must be between 3 and 24 characters in length and use numbers and lower-case letters only.
* @param requestType Required. Hierarchical namespace migration type can either be a hierarchical namespace
* validation request 'HnsOnValidationRequest' or a hydration request 'HnsOnHydrationRequest'. The validation
* request will validate the migration whereas the hydration request will migrate the account.
* @param context The context to associate with this operation.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return the {@link PollerFlux} for polling of long-running operation.
*/
@ServiceMethod(returns = ReturnType.LONG_RUNNING_OPERATION)
private PollerFlux, Void> beginHierarchicalNamespaceMigrationAsync(
String resourceGroupName, String accountName, String requestType, Context context) {
context = this.client.mergeContext(context);
Mono>> mono =
hierarchicalNamespaceMigrationWithResponseAsync(resourceGroupName, accountName, requestType, context);
return this
.client
.getLroResult(mono, this.client.getHttpPipeline(), Void.class, Void.class, context);
}
/**
* Live Migration of storage account to enable Hns.
*
* @param resourceGroupName The name of the resource group within the user's subscription. The name is case
* insensitive.
* @param accountName The name of the storage account within the specified resource group. Storage account names
* must be between 3 and 24 characters in length and use numbers and lower-case letters only.
* @param requestType Required. Hierarchical namespace migration type can either be a hierarchical namespace
* validation request 'HnsOnValidationRequest' or a hydration request 'HnsOnHydrationRequest'. The validation
* request will validate the migration whereas the hydration request will migrate the account.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return the {@link SyncPoller} for polling of long-running operation.
*/
@ServiceMethod(returns = ReturnType.LONG_RUNNING_OPERATION)
public SyncPoller, Void> beginHierarchicalNamespaceMigration(
String resourceGroupName, String accountName, String requestType) {
return beginHierarchicalNamespaceMigrationAsync(resourceGroupName, accountName, requestType).getSyncPoller();
}
/**
* Live Migration of storage account to enable Hns.
*
* @param resourceGroupName The name of the resource group within the user's subscription. The name is case
* insensitive.
* @param accountName The name of the storage account within the specified resource group. Storage account names
* must be between 3 and 24 characters in length and use numbers and lower-case letters only.
* @param requestType Required. Hierarchical namespace migration type can either be a hierarchical namespace
* validation request 'HnsOnValidationRequest' or a hydration request 'HnsOnHydrationRequest'. The validation
* request will validate the migration whereas the hydration request will migrate the account.
* @param context The context to associate with this operation.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return the {@link SyncPoller} for polling of long-running operation.
*/
@ServiceMethod(returns = ReturnType.LONG_RUNNING_OPERATION)
public SyncPoller, Void> beginHierarchicalNamespaceMigration(
String resourceGroupName, String accountName, String requestType, Context context) {
return beginHierarchicalNamespaceMigrationAsync(resourceGroupName, accountName, requestType, context)
.getSyncPoller();
}
/**
* Live Migration of storage account to enable Hns.
*
* @param resourceGroupName The name of the resource group within the user's subscription. The name is case
* insensitive.
* @param accountName The name of the storage account within the specified resource group. Storage account names
* must be between 3 and 24 characters in length and use numbers and lower-case letters only.
* @param requestType Required. Hierarchical namespace migration type can either be a hierarchical namespace
* validation request 'HnsOnValidationRequest' or a hydration request 'HnsOnHydrationRequest'. The validation
* request will validate the migration whereas the hydration request will migrate the account.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return A {@link Mono} that completes when a successful response is received.
*/
@ServiceMethod(returns = ReturnType.SINGLE)
public Mono hierarchicalNamespaceMigrationAsync(
String resourceGroupName, String accountName, String requestType) {
return beginHierarchicalNamespaceMigrationAsync(resourceGroupName, accountName, requestType)
.last()
.flatMap(this.client::getLroFinalResultOrError);
}
/**
* Live Migration of storage account to enable Hns.
*
* @param resourceGroupName The name of the resource group within the user's subscription. The name is case
* insensitive.
* @param accountName The name of the storage account within the specified resource group. Storage account names
* must be between 3 and 24 characters in length and use numbers and lower-case letters only.
* @param requestType Required. Hierarchical namespace migration type can either be a hierarchical namespace
* validation request 'HnsOnValidationRequest' or a hydration request 'HnsOnHydrationRequest'. The validation
* request will validate the migration whereas the hydration request will migrate the account.
* @param context The context to associate with this operation.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return A {@link Mono} that completes when a successful response is received.
*/
@ServiceMethod(returns = ReturnType.SINGLE)
private Mono hierarchicalNamespaceMigrationAsync(
String resourceGroupName, String accountName, String requestType, Context context) {
return beginHierarchicalNamespaceMigrationAsync(resourceGroupName, accountName, requestType, context)
.last()
.flatMap(this.client::getLroFinalResultOrError);
}
/**
* Live Migration of storage account to enable Hns.
*
* @param resourceGroupName The name of the resource group within the user's subscription. The name is case
* insensitive.
* @param accountName The name of the storage account within the specified resource group. Storage account names
* must be between 3 and 24 characters in length and use numbers and lower-case letters only.
* @param requestType Required. Hierarchical namespace migration type can either be a hierarchical namespace
* validation request 'HnsOnValidationRequest' or a hydration request 'HnsOnHydrationRequest'. The validation
* request will validate the migration whereas the hydration request will migrate the account.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
*/
@ServiceMethod(returns = ReturnType.SINGLE)
public void hierarchicalNamespaceMigration(String resourceGroupName, String accountName, String requestType) {
hierarchicalNamespaceMigrationAsync(resourceGroupName, accountName, requestType).block();
}
/**
* Live Migration of storage account to enable Hns.
*
* @param resourceGroupName The name of the resource group within the user's subscription. The name is case
* insensitive.
* @param accountName The name of the storage account within the specified resource group. Storage account names
* must be between 3 and 24 characters in length and use numbers and lower-case letters only.
* @param requestType Required. Hierarchical namespace migration type can either be a hierarchical namespace
* validation request 'HnsOnValidationRequest' or a hydration request 'HnsOnHydrationRequest'. The validation
* request will validate the migration whereas the hydration request will migrate the account.
* @param context The context to associate with this operation.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
*/
@ServiceMethod(returns = ReturnType.SINGLE)
public void hierarchicalNamespaceMigration(
String resourceGroupName, String accountName, String requestType, Context context) {
hierarchicalNamespaceMigrationAsync(resourceGroupName, accountName, requestType, context).block();
}
/**
* Abort live Migration of storage account to enable Hns.
*
* @param resourceGroupName The name of the resource group within the user's subscription. The name is case
* insensitive.
* @param accountName The name of the storage account within the specified resource group. Storage account names
* must be between 3 and 24 characters in length and use numbers and lower-case letters only.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return the {@link Response} on successful completion of {@link Mono}.
*/
@ServiceMethod(returns = ReturnType.SINGLE)
public Mono>> abortHierarchicalNamespaceMigrationWithResponseAsync(
String resourceGroupName, String accountName) {
if (this.client.getEndpoint() == null) {
return Mono
.error(
new IllegalArgumentException(
"Parameter this.client.getEndpoint() is required and cannot be null."));
}
if (resourceGroupName == null) {
return Mono
.error(new IllegalArgumentException("Parameter resourceGroupName is required and cannot be null."));
}
if (accountName == null) {
return Mono.error(new IllegalArgumentException("Parameter accountName is required and cannot be null."));
}
if (this.client.getSubscriptionId() == null) {
return Mono
.error(
new IllegalArgumentException(
"Parameter this.client.getSubscriptionId() is required and cannot be null."));
}
final String accept = "application/json";
return FluxUtil
.withContext(
context ->
service
.abortHierarchicalNamespaceMigration(
this.client.getEndpoint(),
resourceGroupName,
accountName,
this.client.getApiVersion(),
this.client.getSubscriptionId(),
accept,
context))
.contextWrite(context -> context.putAll(FluxUtil.toReactorContext(this.client.getContext()).readOnly()));
}
/**
* Abort live Migration of storage account to enable Hns.
*
* @param resourceGroupName The name of the resource group within the user's subscription. The name is case
* insensitive.
* @param accountName The name of the storage account within the specified resource group. Storage account names
* must be between 3 and 24 characters in length and use numbers and lower-case letters only.
* @param context The context to associate with this operation.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return the {@link Response} on successful completion of {@link Mono}.
*/
@ServiceMethod(returns = ReturnType.SINGLE)
private Mono>> abortHierarchicalNamespaceMigrationWithResponseAsync(
String resourceGroupName, String accountName, Context context) {
if (this.client.getEndpoint() == null) {
return Mono
.error(
new IllegalArgumentException(
"Parameter this.client.getEndpoint() is required and cannot be null."));
}
if (resourceGroupName == null) {
return Mono
.error(new IllegalArgumentException("Parameter resourceGroupName is required and cannot be null."));
}
if (accountName == null) {
return Mono.error(new IllegalArgumentException("Parameter accountName is required and cannot be null."));
}
if (this.client.getSubscriptionId() == null) {
return Mono
.error(
new IllegalArgumentException(
"Parameter this.client.getSubscriptionId() is required and cannot be null."));
}
final String accept = "application/json";
context = this.client.mergeContext(context);
return service
.abortHierarchicalNamespaceMigration(
this.client.getEndpoint(),
resourceGroupName,
accountName,
this.client.getApiVersion(),
this.client.getSubscriptionId(),
accept,
context);
}
/**
* Abort live Migration of storage account to enable Hns.
*
* @param resourceGroupName The name of the resource group within the user's subscription. The name is case
* insensitive.
* @param accountName The name of the storage account within the specified resource group. Storage account names
* must be between 3 and 24 characters in length and use numbers and lower-case letters only.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return the {@link PollerFlux} for polling of long-running operation.
*/
@ServiceMethod(returns = ReturnType.LONG_RUNNING_OPERATION)
public PollerFlux, Void> beginAbortHierarchicalNamespaceMigrationAsync(
String resourceGroupName, String accountName) {
Mono>> mono =
abortHierarchicalNamespaceMigrationWithResponseAsync(resourceGroupName, accountName);
return this
.client
.getLroResult(
mono, this.client.getHttpPipeline(), Void.class, Void.class, this.client.getContext());
}
/**
* Abort live Migration of storage account to enable Hns.
*
* @param resourceGroupName The name of the resource group within the user's subscription. The name is case
* insensitive.
* @param accountName The name of the storage account within the specified resource group. Storage account names
* must be between 3 and 24 characters in length and use numbers and lower-case letters only.
* @param context The context to associate with this operation.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return the {@link PollerFlux} for polling of long-running operation.
*/
@ServiceMethod(returns = ReturnType.LONG_RUNNING_OPERATION)
private PollerFlux, Void> beginAbortHierarchicalNamespaceMigrationAsync(
String resourceGroupName, String accountName, Context context) {
context = this.client.mergeContext(context);
Mono>> mono =
abortHierarchicalNamespaceMigrationWithResponseAsync(resourceGroupName, accountName, context);
return this
.client
.getLroResult(mono, this.client.getHttpPipeline(), Void.class, Void.class, context);
}
/**
* Abort live Migration of storage account to enable Hns.
*
* @param resourceGroupName The name of the resource group within the user's subscription. The name is case
* insensitive.
* @param accountName The name of the storage account within the specified resource group. Storage account names
* must be between 3 and 24 characters in length and use numbers and lower-case letters only.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return the {@link SyncPoller} for polling of long-running operation.
*/
@ServiceMethod(returns = ReturnType.LONG_RUNNING_OPERATION)
public SyncPoller, Void> beginAbortHierarchicalNamespaceMigration(
String resourceGroupName, String accountName) {
return beginAbortHierarchicalNamespaceMigrationAsync(resourceGroupName, accountName).getSyncPoller();
}
/**
* Abort live Migration of storage account to enable Hns.
*
* @param resourceGroupName The name of the resource group within the user's subscription. The name is case
* insensitive.
* @param accountName The name of the storage account within the specified resource group. Storage account names
* must be between 3 and 24 characters in length and use numbers and lower-case letters only.
* @param context The context to associate with this operation.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return the {@link SyncPoller} for polling of long-running operation.
*/
@ServiceMethod(returns = ReturnType.LONG_RUNNING_OPERATION)
public SyncPoller, Void> beginAbortHierarchicalNamespaceMigration(
String resourceGroupName, String accountName, Context context) {
return beginAbortHierarchicalNamespaceMigrationAsync(resourceGroupName, accountName, context).getSyncPoller();
}
/**
* Abort live Migration of storage account to enable Hns.
*
* @param resourceGroupName The name of the resource group within the user's subscription. The name is case
* insensitive.
* @param accountName The name of the storage account within the specified resource group. Storage account names
* must be between 3 and 24 characters in length and use numbers and lower-case letters only.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return A {@link Mono} that completes when a successful response is received.
*/
@ServiceMethod(returns = ReturnType.SINGLE)
public Mono abortHierarchicalNamespaceMigrationAsync(String resourceGroupName, String accountName) {
return beginAbortHierarchicalNamespaceMigrationAsync(resourceGroupName, accountName)
.last()
.flatMap(this.client::getLroFinalResultOrError);
}
/**
* Abort live Migration of storage account to enable Hns.
*
* @param resourceGroupName The name of the resource group within the user's subscription. The name is case
* insensitive.
* @param accountName The name of the storage account within the specified resource group. Storage account names
* must be between 3 and 24 characters in length and use numbers and lower-case letters only.
* @param context The context to associate with this operation.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return A {@link Mono} that completes when a successful response is received.
*/
@ServiceMethod(returns = ReturnType.SINGLE)
private Mono abortHierarchicalNamespaceMigrationAsync(
String resourceGroupName, String accountName, Context context) {
return beginAbortHierarchicalNamespaceMigrationAsync(resourceGroupName, accountName, context)
.last()
.flatMap(this.client::getLroFinalResultOrError);
}
/**
* Abort live Migration of storage account to enable Hns.
*
* @param resourceGroupName The name of the resource group within the user's subscription. The name is case
* insensitive.
* @param accountName The name of the storage account within the specified resource group. Storage account names
* must be between 3 and 24 characters in length and use numbers and lower-case letters only.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
*/
@ServiceMethod(returns = ReturnType.SINGLE)
public void abortHierarchicalNamespaceMigration(String resourceGroupName, String accountName) {
abortHierarchicalNamespaceMigrationAsync(resourceGroupName, accountName).block();
}
/**
* Abort live Migration of storage account to enable Hns.
*
* @param resourceGroupName The name of the resource group within the user's subscription. The name is case
* insensitive.
* @param accountName The name of the storage account within the specified resource group. Storage account names
* must be between 3 and 24 characters in length and use numbers and lower-case letters only.
* @param context The context to associate with this operation.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
*/
@ServiceMethod(returns = ReturnType.SINGLE)
public void abortHierarchicalNamespaceMigration(String resourceGroupName, String accountName, Context context) {
abortHierarchicalNamespaceMigrationAsync(resourceGroupName, accountName, context).block();
}
/**
* Restore blobs in the specified blob ranges.
*
* @param resourceGroupName The name of the resource group within the user's subscription. The name is case
* insensitive.
* @param accountName The name of the storage account within the specified resource group. Storage account names
* must be between 3 and 24 characters in length and use numbers and lower-case letters only.
* @param parameters The parameters to provide for restore blob ranges.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return blob restore status along with {@link Response} on successful completion of {@link Mono}.
*/
@ServiceMethod(returns = ReturnType.SINGLE)
public Mono>> restoreBlobRangesWithResponseAsync(
String resourceGroupName, String accountName, BlobRestoreParameters parameters) {
if (this.client.getEndpoint() == null) {
return Mono
.error(
new IllegalArgumentException(
"Parameter this.client.getEndpoint() is required and cannot be null."));
}
if (resourceGroupName == null) {
return Mono
.error(new IllegalArgumentException("Parameter resourceGroupName is required and cannot be null."));
}
if (accountName == null) {
return Mono.error(new IllegalArgumentException("Parameter accountName is required and cannot be null."));
}
if (this.client.getSubscriptionId() == null) {
return Mono
.error(
new IllegalArgumentException(
"Parameter this.client.getSubscriptionId() is required and cannot be null."));
}
if (parameters == null) {
return Mono.error(new IllegalArgumentException("Parameter parameters is required and cannot be null."));
} else {
parameters.validate();
}
final String accept = "application/json";
return FluxUtil
.withContext(
context ->
service
.restoreBlobRanges(
this.client.getEndpoint(),
resourceGroupName,
accountName,
this.client.getApiVersion(),
this.client.getSubscriptionId(),
parameters,
accept,
context))
.contextWrite(context -> context.putAll(FluxUtil.toReactorContext(this.client.getContext()).readOnly()));
}
/**
* Restore blobs in the specified blob ranges.
*
* @param resourceGroupName The name of the resource group within the user's subscription. The name is case
* insensitive.
* @param accountName The name of the storage account within the specified resource group. Storage account names
* must be between 3 and 24 characters in length and use numbers and lower-case letters only.
* @param parameters The parameters to provide for restore blob ranges.
* @param context The context to associate with this operation.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return blob restore status along with {@link Response} on successful completion of {@link Mono}.
*/
@ServiceMethod(returns = ReturnType.SINGLE)
private Mono>> restoreBlobRangesWithResponseAsync(
String resourceGroupName, String accountName, BlobRestoreParameters parameters, Context context) {
if (this.client.getEndpoint() == null) {
return Mono
.error(
new IllegalArgumentException(
"Parameter this.client.getEndpoint() is required and cannot be null."));
}
if (resourceGroupName == null) {
return Mono
.error(new IllegalArgumentException("Parameter resourceGroupName is required and cannot be null."));
}
if (accountName == null) {
return Mono.error(new IllegalArgumentException("Parameter accountName is required and cannot be null."));
}
if (this.client.getSubscriptionId() == null) {
return Mono
.error(
new IllegalArgumentException(
"Parameter this.client.getSubscriptionId() is required and cannot be null."));
}
if (parameters == null) {
return Mono.error(new IllegalArgumentException("Parameter parameters is required and cannot be null."));
} else {
parameters.validate();
}
final String accept = "application/json";
context = this.client.mergeContext(context);
return service
.restoreBlobRanges(
this.client.getEndpoint(),
resourceGroupName,
accountName,
this.client.getApiVersion(),
this.client.getSubscriptionId(),
parameters,
accept,
context);
}
/**
* Restore blobs in the specified blob ranges.
*
* @param resourceGroupName The name of the resource group within the user's subscription. The name is case
* insensitive.
* @param accountName The name of the storage account within the specified resource group. Storage account names
* must be between 3 and 24 characters in length and use numbers and lower-case letters only.
* @param parameters The parameters to provide for restore blob ranges.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return the {@link PollerFlux} for polling of blob restore status.
*/
@ServiceMethod(returns = ReturnType.LONG_RUNNING_OPERATION)
public PollerFlux, BlobRestoreStatusInner> beginRestoreBlobRangesAsync(
String resourceGroupName, String accountName, BlobRestoreParameters parameters) {
Mono>> mono =
restoreBlobRangesWithResponseAsync(resourceGroupName, accountName, parameters);
return this
.client
.getLroResult(
mono,
this.client.getHttpPipeline(),
BlobRestoreStatusInner.class,
BlobRestoreStatusInner.class,
this.client.getContext());
}
/**
* Restore blobs in the specified blob ranges.
*
* @param resourceGroupName The name of the resource group within the user's subscription. The name is case
* insensitive.
* @param accountName The name of the storage account within the specified resource group. Storage account names
* must be between 3 and 24 characters in length and use numbers and lower-case letters only.
* @param parameters The parameters to provide for restore blob ranges.
* @param context The context to associate with this operation.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return the {@link PollerFlux} for polling of blob restore status.
*/
@ServiceMethod(returns = ReturnType.LONG_RUNNING_OPERATION)
private PollerFlux, BlobRestoreStatusInner> beginRestoreBlobRangesAsync(
String resourceGroupName, String accountName, BlobRestoreParameters parameters, Context context) {
context = this.client.mergeContext(context);
Mono>> mono =
restoreBlobRangesWithResponseAsync(resourceGroupName, accountName, parameters, context);
return this
.client
.getLroResult(
mono,
this.client.getHttpPipeline(),
BlobRestoreStatusInner.class,
BlobRestoreStatusInner.class,
context);
}
/**
* Restore blobs in the specified blob ranges.
*
* @param resourceGroupName The name of the resource group within the user's subscription. The name is case
* insensitive.
* @param accountName The name of the storage account within the specified resource group. Storage account names
* must be between 3 and 24 characters in length and use numbers and lower-case letters only.
* @param parameters The parameters to provide for restore blob ranges.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return the {@link SyncPoller} for polling of blob restore status.
*/
@ServiceMethod(returns = ReturnType.LONG_RUNNING_OPERATION)
public SyncPoller, BlobRestoreStatusInner> beginRestoreBlobRanges(
String resourceGroupName, String accountName, BlobRestoreParameters parameters) {
return beginRestoreBlobRangesAsync(resourceGroupName, accountName, parameters).getSyncPoller();
}
/**
* Restore blobs in the specified blob ranges.
*
* @param resourceGroupName The name of the resource group within the user's subscription. The name is case
* insensitive.
* @param accountName The name of the storage account within the specified resource group. Storage account names
* must be between 3 and 24 characters in length and use numbers and lower-case letters only.
* @param parameters The parameters to provide for restore blob ranges.
* @param context The context to associate with this operation.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return the {@link SyncPoller} for polling of blob restore status.
*/
@ServiceMethod(returns = ReturnType.LONG_RUNNING_OPERATION)
public SyncPoller, BlobRestoreStatusInner> beginRestoreBlobRanges(
String resourceGroupName, String accountName, BlobRestoreParameters parameters, Context context) {
return beginRestoreBlobRangesAsync(resourceGroupName, accountName, parameters, context).getSyncPoller();
}
/**
* Restore blobs in the specified blob ranges.
*
* @param resourceGroupName The name of the resource group within the user's subscription. The name is case
* insensitive.
* @param accountName The name of the storage account within the specified resource group. Storage account names
* must be between 3 and 24 characters in length and use numbers and lower-case letters only.
* @param parameters The parameters to provide for restore blob ranges.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return blob restore status on successful completion of {@link Mono}.
*/
@ServiceMethod(returns = ReturnType.SINGLE)
public Mono restoreBlobRangesAsync(
String resourceGroupName, String accountName, BlobRestoreParameters parameters) {
return beginRestoreBlobRangesAsync(resourceGroupName, accountName, parameters)
.last()
.flatMap(this.client::getLroFinalResultOrError);
}
/**
* Restore blobs in the specified blob ranges.
*
* @param resourceGroupName The name of the resource group within the user's subscription. The name is case
* insensitive.
* @param accountName The name of the storage account within the specified resource group. Storage account names
* must be between 3 and 24 characters in length and use numbers and lower-case letters only.
* @param parameters The parameters to provide for restore blob ranges.
* @param context The context to associate with this operation.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return blob restore status on successful completion of {@link Mono}.
*/
@ServiceMethod(returns = ReturnType.SINGLE)
private Mono restoreBlobRangesAsync(
String resourceGroupName, String accountName, BlobRestoreParameters parameters, Context context) {
return beginRestoreBlobRangesAsync(resourceGroupName, accountName, parameters, context)
.last()
.flatMap(this.client::getLroFinalResultOrError);
}
/**
* Restore blobs in the specified blob ranges.
*
* @param resourceGroupName The name of the resource group within the user's subscription. The name is case
* insensitive.
* @param accountName The name of the storage account within the specified resource group. Storage account names
* must be between 3 and 24 characters in length and use numbers and lower-case letters only.
* @param parameters The parameters to provide for restore blob ranges.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return blob restore status.
*/
@ServiceMethod(returns = ReturnType.SINGLE)
public BlobRestoreStatusInner restoreBlobRanges(
String resourceGroupName, String accountName, BlobRestoreParameters parameters) {
return restoreBlobRangesAsync(resourceGroupName, accountName, parameters).block();
}
/**
* Restore blobs in the specified blob ranges.
*
* @param resourceGroupName The name of the resource group within the user's subscription. The name is case
* insensitive.
* @param accountName The name of the storage account within the specified resource group. Storage account names
* must be between 3 and 24 characters in length and use numbers and lower-case letters only.
* @param parameters The parameters to provide for restore blob ranges.
* @param context The context to associate with this operation.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return blob restore status.
*/
@ServiceMethod(returns = ReturnType.SINGLE)
public BlobRestoreStatusInner restoreBlobRanges(
String resourceGroupName, String accountName, BlobRestoreParameters parameters, Context context) {
return restoreBlobRangesAsync(resourceGroupName, accountName, parameters, context).block();
}
/**
* Revoke user delegation keys.
*
* @param resourceGroupName The name of the resource group within the user's subscription. The name is case
* insensitive.
* @param accountName The name of the storage account within the specified resource group. Storage account names
* must be between 3 and 24 characters in length and use numbers and lower-case letters only.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return the {@link Response} on successful completion of {@link Mono}.
*/
@ServiceMethod(returns = ReturnType.SINGLE)
public Mono> revokeUserDelegationKeysWithResponseAsync(
String resourceGroupName, String accountName) {
if (this.client.getEndpoint() == null) {
return Mono
.error(
new IllegalArgumentException(
"Parameter this.client.getEndpoint() is required and cannot be null."));
}
if (resourceGroupName == null) {
return Mono
.error(new IllegalArgumentException("Parameter resourceGroupName is required and cannot be null."));
}
if (accountName == null) {
return Mono.error(new IllegalArgumentException("Parameter accountName is required and cannot be null."));
}
if (this.client.getSubscriptionId() == null) {
return Mono
.error(
new IllegalArgumentException(
"Parameter this.client.getSubscriptionId() is required and cannot be null."));
}
return FluxUtil
.withContext(
context ->
service
.revokeUserDelegationKeys(
this.client.getEndpoint(),
resourceGroupName,
accountName,
this.client.getApiVersion(),
this.client.getSubscriptionId(),
context))
.contextWrite(context -> context.putAll(FluxUtil.toReactorContext(this.client.getContext()).readOnly()));
}
/**
* Revoke user delegation keys.
*
* @param resourceGroupName The name of the resource group within the user's subscription. The name is case
* insensitive.
* @param accountName The name of the storage account within the specified resource group. Storage account names
* must be between 3 and 24 characters in length and use numbers and lower-case letters only.
* @param context The context to associate with this operation.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return the {@link Response} on successful completion of {@link Mono}.
*/
@ServiceMethod(returns = ReturnType.SINGLE)
private Mono> revokeUserDelegationKeysWithResponseAsync(
String resourceGroupName, String accountName, Context context) {
if (this.client.getEndpoint() == null) {
return Mono
.error(
new IllegalArgumentException(
"Parameter this.client.getEndpoint() is required and cannot be null."));
}
if (resourceGroupName == null) {
return Mono
.error(new IllegalArgumentException("Parameter resourceGroupName is required and cannot be null."));
}
if (accountName == null) {
return Mono.error(new IllegalArgumentException("Parameter accountName is required and cannot be null."));
}
if (this.client.getSubscriptionId() == null) {
return Mono
.error(
new IllegalArgumentException(
"Parameter this.client.getSubscriptionId() is required and cannot be null."));
}
context = this.client.mergeContext(context);
return service
.revokeUserDelegationKeys(
this.client.getEndpoint(),
resourceGroupName,
accountName,
this.client.getApiVersion(),
this.client.getSubscriptionId(),
context);
}
/**
* Revoke user delegation keys.
*
* @param resourceGroupName The name of the resource group within the user's subscription. The name is case
* insensitive.
* @param accountName The name of the storage account within the specified resource group. Storage account names
* must be between 3 and 24 characters in length and use numbers and lower-case letters only.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return A {@link Mono} that completes when a successful response is received.
*/
@ServiceMethod(returns = ReturnType.SINGLE)
public Mono revokeUserDelegationKeysAsync(String resourceGroupName, String accountName) {
return revokeUserDelegationKeysWithResponseAsync(resourceGroupName, accountName)
.flatMap(ignored -> Mono.empty());
}
/**
* Revoke user delegation keys.
*
* @param resourceGroupName The name of the resource group within the user's subscription. The name is case
* insensitive.
* @param accountName The name of the storage account within the specified resource group. Storage account names
* must be between 3 and 24 characters in length and use numbers and lower-case letters only.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
*/
@ServiceMethod(returns = ReturnType.SINGLE)
public void revokeUserDelegationKeys(String resourceGroupName, String accountName) {
revokeUserDelegationKeysAsync(resourceGroupName, accountName).block();
}
/**
* Revoke user delegation keys.
*
* @param resourceGroupName The name of the resource group within the user's subscription. The name is case
* insensitive.
* @param accountName The name of the storage account within the specified resource group. Storage account names
* must be between 3 and 24 characters in length and use numbers and lower-case letters only.
* @param context The context to associate with this operation.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return the {@link Response}.
*/
@ServiceMethod(returns = ReturnType.SINGLE)
public Response revokeUserDelegationKeysWithResponse(
String resourceGroupName, String accountName, Context context) {
return revokeUserDelegationKeysWithResponseAsync(resourceGroupName, accountName, context).block();
}
/**
* Get the next page of items.
*
* @param nextLink The URL to get the next list of items
* The nextLink parameter.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return the response from the List Storage Accounts operation along with {@link PagedResponse} on successful
* completion of {@link Mono}.
*/
@ServiceMethod(returns = ReturnType.SINGLE)
private Mono> listNextSinglePageAsync(String nextLink) {
if (nextLink == null) {
return Mono.error(new IllegalArgumentException("Parameter nextLink is required and cannot be null."));
}
if (this.client.getEndpoint() == null) {
return Mono
.error(
new IllegalArgumentException(
"Parameter this.client.getEndpoint() is required and cannot be null."));
}
final String accept = "application/json";
return FluxUtil
.withContext(context -> service.listNext(nextLink, this.client.getEndpoint(), accept, context))
.>map(
res ->
new PagedResponseBase<>(
res.getRequest(),
res.getStatusCode(),
res.getHeaders(),
res.getValue().value(),
res.getValue().nextLink(),
null))
.contextWrite(context -> context.putAll(FluxUtil.toReactorContext(this.client.getContext()).readOnly()));
}
/**
* Get the next page of items.
*
* @param nextLink The URL to get the next list of items
* The nextLink parameter.
* @param context The context to associate with this operation.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return the response from the List Storage Accounts operation along with {@link PagedResponse} on successful
* completion of {@link Mono}.
*/
@ServiceMethod(returns = ReturnType.SINGLE)
private Mono> listNextSinglePageAsync(String nextLink, Context context) {
if (nextLink == null) {
return Mono.error(new IllegalArgumentException("Parameter nextLink is required and cannot be null."));
}
if (this.client.getEndpoint() == null) {
return Mono
.error(
new IllegalArgumentException(
"Parameter this.client.getEndpoint() is required and cannot be null."));
}
final String accept = "application/json";
context = this.client.mergeContext(context);
return service
.listNext(nextLink, this.client.getEndpoint(), accept, context)
.map(
res ->
new PagedResponseBase<>(
res.getRequest(),
res.getStatusCode(),
res.getHeaders(),
res.getValue().value(),
res.getValue().nextLink(),
null));
}
/**
* Get the next page of items.
*
* @param nextLink The URL to get the next list of items
* The nextLink parameter.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return the response from the List Storage Accounts operation along with {@link PagedResponse} on successful
* completion of {@link Mono}.
*/
@ServiceMethod(returns = ReturnType.SINGLE)
private Mono> listByResourceGroupNextSinglePageAsync(String nextLink) {
if (nextLink == null) {
return Mono.error(new IllegalArgumentException("Parameter nextLink is required and cannot be null."));
}
if (this.client.getEndpoint() == null) {
return Mono
.error(
new IllegalArgumentException(
"Parameter this.client.getEndpoint() is required and cannot be null."));
}
final String accept = "application/json";
return FluxUtil
.withContext(
context -> service.listByResourceGroupNext(nextLink, this.client.getEndpoint(), accept, context))
.>map(
res ->
new PagedResponseBase<>(
res.getRequest(),
res.getStatusCode(),
res.getHeaders(),
res.getValue().value(),
res.getValue().nextLink(),
null))
.contextWrite(context -> context.putAll(FluxUtil.toReactorContext(this.client.getContext()).readOnly()));
}
/**
* Get the next page of items.
*
* @param nextLink The URL to get the next list of items
* The nextLink parameter.
* @param context The context to associate with this operation.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ManagementException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return the response from the List Storage Accounts operation along with {@link PagedResponse} on successful
* completion of {@link Mono}.
*/
@ServiceMethod(returns = ReturnType.SINGLE)
private Mono> listByResourceGroupNextSinglePageAsync(
String nextLink, Context context) {
if (nextLink == null) {
return Mono.error(new IllegalArgumentException("Parameter nextLink is required and cannot be null."));
}
if (this.client.getEndpoint() == null) {
return Mono
.error(
new IllegalArgumentException(
"Parameter this.client.getEndpoint() is required and cannot be null."));
}
final String accept = "application/json";
context = this.client.mergeContext(context);
return service
.listByResourceGroupNext(nextLink, this.client.getEndpoint(), accept, context)
.map(
res ->
new PagedResponseBase<>(
res.getRequest(),
res.getStatusCode(),
res.getHeaders(),
res.getValue().value(),
res.getValue().nextLink(),
null));
}
}
© 2015 - 2024 Weber Informatics LLC | Privacy Policy