diff --git a/sdk/recoveryservices/azure-mgmt-recoveryservicesbackup/_meta.json b/sdk/recoveryservices/azure-mgmt-recoveryservicesbackup/_meta.json index 124e267cadbe..05d1f8de3443 100644 --- a/sdk/recoveryservices/azure-mgmt-recoveryservicesbackup/_meta.json +++ b/sdk/recoveryservices/azure-mgmt-recoveryservicesbackup/_meta.json @@ -1,11 +1,11 @@ { - "commit": "5fb045bd44f143bae17da2e01552ae531f77d0ba", + "commit": "76b41213dd26c013e7a7c63aafd72f42a1df9c62", "repository_url": "https://github.com/Azure/azure-rest-api-specs", "autorest": "3.9.7", "use": [ "@autorest/python@6.7.1", "@autorest/modelerfour@4.26.2" ], - "autorest_command": "autorest specification/recoveryservicesbackup/resource-manager/readme.md --generate-sample=True --include-x-ms-examples-original-file=True --python --python-sdks-folder=/home/vsts/work/1/azure-sdk-for-python/sdk --use=@autorest/python@6.7.1 --use=@autorest/modelerfour@4.26.2 --version=3.9.7 --version-tolerant=False", + "autorest_command": "autorest specification/recoveryservicesbackup/resource-manager/readme.md --generate-sample=True --include-x-ms-examples-original-file=True --python --python-sdks-folder=/mnt/vss/_work/1/s/azure-sdk-for-python/sdk --use=@autorest/python@6.7.1 --use=@autorest/modelerfour@4.26.2 --version=3.9.7 --version-tolerant=False", "readme": "specification/recoveryservicesbackup/resource-manager/readme.md" } \ No newline at end of file diff --git a/sdk/recoveryservices/azure-mgmt-recoveryservicesbackup/azure/mgmt/recoveryservicesbackup/activestamp/_version.py b/sdk/recoveryservices/azure-mgmt-recoveryservicesbackup/azure/mgmt/recoveryservicesbackup/activestamp/_version.py index 364f3c906cf9..e5754a47ce68 100644 --- a/sdk/recoveryservices/azure-mgmt-recoveryservicesbackup/azure/mgmt/recoveryservicesbackup/activestamp/_version.py +++ b/sdk/recoveryservices/azure-mgmt-recoveryservicesbackup/azure/mgmt/recoveryservicesbackup/activestamp/_version.py @@ -6,4 +6,4 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -VERSION = "7.0.0" +VERSION = "1.0.0b1" diff --git a/sdk/recoveryservices/azure-mgmt-recoveryservicesbackup/azure/mgmt/recoveryservicesbackup/activestamp/aio/operations/_protection_containers_operations.py b/sdk/recoveryservices/azure-mgmt-recoveryservicesbackup/azure/mgmt/recoveryservicesbackup/activestamp/aio/operations/_protection_containers_operations.py index ddbafcb3fec5..0faa08ebda6f 100644 --- a/sdk/recoveryservices/azure-mgmt-recoveryservicesbackup/azure/mgmt/recoveryservicesbackup/activestamp/aio/operations/_protection_containers_operations.py +++ b/sdk/recoveryservices/azure-mgmt-recoveryservicesbackup/azure/mgmt/recoveryservicesbackup/activestamp/aio/operations/_protection_containers_operations.py @@ -7,7 +7,7 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- from io import IOBase -from typing import Any, Callable, Dict, IO, Optional, TypeVar, Union, overload +from typing import Any, Callable, Dict, IO, Optional, TypeVar, Union, cast, overload from azure.core.exceptions import ( ClientAuthenticationError, @@ -19,10 +19,12 @@ ) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import AsyncHttpResponse +from azure.core.polling import AsyncLROPoller, AsyncNoPolling, AsyncPollingMethod from azure.core.rest import HttpRequest from azure.core.tracing.decorator_async import distributed_trace_async from azure.core.utils import case_insensitive_dict from azure.mgmt.core.exceptions import ARMErrorFormat +from azure.mgmt.core.polling.async_arm_polling import AsyncARMPolling from ... import models as _models from ..._vendor import _convert_request @@ -128,8 +130,81 @@ async def get( "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.RecoveryServices/vaults/{vaultName}/backupFabrics/{fabricName}/protectionContainers/{containerName}" } + async def _register_initial( + self, + vault_name: str, + resource_group_name: str, + fabric_name: str, + container_name: str, + parameters: Union[_models.ProtectionContainerResource, IO], + **kwargs: Any + ) -> Optional[_models.ProtectionContainerResource]: + error_map = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + cls: ClsType[Optional[_models.ProtectionContainerResource]] = kwargs.pop("cls", None) + + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IOBase, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "ProtectionContainerResource") + + request = build_register_request( + vault_name=vault_name, + resource_group_name=resource_group_name, + fabric_name=fabric_name, + container_name=container_name, + subscription_id=self._config.subscription_id, + api_version=api_version, + content_type=content_type, + json=_json, + content=_content, + template_url=self._register_initial.metadata["url"], + headers=_headers, + params=_params, + ) + request = _convert_request(request) + request.url = self._client.format_url(request.url) + + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200, 202]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + raise HttpResponseError(response=response, error_format=ARMErrorFormat) + + deserialized = None + if response.status_code == 200: + deserialized = self._deserialize("ProtectionContainerResource", pipeline_response) + + if cls: + return cls(pipeline_response, deserialized, {}) + + return deserialized + + _register_initial.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.RecoveryServices/vaults/{vaultName}/backupFabrics/{fabricName}/protectionContainers/{containerName}" + } + @overload - async def register( + async def begin_register( self, vault_name: str, resource_group_name: str, @@ -139,7 +214,7 @@ async def register( *, content_type: str = "application/json", **kwargs: Any - ) -> Optional[_models.ProtectionContainerResource]: + ) -> AsyncLROPoller[_models.ProtectionContainerResource]: """Registers the container with Recovery Services vault. This is an asynchronous operation. To track the operation status, use location header to call get latest status of @@ -161,14 +236,22 @@ async def register( Default value is "application/json". :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: ProtectionContainerResource or None or the result of cls(response) - :rtype: ~azure.mgmt.recoveryservicesbackup.activestamp.models.ProtectionContainerResource or - None + :keyword str continuation_token: A continuation token to restart a poller from a saved state. + :keyword polling: By default, your polling method will be AsyncARMPolling. Pass in False for + this operation to not poll, or pass in your own initialized polling object for a personal + polling strategy. + :paramtype polling: bool or ~azure.core.polling.AsyncPollingMethod + :keyword int polling_interval: Default waiting time between two polls for LRO operations if no + Retry-After header is present. + :return: An instance of AsyncLROPoller that returns either ProtectionContainerResource or the + result of cls(response) + :rtype: + ~azure.core.polling.AsyncLROPoller[~azure.mgmt.recoveryservicesbackup.activestamp.models.ProtectionContainerResource] :raises ~azure.core.exceptions.HttpResponseError: """ @overload - async def register( + async def begin_register( self, vault_name: str, resource_group_name: str, @@ -178,7 +261,7 @@ async def register( *, content_type: str = "application/json", **kwargs: Any - ) -> Optional[_models.ProtectionContainerResource]: + ) -> AsyncLROPoller[_models.ProtectionContainerResource]: """Registers the container with Recovery Services vault. This is an asynchronous operation. To track the operation status, use location header to call get latest status of @@ -199,14 +282,22 @@ async def register( Default value is "application/json". :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: ProtectionContainerResource or None or the result of cls(response) - :rtype: ~azure.mgmt.recoveryservicesbackup.activestamp.models.ProtectionContainerResource or - None + :keyword str continuation_token: A continuation token to restart a poller from a saved state. + :keyword polling: By default, your polling method will be AsyncARMPolling. Pass in False for + this operation to not poll, or pass in your own initialized polling object for a personal + polling strategy. + :paramtype polling: bool or ~azure.core.polling.AsyncPollingMethod + :keyword int polling_interval: Default waiting time between two polls for LRO operations if no + Retry-After header is present. + :return: An instance of AsyncLROPoller that returns either ProtectionContainerResource or the + result of cls(response) + :rtype: + ~azure.core.polling.AsyncLROPoller[~azure.mgmt.recoveryservicesbackup.activestamp.models.ProtectionContainerResource] :raises ~azure.core.exceptions.HttpResponseError: """ @distributed_trace_async - async def register( + async def begin_register( self, vault_name: str, resource_group_name: str, @@ -214,7 +305,7 @@ async def register( container_name: str, parameters: Union[_models.ProtectionContainerResource, IO], **kwargs: Any - ) -> Optional[_models.ProtectionContainerResource]: + ) -> AsyncLROPoller[_models.ProtectionContainerResource]: """Registers the container with Recovery Services vault. This is an asynchronous operation. To track the operation status, use location header to call get latest status of @@ -237,72 +328,66 @@ async def register( Default value is None. :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: ProtectionContainerResource or None or the result of cls(response) - :rtype: ~azure.mgmt.recoveryservicesbackup.activestamp.models.ProtectionContainerResource or - None + :keyword str continuation_token: A continuation token to restart a poller from a saved state. + :keyword polling: By default, your polling method will be AsyncARMPolling. Pass in False for + this operation to not poll, or pass in your own initialized polling object for a personal + polling strategy. + :paramtype polling: bool or ~azure.core.polling.AsyncPollingMethod + :keyword int polling_interval: Default waiting time between two polls for LRO operations if no + Retry-After header is present. + :return: An instance of AsyncLROPoller that returns either ProtectionContainerResource or the + result of cls(response) + :rtype: + ~azure.core.polling.AsyncLROPoller[~azure.mgmt.recoveryservicesbackup.activestamp.models.ProtectionContainerResource] :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[Optional[_models.ProtectionContainerResource]] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(parameters, (IOBase, bytes)): - _content = parameters - else: - _json = self._serialize.body(parameters, "ProtectionContainerResource") - - request = build_register_request( - vault_name=vault_name, - resource_group_name=resource_group_name, - fabric_name=fabric_name, - container_name=container_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - template_url=self.register.metadata["url"], - headers=_headers, - params=_params, - ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 202]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = None - if response.status_code == 200: + cls: ClsType[_models.ProtectionContainerResource] = kwargs.pop("cls", None) + polling: Union[bool, AsyncPollingMethod] = kwargs.pop("polling", True) + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token: Optional[str] = kwargs.pop("continuation_token", None) + if cont_token is None: + raw_result = await self._register_initial( + vault_name=vault_name, + resource_group_name=resource_group_name, + fabric_name=fabric_name, + container_name=container_name, + parameters=parameters, + api_version=api_version, + content_type=content_type, + cls=lambda x, y, z: x, + headers=_headers, + params=_params, + **kwargs + ) + kwargs.pop("error_map", None) + + def get_long_running_output(pipeline_response): deserialized = self._deserialize("ProtectionContainerResource", pipeline_response) - - if cls: - return cls(pipeline_response, deserialized, {}) - - return deserialized - - register.metadata = { + if cls: + return cls(pipeline_response, deserialized, {}) + return deserialized + + if polling is True: + polling_method: AsyncPollingMethod = cast(AsyncPollingMethod, AsyncARMPolling(lro_delay, **kwargs)) + elif polling is False: + polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) + else: + polling_method = polling + if cont_token: + return AsyncLROPoller.from_continuation_token( + polling_method=polling_method, + continuation_token=cont_token, + client=self._client, + deserialization_callback=get_long_running_output, + ) + return AsyncLROPoller(self._client, raw_result, get_long_running_output, polling_method) # type: ignore + + begin_register.metadata = { "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.RecoveryServices/vaults/{vaultName}/backupFabrics/{fabricName}/protectionContainers/{containerName}" } diff --git a/sdk/recoveryservices/azure-mgmt-recoveryservicesbackup/azure/mgmt/recoveryservicesbackup/activestamp/models/_models_py3.py b/sdk/recoveryservices/azure-mgmt-recoveryservicesbackup/azure/mgmt/recoveryservicesbackup/activestamp/models/_models_py3.py index 15b2f717988a..7252dd95b0b3 100644 --- a/sdk/recoveryservices/azure-mgmt-recoveryservicesbackup/azure/mgmt/recoveryservicesbackup/activestamp/models/_models_py3.py +++ b/sdk/recoveryservices/azure-mgmt-recoveryservicesbackup/azure/mgmt/recoveryservicesbackup/activestamp/models/_models_py3.py @@ -12697,7 +12697,7 @@ def __init__( self.po_logical_name = po_logical_name -class BackupStatusResponse(_serialization.Model): +class BackupStatusResponse(_serialization.Model): # pylint: disable=too-many-instance-attributes """BackupStatus response. :ivar protection_status: Specifies whether the container is registered or not. Known values @@ -12723,6 +12723,12 @@ class BackupStatusResponse(_serialization.Model): :vartype policy_name: str :ivar registration_status: Container registration status. :vartype registration_status: str + :ivar protected_items_count: Number of protected items. + :vartype protected_items_count: int + :ivar acquire_storage_account_lock: Specifies whether the storage account lock has been + acquired or not. Known values are: "Acquire" and "NotAcquire". + :vartype acquire_storage_account_lock: str or + ~azure.mgmt.recoveryservicesbackup.activestamp.models.AcquireStorageAccountLock """ _attribute_map = { @@ -12735,6 +12741,8 @@ class BackupStatusResponse(_serialization.Model): "error_message": {"key": "errorMessage", "type": "str"}, "policy_name": {"key": "policyName", "type": "str"}, "registration_status": {"key": "registrationStatus", "type": "str"}, + "protected_items_count": {"key": "protectedItemsCount", "type": "int"}, + "acquire_storage_account_lock": {"key": "acquireStorageAccountLock", "type": "str"}, } def __init__( @@ -12749,6 +12757,8 @@ def __init__( error_message: Optional[str] = None, policy_name: Optional[str] = None, registration_status: Optional[str] = None, + protected_items_count: Optional[int] = None, + acquire_storage_account_lock: Optional[Union[str, "_models.AcquireStorageAccountLock"]] = None, **kwargs: Any ) -> None: """ @@ -12775,6 +12785,12 @@ def __init__( :paramtype policy_name: str :keyword registration_status: Container registration status. :paramtype registration_status: str + :keyword protected_items_count: Number of protected items. + :paramtype protected_items_count: int + :keyword acquire_storage_account_lock: Specifies whether the storage account lock has been + acquired or not. Known values are: "Acquire" and "NotAcquire". + :paramtype acquire_storage_account_lock: str or + ~azure.mgmt.recoveryservicesbackup.activestamp.models.AcquireStorageAccountLock """ super().__init__(**kwargs) self.protection_status = protection_status @@ -12786,6 +12802,8 @@ def __init__( self.error_message = error_message self.policy_name = policy_name self.registration_status = registration_status + self.protected_items_count = protected_items_count + self.acquire_storage_account_lock = acquire_storage_account_lock class BEKDetails(_serialization.Model): @@ -15570,6 +15588,10 @@ class IaasVMRecoveryPoint(RecoveryPoint): # pylint: disable=too-many-instance-a :ivar is_private_access_enabled_on_any_disk: This flag denotes if any of the disks in the VM are using Private access network setting. :vartype is_private_access_enabled_on_any_disk: bool + :ivar extended_location: Extended location of the VM recovery point, + should be null if VM is in public cloud. + :vartype extended_location: + ~azure.mgmt.recoveryservicesbackup.activestamp.models.ExtendedLocation """ _validation = { @@ -15602,6 +15624,7 @@ class IaasVMRecoveryPoint(RecoveryPoint): # pylint: disable=too-many-instance-a "security_type": {"key": "securityType", "type": "str"}, "recovery_point_properties": {"key": "recoveryPointProperties", "type": "RecoveryPointProperties"}, "is_private_access_enabled_on_any_disk": {"key": "isPrivateAccessEnabledOnAnyDisk", "type": "bool"}, + "extended_location": {"key": "extendedLocation", "type": "ExtendedLocation"}, } def __init__( @@ -15625,6 +15648,7 @@ def __init__( security_type: Optional[str] = None, recovery_point_properties: Optional["_models.RecoveryPointProperties"] = None, is_private_access_enabled_on_any_disk: Optional[bool] = None, + extended_location: Optional["_models.ExtendedLocation"] = None, **kwargs: Any ) -> None: """ @@ -15675,6 +15699,10 @@ def __init__( :keyword is_private_access_enabled_on_any_disk: This flag denotes if any of the disks in the VM are using Private access network setting. :paramtype is_private_access_enabled_on_any_disk: bool + :keyword extended_location: Extended location of the VM recovery point, + should be null if VM is in public cloud. + :paramtype extended_location: + ~azure.mgmt.recoveryservicesbackup.activestamp.models.ExtendedLocation """ super().__init__(**kwargs) self.object_type: str = "IaasVMRecoveryPoint" @@ -15696,6 +15724,7 @@ def __init__( self.security_type = security_type self.recovery_point_properties = recovery_point_properties self.is_private_access_enabled_on_any_disk = is_private_access_enabled_on_any_disk + self.extended_location = extended_location class IaasVMRestoreRequest(RestoreRequest): # pylint: disable=too-many-instance-attributes diff --git a/sdk/recoveryservices/azure-mgmt-recoveryservicesbackup/azure/mgmt/recoveryservicesbackup/activestamp/operations/_protection_containers_operations.py b/sdk/recoveryservices/azure-mgmt-recoveryservicesbackup/azure/mgmt/recoveryservicesbackup/activestamp/operations/_protection_containers_operations.py index bddd6faf9ca7..8904e0ed9986 100644 --- a/sdk/recoveryservices/azure-mgmt-recoveryservicesbackup/azure/mgmt/recoveryservicesbackup/activestamp/operations/_protection_containers_operations.py +++ b/sdk/recoveryservices/azure-mgmt-recoveryservicesbackup/azure/mgmt/recoveryservicesbackup/activestamp/operations/_protection_containers_operations.py @@ -7,7 +7,7 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- from io import IOBase -from typing import Any, Callable, Dict, IO, Optional, TypeVar, Union, overload +from typing import Any, Callable, Dict, IO, Optional, TypeVar, Union, cast, overload from azure.core.exceptions import ( ClientAuthenticationError, @@ -19,10 +19,12 @@ ) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import HttpResponse +from azure.core.polling import LROPoller, NoPolling, PollingMethod from azure.core.rest import HttpRequest from azure.core.tracing.decorator import distributed_trace from azure.core.utils import case_insensitive_dict from azure.mgmt.core.exceptions import ARMErrorFormat +from azure.mgmt.core.polling.arm_polling import ARMPolling from .. import models as _models from .._serialization import Serializer @@ -323,8 +325,81 @@ def get( "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.RecoveryServices/vaults/{vaultName}/backupFabrics/{fabricName}/protectionContainers/{containerName}" } + def _register_initial( + self, + vault_name: str, + resource_group_name: str, + fabric_name: str, + container_name: str, + parameters: Union[_models.ProtectionContainerResource, IO], + **kwargs: Any + ) -> Optional[_models.ProtectionContainerResource]: + error_map = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + cls: ClsType[Optional[_models.ProtectionContainerResource]] = kwargs.pop("cls", None) + + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(parameters, (IOBase, bytes)): + _content = parameters + else: + _json = self._serialize.body(parameters, "ProtectionContainerResource") + + request = build_register_request( + vault_name=vault_name, + resource_group_name=resource_group_name, + fabric_name=fabric_name, + container_name=container_name, + subscription_id=self._config.subscription_id, + api_version=api_version, + content_type=content_type, + json=_json, + content=_content, + template_url=self._register_initial.metadata["url"], + headers=_headers, + params=_params, + ) + request = _convert_request(request) + request.url = self._client.format_url(request.url) + + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200, 202]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + raise HttpResponseError(response=response, error_format=ARMErrorFormat) + + deserialized = None + if response.status_code == 200: + deserialized = self._deserialize("ProtectionContainerResource", pipeline_response) + + if cls: + return cls(pipeline_response, deserialized, {}) + + return deserialized + + _register_initial.metadata = { + "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.RecoveryServices/vaults/{vaultName}/backupFabrics/{fabricName}/protectionContainers/{containerName}" + } + @overload - def register( + def begin_register( self, vault_name: str, resource_group_name: str, @@ -334,7 +409,7 @@ def register( *, content_type: str = "application/json", **kwargs: Any - ) -> Optional[_models.ProtectionContainerResource]: + ) -> LROPoller[_models.ProtectionContainerResource]: """Registers the container with Recovery Services vault. This is an asynchronous operation. To track the operation status, use location header to call get latest status of @@ -356,14 +431,22 @@ def register( Default value is "application/json". :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: ProtectionContainerResource or None or the result of cls(response) - :rtype: ~azure.mgmt.recoveryservicesbackup.activestamp.models.ProtectionContainerResource or - None + :keyword str continuation_token: A continuation token to restart a poller from a saved state. + :keyword polling: By default, your polling method will be ARMPolling. Pass in False for this + operation to not poll, or pass in your own initialized polling object for a personal polling + strategy. + :paramtype polling: bool or ~azure.core.polling.PollingMethod + :keyword int polling_interval: Default waiting time between two polls for LRO operations if no + Retry-After header is present. + :return: An instance of LROPoller that returns either ProtectionContainerResource or the result + of cls(response) + :rtype: + ~azure.core.polling.LROPoller[~azure.mgmt.recoveryservicesbackup.activestamp.models.ProtectionContainerResource] :raises ~azure.core.exceptions.HttpResponseError: """ @overload - def register( + def begin_register( self, vault_name: str, resource_group_name: str, @@ -373,7 +456,7 @@ def register( *, content_type: str = "application/json", **kwargs: Any - ) -> Optional[_models.ProtectionContainerResource]: + ) -> LROPoller[_models.ProtectionContainerResource]: """Registers the container with Recovery Services vault. This is an asynchronous operation. To track the operation status, use location header to call get latest status of @@ -394,14 +477,22 @@ def register( Default value is "application/json". :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: ProtectionContainerResource or None or the result of cls(response) - :rtype: ~azure.mgmt.recoveryservicesbackup.activestamp.models.ProtectionContainerResource or - None + :keyword str continuation_token: A continuation token to restart a poller from a saved state. + :keyword polling: By default, your polling method will be ARMPolling. Pass in False for this + operation to not poll, or pass in your own initialized polling object for a personal polling + strategy. + :paramtype polling: bool or ~azure.core.polling.PollingMethod + :keyword int polling_interval: Default waiting time between two polls for LRO operations if no + Retry-After header is present. + :return: An instance of LROPoller that returns either ProtectionContainerResource or the result + of cls(response) + :rtype: + ~azure.core.polling.LROPoller[~azure.mgmt.recoveryservicesbackup.activestamp.models.ProtectionContainerResource] :raises ~azure.core.exceptions.HttpResponseError: """ @distributed_trace - def register( + def begin_register( self, vault_name: str, resource_group_name: str, @@ -409,7 +500,7 @@ def register( container_name: str, parameters: Union[_models.ProtectionContainerResource, IO], **kwargs: Any - ) -> Optional[_models.ProtectionContainerResource]: + ) -> LROPoller[_models.ProtectionContainerResource]: """Registers the container with Recovery Services vault. This is an asynchronous operation. To track the operation status, use location header to call get latest status of @@ -432,72 +523,66 @@ def register( Default value is None. :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: ProtectionContainerResource or None or the result of cls(response) - :rtype: ~azure.mgmt.recoveryservicesbackup.activestamp.models.ProtectionContainerResource or - None + :keyword str continuation_token: A continuation token to restart a poller from a saved state. + :keyword polling: By default, your polling method will be ARMPolling. Pass in False for this + operation to not poll, or pass in your own initialized polling object for a personal polling + strategy. + :paramtype polling: bool or ~azure.core.polling.PollingMethod + :keyword int polling_interval: Default waiting time between two polls for LRO operations if no + Retry-After header is present. + :return: An instance of LROPoller that returns either ProtectionContainerResource or the result + of cls(response) + :rtype: + ~azure.core.polling.LROPoller[~azure.mgmt.recoveryservicesbackup.activestamp.models.ProtectionContainerResource] :raises ~azure.core.exceptions.HttpResponseError: """ - error_map = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[Optional[_models.ProtectionContainerResource]] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(parameters, (IOBase, bytes)): - _content = parameters - else: - _json = self._serialize.body(parameters, "ProtectionContainerResource") - - request = build_register_request( - vault_name=vault_name, - resource_group_name=resource_group_name, - fabric_name=fabric_name, - container_name=container_name, - subscription_id=self._config.subscription_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - template_url=self.register.metadata["url"], - headers=_headers, - params=_params, - ) - request = _convert_request(request) - request.url = self._client.format_url(request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 202]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response, error_format=ARMErrorFormat) - - deserialized = None - if response.status_code == 200: + cls: ClsType[_models.ProtectionContainerResource] = kwargs.pop("cls", None) + polling: Union[bool, PollingMethod] = kwargs.pop("polling", True) + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token: Optional[str] = kwargs.pop("continuation_token", None) + if cont_token is None: + raw_result = self._register_initial( + vault_name=vault_name, + resource_group_name=resource_group_name, + fabric_name=fabric_name, + container_name=container_name, + parameters=parameters, + api_version=api_version, + content_type=content_type, + cls=lambda x, y, z: x, + headers=_headers, + params=_params, + **kwargs + ) + kwargs.pop("error_map", None) + + def get_long_running_output(pipeline_response): deserialized = self._deserialize("ProtectionContainerResource", pipeline_response) - - if cls: - return cls(pipeline_response, deserialized, {}) - - return deserialized - - register.metadata = { + if cls: + return cls(pipeline_response, deserialized, {}) + return deserialized + + if polling is True: + polling_method: PollingMethod = cast(PollingMethod, ARMPolling(lro_delay, **kwargs)) + elif polling is False: + polling_method = cast(PollingMethod, NoPolling()) + else: + polling_method = polling + if cont_token: + return LROPoller.from_continuation_token( + polling_method=polling_method, + continuation_token=cont_token, + client=self._client, + deserialization_callback=get_long_running_output, + ) + return LROPoller(self._client, raw_result, get_long_running_output, polling_method) # type: ignore + + begin_register.metadata = { "url": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.RecoveryServices/vaults/{vaultName}/backupFabrics/{fabricName}/protectionContainers/{containerName}" } diff --git a/sdk/recoveryservices/azure-mgmt-recoveryservicesbackup/azure/mgmt/recoveryservicesbackup/passivestamp/_version.py b/sdk/recoveryservices/azure-mgmt-recoveryservicesbackup/azure/mgmt/recoveryservicesbackup/passivestamp/_version.py index 364f3c906cf9..e5754a47ce68 100644 --- a/sdk/recoveryservices/azure-mgmt-recoveryservicesbackup/azure/mgmt/recoveryservicesbackup/passivestamp/_version.py +++ b/sdk/recoveryservices/azure-mgmt-recoveryservicesbackup/azure/mgmt/recoveryservicesbackup/passivestamp/_version.py @@ -6,4 +6,4 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -VERSION = "7.0.0" +VERSION = "1.0.0b1" diff --git a/sdk/recoveryservices/azure-mgmt-recoveryservicesbackup/generated_samples/activestamp/azure_storage/protection_containers_register.py b/sdk/recoveryservices/azure-mgmt-recoveryservicesbackup/generated_samples/activestamp/azure_storage/protection_containers_register.py index 34b74d661500..aa5b025c3387 100644 --- a/sdk/recoveryservices/azure-mgmt-recoveryservicesbackup/generated_samples/activestamp/azure_storage/protection_containers_register.py +++ b/sdk/recoveryservices/azure-mgmt-recoveryservicesbackup/generated_samples/activestamp/azure_storage/protection_containers_register.py @@ -29,7 +29,7 @@ def main(): subscription_id="00000000-0000-0000-0000-000000000000", ) - response = client.protection_containers.register( + response = client.protection_containers.begin_register( vault_name="swaggertestvault", resource_group_name="SwaggerTestRg", fabric_name="Azure", @@ -43,7 +43,7 @@ def main(): "sourceResourceId": "/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/SwaggerTestRg/providers/Microsoft.Storage/storageAccounts/swaggertestsa", } }, - ) + ).result() print(response)