async def begin_put(
self, resource_group_name: str, cluster_name: str,
private_endpoint_connection_name: str,
properties: "_models.PrivateEndpointConnection",
**kwargs) -> AsyncLROPoller["_models.PrivateEndpointConnection"]:
"""Updates the state of the specified private endpoint connection associated with the
RedisEnterprise cluster.
:param resource_group_name: The name of the resource group.
:type resource_group_name: str
:param cluster_name: The name of the RedisEnterprise cluster.
:type cluster_name: str
:param private_endpoint_connection_name: The name of the private endpoint connection associated
with the Azure resource.
:type private_endpoint_connection_name: str
:param properties: The private endpoint connection properties.
:type properties: ~azure.mgmt.redisenterprise.models.PrivateEndpointConnection
:keyword callable cls: A custom type or function that will be passed the direct response
:keyword str continuation_token: A continuation token to restart a poller from a saved state.
:keyword polling: True for ARMPolling, False for no polling, or a
polling object for 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 PrivateEndpointConnection or the result of cls(response)
:rtype: ~azure.core.polling.AsyncLROPoller[~azure.mgmt.redisenterprise.models.PrivateEndpointConnection]
:raises ~azure.core.exceptions.HttpResponseError:
"""
polling = kwargs.pop('polling',
True) # type: Union[bool, AsyncPollingMethod]
cls = kwargs.pop(
'cls', None) # type: ClsType["_models.PrivateEndpointConnection"]
lro_delay = kwargs.pop('polling_interval',
self._config.polling_interval)
cont_token = kwargs.pop('continuation_token',
None) # type: Optional[str]
if cont_token is None:
raw_result = await self._put_initial(
resource_group_name=resource_group_name,
cluster_name=cluster_name,
private_endpoint_connection_name=
private_endpoint_connection_name,
properties=properties,
cls=lambda x, y, z: x,
**kwargs)
kwargs.pop('error_map', None)
kwargs.pop('content_type', None)
def get_long_running_output(pipeline_response):
deserialized = self._deserialize('PrivateEndpointConnection',
pipeline_response)
if cls:
return cls(pipeline_response, deserialized, {})
return deserialized
path_format_arguments = {
'resourceGroupName':
self._serialize.url("resource_group_name", resource_group_name,
'str'),
'clusterName':
self._serialize.url("cluster_name", cluster_name, 'str'),
'subscriptionId':
self._serialize.url("self._config.subscription_id",
self._config.subscription_id, 'str'),
'privateEndpointConnectionName':
self._serialize.url("private_endpoint_connection_name",
private_endpoint_connection_name, 'str'),
}
if polling is True:
polling_method = AsyncARMPolling(
lro_delay,
path_format_arguments=path_format_arguments,
**kwargs)
elif polling is False:
polling_method = 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)
else:
return AsyncLROPoller(self._client, raw_result,
get_long_running_output, polling_method)
async def begin_get_status(
self, resource_group_name: str, network_watcher_name: str,
packet_capture_name: str,
**kwargs) -> "models.PacketCaptureQueryStatusResult":
"""Query the status of a running packet capture session.
:param resource_group_name: The name of the resource group.
:type resource_group_name: str
:param network_watcher_name: The name of the Network Watcher resource.
:type network_watcher_name: str
:param packet_capture_name: The name given to the packet capture session.
:type packet_capture_name: str
:keyword callable cls: A custom type or function that will be passed the direct response
:keyword str continuation_token: A continuation token to restart a poller from a saved state.
:keyword polling: True for ARMPolling, False for no polling, or a
polling object for 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: PacketCaptureQueryStatusResult, or the result of cls(response)
:rtype: ~azure.mgmt.network.v2017_09_01.models.PacketCaptureQueryStatusResult
:raises ~azure.core.exceptions.HttpResponseError:
"""
polling = kwargs.pop('polling',
True) # type: Union[bool, AsyncPollingMethod]
cls = kwargs.pop(
'cls',
None) # type: ClsType["models.PacketCaptureQueryStatusResult"]
lro_delay = kwargs.pop('polling_interval',
self._config.polling_interval)
cont_token = kwargs.pop('continuation_token',
None) # type: Optional[str]
if cont_token is None:
raw_result = await self._get_status_initial(
resource_group_name=resource_group_name,
network_watcher_name=network_watcher_name,
packet_capture_name=packet_capture_name,
cls=lambda x, y, z: x,
**kwargs)
kwargs.pop('error_map', None)
kwargs.pop('content_type', None)
def get_long_running_output(pipeline_response):
deserialized = self._deserialize('PacketCaptureQueryStatusResult',
pipeline_response)
if cls:
return cls(pipeline_response, deserialized, {})
return deserialized
if polling is True:
polling_method = AsyncARMPolling(
lro_delay,
lro_options={'final-state-via': 'location'},
**kwargs)
elif polling is False:
polling_method = 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)
else:
return AsyncLROPoller(self._client, raw_result,
get_long_running_output, polling_method)
async def begin_create_or_update(
self, resource_group_name: str, network_security_group_name: str,
security_rule_name: str,
security_rule_parameters: "models.SecurityRule",
**kwargs) -> AsyncLROPoller["models.SecurityRule"]:
"""Creates or updates a security rule in the specified network security group.
:param resource_group_name: The name of the resource group.
:type resource_group_name: str
:param network_security_group_name: The name of the network security group.
:type network_security_group_name: str
:param security_rule_name: The name of the security rule.
:type security_rule_name: str
:param security_rule_parameters: Parameters supplied to the create or update network security
rule operation.
:type security_rule_parameters: ~azure.mgmt.network.v2018_10_01.models.SecurityRule
:keyword callable cls: A custom type or function that will be passed the direct response
:keyword str continuation_token: A continuation token to restart a poller from a saved state.
:keyword polling: True for ARMPolling, False for no polling, or a
polling object for 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 SecurityRule or the result of cls(response)
:rtype: ~azure.core.polling.AsyncLROPoller[~azure.mgmt.network.v2018_10_01.models.SecurityRule]
:raises ~azure.core.exceptions.HttpResponseError:
"""
polling = kwargs.pop('polling',
True) # type: Union[bool, AsyncPollingMethod]
cls = kwargs.pop('cls', None) # type: ClsType["models.SecurityRule"]
lro_delay = kwargs.pop('polling_interval',
self._config.polling_interval)
cont_token = kwargs.pop('continuation_token',
None) # type: Optional[str]
if cont_token is None:
raw_result = await self._create_or_update_initial(
resource_group_name=resource_group_name,
network_security_group_name=network_security_group_name,
security_rule_name=security_rule_name,
security_rule_parameters=security_rule_parameters,
cls=lambda x, y, z: x,
**kwargs)
kwargs.pop('error_map', None)
kwargs.pop('content_type', None)
def get_long_running_output(pipeline_response):
deserialized = self._deserialize('SecurityRule', pipeline_response)
if cls:
return cls(pipeline_response, deserialized, {})
return deserialized
if polling is True:
polling_method = AsyncARMPolling(lro_delay, **kwargs)
elif polling is False:
polling_method = 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)
else:
return AsyncLROPoller(self._client, raw_result,
get_long_running_output, polling_method)
async def begin_create_or_update(
self, resource_group_name: str, virtual_network_name: str,
parameters: "_models.VirtualNetwork",
**kwargs) -> AsyncLROPoller["_models.VirtualNetwork"]:
"""Creates or updates a virtual network in the specified resource group.
:param resource_group_name: The name of the resource group.
:type resource_group_name: str
:param virtual_network_name: The name of the virtual network.
:type virtual_network_name: str
:param parameters: Parameters supplied to the create or update virtual network operation.
:type parameters: ~azure.mgmt.network.v2019_06_01.models.VirtualNetwork
:keyword callable cls: A custom type or function that will be passed the direct response
:keyword str continuation_token: A continuation token to restart a poller from a saved state.
:keyword polling: True for ARMPolling, False for no polling, or a
polling object for 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 VirtualNetwork or the result of cls(response)
:rtype: ~azure.core.polling.AsyncLROPoller[~azure.mgmt.network.v2019_06_01.models.VirtualNetwork]
:raises ~azure.core.exceptions.HttpResponseError:
"""
polling = kwargs.pop('polling',
True) # type: Union[bool, AsyncPollingMethod]
cls = kwargs.pop('cls',
None) # type: ClsType["_models.VirtualNetwork"]
lro_delay = kwargs.pop('polling_interval',
self._config.polling_interval)
cont_token = kwargs.pop('continuation_token',
None) # type: Optional[str]
if cont_token is None:
raw_result = await self._create_or_update_initial(
resource_group_name=resource_group_name,
virtual_network_name=virtual_network_name,
parameters=parameters,
cls=lambda x, y, z: x,
**kwargs)
kwargs.pop('error_map', None)
kwargs.pop('content_type', None)
def get_long_running_output(pipeline_response):
deserialized = self._deserialize('VirtualNetwork',
pipeline_response)
if cls:
return cls(pipeline_response, deserialized, {})
return deserialized
path_format_arguments = {
'resourceGroupName':
self._serialize.url("resource_group_name", resource_group_name,
'str'),
'virtualNetworkName':
self._serialize.url("virtual_network_name", virtual_network_name,
'str'),
'subscriptionId':
self._serialize.url("self._config.subscription_id",
self._config.subscription_id, 'str'),
}
if polling is True:
polling_method = AsyncARMPolling(
lro_delay,
lro_options={'final-state-via': 'azure-async-operation'},
path_format_arguments=path_format_arguments,
**kwargs)
elif polling is False:
polling_method = 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)
else:
return AsyncLROPoller(self._client, raw_result,
get_long_running_output, polling_method)
async def begin_delete(
self, resource_group_name: str, vm_name: str,
vm_extension_name: str,
**kwargs) -> AsyncLROPoller["_models.OperationStatusResponse"]:
"""The operation to delete the extension.
:param resource_group_name: The name of the resource group.
:type resource_group_name: str
:param vm_name: The name of the virtual machine where the extension should be deleted.
:type vm_name: str
:param vm_extension_name: The name of the virtual machine extension.
:type vm_extension_name: str
:keyword callable cls: A custom type or function that will be passed the direct response
:keyword str continuation_token: A continuation token to restart a poller from a saved state.
:keyword polling: True for ARMPolling, False for no polling, or a
polling object for 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 OperationStatusResponse or the result of cls(response)
:rtype: ~azure.core.polling.AsyncLROPoller[~azure.mgmt.compute.v2016_03_30.models.OperationStatusResponse]
:raises ~azure.core.exceptions.HttpResponseError:
"""
polling = kwargs.pop('polling',
True) # type: Union[bool, AsyncPollingMethod]
cls = kwargs.pop(
'cls', None) # type: ClsType["_models.OperationStatusResponse"]
lro_delay = kwargs.pop('polling_interval',
self._config.polling_interval)
cont_token = kwargs.pop('continuation_token',
None) # type: Optional[str]
if cont_token is None:
raw_result = await self._delete_initial(
resource_group_name=resource_group_name,
vm_name=vm_name,
vm_extension_name=vm_extension_name,
cls=lambda x, y, z: x,
**kwargs)
kwargs.pop('error_map', None)
kwargs.pop('content_type', None)
def get_long_running_output(pipeline_response):
deserialized = self._deserialize('OperationStatusResponse',
pipeline_response)
if cls:
return cls(pipeline_response, deserialized, {})
return deserialized
path_format_arguments = {
'resourceGroupName':
self._serialize.url("resource_group_name", resource_group_name,
'str'),
'vmName':
self._serialize.url("vm_name", vm_name, 'str'),
'vmExtensionName':
self._serialize.url("vm_extension_name", vm_extension_name, 'str'),
'subscriptionId':
self._serialize.url("self._config.subscription_id",
self._config.subscription_id, 'str'),
}
if polling is True:
polling_method = AsyncARMPolling(
lro_delay,
path_format_arguments=path_format_arguments,
**kwargs)
elif polling is False:
polling_method = 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)
else:
return AsyncLROPoller(self._client, raw_result,
get_long_running_output, polling_method)
async def begin_update_tags(
self, resource_group_name: str, bastion_host_name: str,
bastion_host_parameters: "_models.TagsObject",
**kwargs) -> AsyncLROPoller["_models.BastionHost"]:
"""Updates bastion host tags.
:param resource_group_name: The resource group name of the BastionHost.
:type resource_group_name: str
:param bastion_host_name: The name of the bastionHost.
:type bastion_host_name: str
:param bastion_host_parameters: Parameters supplied to update a bastion host tags.
:type bastion_host_parameters: ~azure.mgmt.network.v2019_06_01.models.TagsObject
:keyword callable cls: A custom type or function that will be passed the direct response
:keyword str continuation_token: A continuation token to restart a poller from a saved state.
:keyword polling: Pass in True if you'd like the AsyncARMPolling polling method,
False for no polling, or 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 BastionHost or the result of cls(response)
:rtype: ~azure.core.polling.AsyncLROPoller[~azure.mgmt.network.v2019_06_01.models.BastionHost]
:raises ~azure.core.exceptions.HttpResponseError:
"""
polling = kwargs.pop('polling',
True) # type: Union[bool, AsyncPollingMethod]
cls = kwargs.pop('cls', None) # type: ClsType["_models.BastionHost"]
lro_delay = kwargs.pop('polling_interval',
self._config.polling_interval)
cont_token = kwargs.pop('continuation_token',
None) # type: Optional[str]
if cont_token is None:
raw_result = await self._update_tags_initial(
resource_group_name=resource_group_name,
bastion_host_name=bastion_host_name,
bastion_host_parameters=bastion_host_parameters,
cls=lambda x, y, z: x,
**kwargs)
kwargs.pop('error_map', None)
kwargs.pop('content_type', None)
def get_long_running_output(pipeline_response):
deserialized = self._deserialize('BastionHost', pipeline_response)
if cls:
return cls(pipeline_response, deserialized, {})
return deserialized
path_format_arguments = {
'subscriptionId':
self._serialize.url("self._config.subscription_id",
self._config.subscription_id, 'str'),
'resourceGroupName':
self._serialize.url("resource_group_name", resource_group_name,
'str'),
'bastionHostName':
self._serialize.url("bastion_host_name", bastion_host_name, 'str'),
}
if polling is True:
polling_method = AsyncARMPolling(
lro_delay,
path_format_arguments=path_format_arguments,
**kwargs)
elif polling is False:
polling_method = 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)
else:
return AsyncLROPoller(self._client, raw_result,
get_long_running_output, polling_method)
async def begin_start_extension_upgrade(self, resource_group_name: str,
vm_scale_set_name: str,
**kwargs) -> AsyncLROPoller[None]:
"""Starts a rolling upgrade to move all extensions for all virtual machine scale set instances to
the latest available extension version. Instances which are already running the latest
extension versions are not affected.
:param resource_group_name: The name of the resource group.
:type resource_group_name: str
:param vm_scale_set_name: The name of the VM scale set.
:type vm_scale_set_name: str
:keyword callable cls: A custom type or function that will be passed the direct response
:keyword str continuation_token: A continuation token to restart a poller from a saved state.
:keyword polling: Pass in True if you'd like the AsyncARMPolling polling method,
False for no polling, or 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 None or the result of cls(response)
:rtype: ~azure.core.polling.AsyncLROPoller[None]
:raises ~azure.core.exceptions.HttpResponseError:
"""
polling = kwargs.pop('polling',
True) # type: Union[bool, AsyncPollingMethod]
cls = kwargs.pop('cls', None) # type: ClsType[None]
lro_delay = kwargs.pop('polling_interval',
self._config.polling_interval)
cont_token = kwargs.pop('continuation_token',
None) # type: Optional[str]
if cont_token is None:
raw_result = await self._start_extension_upgrade_initial(
resource_group_name=resource_group_name,
vm_scale_set_name=vm_scale_set_name,
cls=lambda x, y, z: x,
**kwargs)
kwargs.pop('error_map', None)
kwargs.pop('content_type', None)
def get_long_running_output(pipeline_response):
if cls:
return cls(pipeline_response, None, {})
path_format_arguments = {
'resourceGroupName':
self._serialize.url("resource_group_name", resource_group_name,
'str'),
'vmScaleSetName':
self._serialize.url("vm_scale_set_name", vm_scale_set_name, 'str'),
'subscriptionId':
self._serialize.url("self._config.subscription_id",
self._config.subscription_id, 'str'),
}
if polling is True:
polling_method = AsyncARMPolling(
lro_delay,
path_format_arguments=path_format_arguments,
**kwargs)
elif polling is False:
polling_method = 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)
else:
return AsyncLROPoller(self._client, raw_result,
get_long_running_output, polling_method)
async def begin_delete(self, resource_group_name: str, profile_name: str,
endpoint_name: str, origin_name: str,
**kwargs) -> AsyncLROPoller[None]:
"""Deletes an existing origin within an endpoint.
:param resource_group_name: Name of the Resource group within the Azure subscription.
:type resource_group_name: str
:param profile_name: Name of the CDN profile which is unique within the resource group.
:type profile_name: str
:param endpoint_name: Name of the endpoint under the profile which is unique globally.
:type endpoint_name: str
:param origin_name: Name of the origin which is unique within the endpoint.
:type origin_name: str
:keyword callable cls: A custom type or function that will be passed the direct response
:keyword str continuation_token: A continuation token to restart a poller from a saved state.
:keyword polling: True for ARMPolling, False for no polling, or a
polling object for 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 None or the result of cls(response)
:rtype: ~azure.core.polling.AsyncLROPoller[None]
:raises ~azure.core.exceptions.HttpResponseError:
"""
polling = kwargs.pop('polling',
True) # type: Union[bool, AsyncPollingMethod]
cls = kwargs.pop('cls', None) # type: ClsType[None]
lro_delay = kwargs.pop('polling_interval',
self._config.polling_interval)
cont_token = kwargs.pop('continuation_token',
None) # type: Optional[str]
if cont_token is None:
raw_result = await self._delete_initial(
resource_group_name=resource_group_name,
profile_name=profile_name,
endpoint_name=endpoint_name,
origin_name=origin_name,
cls=lambda x, y, z: x,
**kwargs)
kwargs.pop('error_map', None)
kwargs.pop('content_type', None)
def get_long_running_output(pipeline_response):
if cls:
return cls(pipeline_response, None, {})
path_format_arguments = {
'resourceGroupName':
self._serialize.url("resource_group_name",
resource_group_name,
'str',
max_length=90,
min_length=1,
pattern=r'^[-\w\._\(\)]+$'),
'profileName':
self._serialize.url("profile_name", profile_name, 'str'),
'endpointName':
self._serialize.url("endpoint_name", endpoint_name, 'str'),
'originName':
self._serialize.url("origin_name", origin_name, 'str'),
'subscriptionId':
self._serialize.url("self._config.subscription_id",
self._config.subscription_id, 'str'),
}
if polling is True:
polling_method = AsyncARMPolling(
lro_delay,
path_format_arguments=path_format_arguments,
**kwargs)
elif polling is False:
polling_method = 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)
else:
return AsyncLROPoller(self._client, raw_result,
get_long_running_output, polling_method)
async def begin_create_or_update(self, resource_group_name: str,
virtual_wan_name: str,
wan_parameters: "models.VirtualWAN",
**kwargs) -> "models.VirtualWAN":
"""Creates a VirtualWAN resource if it doesn't exist else updates the existing VirtualWAN.
:param resource_group_name: The resource group name of the VirtualWan.
:type resource_group_name: str
:param virtual_wan_name: The name of the VirtualWAN being created or updated.
:type virtual_wan_name: str
:param wan_parameters: Parameters supplied to create or update VirtualWAN.
:type wan_parameters: ~azure.mgmt.network.v2020_03_01.models.VirtualWAN
:keyword callable cls: A custom type or function that will be passed the direct response
:keyword str continuation_token: A continuation token to restart a poller from a saved state.
:keyword polling: True for ARMPolling, False for no polling, or a
polling object for 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: VirtualWAN, or the result of cls(response)
:rtype: ~azure.mgmt.network.v2020_03_01.models.VirtualWAN
:raises ~azure.core.exceptions.HttpResponseError:
"""
polling = kwargs.pop('polling',
True) # type: Union[bool, AsyncPollingMethod]
cls = kwargs.pop('cls', None) # type: ClsType["models.VirtualWAN"]
lro_delay = kwargs.pop('polling_interval',
self._config.polling_interval)
cont_token = kwargs.pop('continuation_token',
None) # type: Optional[str]
if cont_token is None:
raw_result = await self._create_or_update_initial(
resource_group_name=resource_group_name,
virtual_wan_name=virtual_wan_name,
wan_parameters=wan_parameters,
cls=lambda x, y, z: x,
**kwargs)
kwargs.pop('error_map', None)
kwargs.pop('content_type', None)
def get_long_running_output(pipeline_response):
deserialized = self._deserialize('VirtualWAN', pipeline_response)
if cls:
return cls(pipeline_response, deserialized, {})
return deserialized
if polling is True:
polling_method = AsyncARMPolling(
lro_delay,
lro_options={'final-state-via': 'azure-async-operation'},
**kwargs)
elif polling is False:
polling_method = 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)
else:
return AsyncLROPoller(self._client, raw_result,
get_long_running_output, polling_method)
async def begin_download(
self, resource_group_name: str, virtual_wan_name: str,
request: "_models.GetVpnSitesConfigurationRequest",
**kwargs: Any) -> AsyncLROPoller[None]:
"""Gives the sas-url to download the configurations for vpn-sites in a resource group.
:param resource_group_name: The resource group name.
:type resource_group_name: str
:param virtual_wan_name: The name of the VirtualWAN for which configuration of all vpn-sites is
needed.
:type virtual_wan_name: str
:param request: Parameters supplied to download vpn-sites configuration.
:type request: ~azure.mgmt.network.v2020_04_01.models.GetVpnSitesConfigurationRequest
:keyword callable cls: A custom type or function that will be passed the direct response
: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 None or the result of cls(response)
:rtype: ~azure.core.polling.AsyncLROPoller[None]
:raises ~azure.core.exceptions.HttpResponseError:
"""
polling = kwargs.pop('polling',
True) # type: Union[bool, AsyncPollingMethod]
cls = kwargs.pop('cls', None) # type: ClsType[None]
lro_delay = kwargs.pop('polling_interval',
self._config.polling_interval)
cont_token = kwargs.pop('continuation_token',
None) # type: Optional[str]
if cont_token is None:
raw_result = await self._download_initial(
resource_group_name=resource_group_name,
virtual_wan_name=virtual_wan_name,
request=request,
cls=lambda x, y, z: x,
**kwargs)
kwargs.pop('error_map', None)
kwargs.pop('content_type', None)
def get_long_running_output(pipeline_response):
if cls:
return cls(pipeline_response, None, {})
path_format_arguments = {
'subscriptionId':
self._serialize.url("self._config.subscription_id",
self._config.subscription_id, 'str'),
'resourceGroupName':
self._serialize.url("resource_group_name", resource_group_name,
'str'),
'virtualWANName':
self._serialize.url("virtual_wan_name", virtual_wan_name, 'str'),
}
if polling is True:
polling_method = AsyncARMPolling(
lro_delay,
lro_options={'final-state-via': 'location'},
path_format_arguments=path_format_arguments,
**kwargs)
elif polling is False:
polling_method = 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)
else:
return AsyncLROPoller(self._client, raw_result,
get_long_running_output, polling_method)
async def begin_upgrade_node_image_version(
self, resource_group_name: str, resource_name: str,
agent_pool_name: str,
**kwargs: Any) -> AsyncLROPoller["_models.AgentPool"]:
"""Upgrade node image version of an agent pool to the latest.
Upgrade node image version of an agent pool to the latest.
:param resource_group_name: The name of the resource group.
:type resource_group_name: str
:param resource_name: The name of the managed cluster resource.
:type resource_name: str
:param agent_pool_name: The name of the agent pool.
:type agent_pool_name: str
:keyword callable cls: A custom type or function that will be passed the direct response
: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 None or the result of cls(response)
:rtype: ~azure.core.polling.AsyncLROPoller[None]
:raises ~azure.core.exceptions.HttpResponseError:
"""
polling = kwargs.pop('polling',
True) # type: Union[bool, AsyncPollingMethod]
cls = kwargs.pop('cls', None) # type: ClsType["_models.AgentPool"]
lro_delay = kwargs.pop('polling_interval',
self._config.polling_interval)
cont_token = kwargs.pop('continuation_token',
None) # type: Optional[str]
if cont_token is None:
raw_result = await self._upgrade_node_image_version_initial(
resource_group_name=resource_group_name,
resource_name=resource_name,
agent_pool_name=agent_pool_name,
cls=lambda x, y, z: x,
**kwargs)
kwargs.pop('error_map', None)
kwargs.pop('content_type', None)
def get_long_running_output(pipeline_response):
deserialized = self._deserialize('AgentPool', pipeline_response)
if cls:
return cls(pipeline_response, deserialized, {})
return deserialized
path_format_arguments = {
'subscriptionId':
self._serialize.url("self._config.subscription_id",
self._config.subscription_id, 'str'),
'resourceGroupName':
self._serialize.url("resource_group_name",
resource_group_name,
'str',
min_length=1),
'resourceName':
self._serialize.url(
"resource_name",
resource_name,
'str',
max_length=63,
min_length=1,
pattern=
r'^[a-zA-Z0-9]$|^[a-zA-Z0-9][-_a-zA-Z0-9]{0,61}[a-zA-Z0-9]$'),
'agentPoolName':
self._serialize.url("agent_pool_name", agent_pool_name, 'str'),
}
if polling is True:
polling_method = AsyncARMPolling(
lro_delay,
path_format_arguments=path_format_arguments,
**kwargs)
elif polling is False:
polling_method = 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)
else:
return AsyncLROPoller(self._client, raw_result,
get_long_running_output, polling_method)
async def begin_update(
self, resource_group_name: str, gallery_name: str,
sharing_update: "_models.SharingUpdate",
**kwargs: Any) -> AsyncLROPoller["_models.SharingUpdate"]:
"""Update sharing profile of a gallery.
:param resource_group_name: The name of the resource group.
:type resource_group_name: str
:param gallery_name: The name of the Shared Image Gallery.
:type gallery_name: str
:param sharing_update: Parameters supplied to the update gallery sharing profile.
:type sharing_update: ~azure.mgmt.compute.v2020_09_30.models.SharingUpdate
:keyword callable cls: A custom type or function that will be passed the direct response
: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 SharingUpdate or the result of
cls(response)
:rtype:
~azure.core.polling.AsyncLROPoller[~azure.mgmt.compute.v2020_09_30.models.SharingUpdate]
:raises: ~azure.core.exceptions.HttpResponseError
"""
api_version = kwargs.pop('api_version', "2020-09-30") # type: str
content_type = kwargs.pop('content_type',
"application/json") # type: Optional[str]
polling = kwargs.pop('polling',
True) # type: Union[bool, AsyncPollingMethod]
cls = kwargs.pop('cls', None) # type: ClsType["_models.SharingUpdate"]
lro_delay = kwargs.pop('polling_interval',
self._config.polling_interval)
cont_token = kwargs.pop('continuation_token',
None) # type: Optional[str]
if cont_token is None:
raw_result = await self._update_initial(
resource_group_name=resource_group_name,
gallery_name=gallery_name,
sharing_update=sharing_update,
api_version=api_version,
content_type=content_type,
cls=lambda x, y, z: x,
**kwargs)
kwargs.pop('error_map', None)
def get_long_running_output(pipeline_response):
response = pipeline_response.http_response
deserialized = self._deserialize('SharingUpdate',
pipeline_response)
if cls:
return cls(pipeline_response, deserialized, {})
return deserialized
if polling is True:
polling_method = AsyncARMPolling(lro_delay, **kwargs)
elif polling is False:
polling_method = 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)
async def begin_delete(self, resource_group_name: str,
container_service_name: str,
**kwargs) -> AsyncLROPoller[None]:
"""Deletes the specified container service.
Deletes the specified container service in the specified subscription and resource group. The
operation does not delete other resources created as part of creating a container service,
including storage accounts, VMs, and availability sets. All the other resources created with
the container service are part of the same resource group and can be deleted individually.
:param resource_group_name: The name of the resource group.
:type resource_group_name: str
:param container_service_name: The name of the container service in the specified subscription
and resource group.
:type container_service_name: str
:keyword callable cls: A custom type or function that will be passed the direct response
:keyword str continuation_token: A continuation token to restart a poller from a saved state.
:keyword polling: True for ARMPolling, False for no polling, or a
polling object for 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 None or the result of cls(response)
:rtype: ~azure.core.polling.AsyncLROPoller[None]
:raises ~azure.core.exceptions.HttpResponseError:
"""
polling = kwargs.pop('polling',
True) # type: Union[bool, AsyncPollingMethod]
cls = kwargs.pop('cls', None) # type: ClsType[None]
lro_delay = kwargs.pop('polling_interval',
self._config.polling_interval)
cont_token = kwargs.pop('continuation_token',
None) # type: Optional[str]
if cont_token is None:
raw_result = await self._delete_initial(
resource_group_name=resource_group_name,
container_service_name=container_service_name,
cls=lambda x, y, z: x,
**kwargs)
kwargs.pop('error_map', None)
kwargs.pop('content_type', None)
def get_long_running_output(pipeline_response):
if cls:
return cls(pipeline_response, None, {})
if polling is True:
polling_method = AsyncARMPolling(lro_delay, **kwargs)
elif polling is False:
polling_method = 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)
else:
return AsyncLROPoller(self._client, raw_result,
get_long_running_output, polling_method)
async def begin_update(self, resource_group_name: str, service_name: str,
app_name: str, app_resource: "_models.AppResource",
**kwargs) -> AsyncLROPoller["_models.AppResource"]:
"""Operation to update an exiting App.
:param resource_group_name: The name of the resource group that contains the resource. You can
obtain this value from the Azure Resource Manager API or the portal.
:type resource_group_name: str
:param service_name: The name of the Service resource.
:type service_name: str
:param app_name: The name of the App resource.
:type app_name: str
:param app_resource: Parameters for the update operation.
:type app_resource: ~azure.mgmt.appplatform.v2020_11_01_preview.models.AppResource
:keyword callable cls: A custom type or function that will be passed the direct response
:keyword str continuation_token: A continuation token to restart a poller from a saved state.
:keyword polling: Pass in True if you'd like the AsyncARMPolling polling method,
False for no polling, or 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 AppResource or the result of cls(response)
:rtype: ~azure.core.polling.AsyncLROPoller[~azure.mgmt.appplatform.v2020_11_01_preview.models.AppResource]
:raises ~azure.core.exceptions.HttpResponseError:
"""
polling = kwargs.pop('polling',
True) # type: Union[bool, AsyncPollingMethod]
cls = kwargs.pop('cls', None) # type: ClsType["_models.AppResource"]
lro_delay = kwargs.pop('polling_interval',
self._config.polling_interval)
cont_token = kwargs.pop('continuation_token',
None) # type: Optional[str]
if cont_token is None:
raw_result = await self._update_initial(
resource_group_name=resource_group_name,
service_name=service_name,
app_name=app_name,
app_resource=app_resource,
cls=lambda x, y, z: x,
**kwargs)
kwargs.pop('error_map', None)
kwargs.pop('content_type', None)
def get_long_running_output(pipeline_response):
deserialized = self._deserialize('AppResource', pipeline_response)
if cls:
return cls(pipeline_response, deserialized, {})
return deserialized
path_format_arguments = {
'subscriptionId':
self._serialize.url("self._config.subscription_id",
self._config.subscription_id, 'str'),
'resourceGroupName':
self._serialize.url("resource_group_name", resource_group_name,
'str'),
'serviceName':
self._serialize.url("service_name", service_name, 'str'),
'appName':
self._serialize.url("app_name", app_name, 'str'),
}
if polling is True:
polling_method = AsyncARMPolling(
lro_delay,
lro_options={'final-state-via': 'azure-async-operation'},
path_format_arguments=path_format_arguments,
**kwargs)
elif polling is False:
polling_method = 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)
else:
return AsyncLROPoller(self._client, raw_result,
get_long_running_output, polling_method)
async def begin_delete(self, resource_group_name: str,
config_store_name: str,
private_endpoint_connection_name: str,
**kwargs: Any) -> AsyncLROPoller[None]:
"""Deletes a private endpoint connection.
:param resource_group_name: The name of the resource group to which the container registry
belongs.
:type resource_group_name: str
:param config_store_name: The name of the configuration store.
:type config_store_name: str
:param private_endpoint_connection_name: Private endpoint connection name.
:type private_endpoint_connection_name: str
:keyword callable cls: A custom type or function that will be passed the direct response
: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 None or the result of cls(response)
:rtype: ~azure.core.polling.AsyncLROPoller[None]
:raises ~azure.core.exceptions.HttpResponseError:
"""
polling = kwargs.pop('polling',
True) # type: Union[bool, AsyncPollingMethod]
cls = kwargs.pop('cls', None) # type: ClsType[None]
lro_delay = kwargs.pop('polling_interval',
self._config.polling_interval)
cont_token = kwargs.pop('continuation_token',
None) # type: Optional[str]
if cont_token is None:
raw_result = await self._delete_initial(
resource_group_name=resource_group_name,
config_store_name=config_store_name,
private_endpoint_connection_name=
private_endpoint_connection_name,
cls=lambda x, y, z: x,
**kwargs)
kwargs.pop('error_map', None)
kwargs.pop('content_type', None)
def get_long_running_output(pipeline_response):
if cls:
return cls(pipeline_response, None, {})
path_format_arguments = {
'subscriptionId':
self._serialize.url("self._config.subscription_id",
self._config.subscription_id, 'str'),
'resourceGroupName':
self._serialize.url("resource_group_name", resource_group_name,
'str'),
'configStoreName':
self._serialize.url("config_store_name",
config_store_name,
'str',
max_length=50,
min_length=5,
pattern=r'^[a-zA-Z0-9_-]*$'),
'privateEndpointConnectionName':
self._serialize.url("private_endpoint_connection_name",
private_endpoint_connection_name, 'str'),
}
if polling is True:
polling_method = AsyncARMPolling(
lro_delay,
path_format_arguments=path_format_arguments,
**kwargs)
elif polling is False:
polling_method = 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)
else:
return AsyncLROPoller(self._client, raw_result,
get_long_running_output, polling_method)
async def begin_stop_packet_capture(
self,
resource_group_name: str,
gateway_name: str,
parameters: Optional["_models.VpnGatewayPacketCaptureStopParameters"] = None,
**kwargs: Any
) -> AsyncLROPoller[str]:
"""Stops packet capture on vpn gateway in the specified resource group.
:param resource_group_name: The resource group name of the VpnGateway.
:type resource_group_name: str
:param gateway_name: The name of the gateway.
:type gateway_name: str
:param parameters: Vpn gateway packet capture parameters supplied to stop packet capture on vpn
gateway.
:type parameters: ~azure.mgmt.network.v2020_08_01.models.VpnGatewayPacketCaptureStopParameters
:keyword callable cls: A custom type or function that will be passed the direct response
: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 str or the result of cls(response)
:rtype: ~azure.core.polling.AsyncLROPoller[str]
:raises ~azure.core.exceptions.HttpResponseError:
"""
polling = kwargs.pop('polling', True) # type: Union[bool, AsyncPollingMethod]
cls = kwargs.pop('cls', None) # type: ClsType[str]
lro_delay = kwargs.pop(
'polling_interval',
self._config.polling_interval
)
cont_token = kwargs.pop('continuation_token', None) # type: Optional[str]
if cont_token is None:
raw_result = await self._stop_packet_capture_initial(
resource_group_name=resource_group_name,
gateway_name=gateway_name,
parameters=parameters,
cls=lambda x,y,z: x,
**kwargs
)
kwargs.pop('error_map', None)
kwargs.pop('content_type', None)
def get_long_running_output(pipeline_response):
deserialized = self._deserialize('str', pipeline_response)
if cls:
return cls(pipeline_response, deserialized, {})
return deserialized
path_format_arguments = {
'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str'),
'gatewayName': self._serialize.url("gateway_name", gateway_name, 'str'),
'subscriptionId': self._serialize.url("self._config.subscription_id", self._config.subscription_id, 'str'),
}
if polling is True: polling_method = AsyncARMPolling(lro_delay, lro_options={'final-state-via': 'location'}, path_format_arguments=path_format_arguments, **kwargs)
elif polling is False: polling_method = 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
)
else:
return AsyncLROPoller(self._client, raw_result, get_long_running_output, polling_method)
async def begin_delete( # pylint: disable=inconsistent-return-statements
self,
resource_group_name: str,
resource_name: str,
private_endpoint_connection_name: str,
**kwargs: Any
) -> AsyncLROPoller[None]:
"""Deletes a private endpoint connection.
Deletes a private endpoint connection.
:param resource_group_name: The name of the resource group.
:type resource_group_name: str
:param resource_name: The name of the managed cluster resource.
:type resource_name: str
:param private_endpoint_connection_name: The name of the private endpoint connection.
:type private_endpoint_connection_name: str
:keyword callable cls: A custom type or function that will be passed the direct response
: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 None or the result of cls(response)
:rtype: ~azure.core.polling.AsyncLROPoller[None]
:raises: ~azure.core.exceptions.HttpResponseError
"""
api_version = kwargs.pop('api_version', "2021-05-01") # type: str
polling = kwargs.pop('polling', True) # type: Union[bool, AsyncPollingMethod]
cls = kwargs.pop('cls', None) # type: ClsType[None]
lro_delay = kwargs.pop(
'polling_interval',
self._config.polling_interval
)
cont_token = kwargs.pop('continuation_token', None) # type: Optional[str]
if cont_token is None:
raw_result = await self._delete_initial(
resource_group_name=resource_group_name,
resource_name=resource_name,
private_endpoint_connection_name=private_endpoint_connection_name,
api_version=api_version,
cls=lambda x,y,z: x,
**kwargs
)
kwargs.pop('error_map', None)
def get_long_running_output(pipeline_response):
if cls:
return cls(pipeline_response, None, {})
if polling is True: polling_method = AsyncARMPolling(lro_delay, **kwargs)
elif polling is False: polling_method = 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)
async def begin_update(self,
resource_group_name: str,
profile_name: str,
tags: Optional[Dict[str, str]] = None,
**kwargs) -> AsyncLROPoller["models.Profile"]:
"""Updates an existing CDN profile with the specified profile name under the specified
subscription and resource group.
:param resource_group_name: Name of the Resource group within the Azure subscription.
:type resource_group_name: str
:param profile_name: Name of the CDN profile which is unique within the resource group.
:type profile_name: str
:param tags: Profile tags.
:type tags: dict[str, str]
:keyword callable cls: A custom type or function that will be passed the direct response
:keyword str continuation_token: A continuation token to restart a poller from a saved state.
:keyword polling: True for ARMPolling, False for no polling, or a
polling object for 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 Profile or the result of cls(response)
:rtype: ~azure.core.polling.AsyncLROPoller[~azure.mgmt.cdn.models.Profile]
:raises ~azure.core.exceptions.HttpResponseError:
"""
polling = kwargs.pop('polling',
True) # type: Union[bool, AsyncPollingMethod]
cls = kwargs.pop('cls', None) # type: ClsType["models.Profile"]
lro_delay = kwargs.pop('polling_interval',
self._config.polling_interval)
cont_token = kwargs.pop('continuation_token',
None) # type: Optional[str]
if cont_token is None:
raw_result = await self._update_initial(
resource_group_name=resource_group_name,
profile_name=profile_name,
tags=tags,
cls=lambda x, y, z: x,
**kwargs)
kwargs.pop('error_map', None)
kwargs.pop('content_type', None)
def get_long_running_output(pipeline_response):
deserialized = self._deserialize('Profile', pipeline_response)
if cls:
return cls(pipeline_response, deserialized, {})
return deserialized
if polling is True:
polling_method = AsyncARMPolling(lro_delay, **kwargs)
elif polling is False:
polling_method = 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)
else:
return AsyncLROPoller(self._client, raw_result,
get_long_running_output, polling_method)
async def begin_update_tags(self, resource_group_name: str,
load_balancer_name: str,
parameters: "models.TagsObject",
**kwargs) -> "models.LoadBalancer":
"""Updates a load balancer tags.
:param resource_group_name: The name of the resource group.
:type resource_group_name: str
:param load_balancer_name: The name of the load balancer.
:type load_balancer_name: str
:param parameters: Parameters supplied to update load balancer tags.
:type parameters: ~azure.mgmt.network.v2017_11_01.models.TagsObject
:keyword callable cls: A custom type or function that will be passed the direct response
:keyword str continuation_token: A continuation token to restart a poller from a saved state.
:keyword polling: True for ARMPolling, False for no polling, or a
polling object for 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: LoadBalancer, or the result of cls(response)
:rtype: ~azure.mgmt.network.v2017_11_01.models.LoadBalancer
:raises ~azure.core.exceptions.HttpResponseError:
"""
polling = kwargs.pop('polling',
True) # type: Union[bool, AsyncPollingMethod]
cls = kwargs.pop('cls', None) # type: ClsType["models.LoadBalancer"]
lro_delay = kwargs.pop('polling_interval',
self._config.polling_interval)
cont_token = kwargs.pop('continuation_token',
None) # type: Optional[str]
if cont_token is None:
raw_result = await self._update_tags_initial(
resource_group_name=resource_group_name,
load_balancer_name=load_balancer_name,
parameters=parameters,
cls=lambda x, y, z: x,
**kwargs)
kwargs.pop('error_map', None)
kwargs.pop('content_type', None)
def get_long_running_output(pipeline_response):
deserialized = self._deserialize('LoadBalancer', pipeline_response)
if cls:
return cls(pipeline_response, deserialized, {})
return deserialized
if polling is True:
polling_method = AsyncARMPolling(lro_delay, **kwargs)
elif polling is False:
polling_method = 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)
else:
return AsyncLROPoller(self._client, raw_result,
get_long_running_output, polling_method)
async def begin_create_or_update(
self,
resource_group_name: str,
express_route_gateway_name: str,
connection_name: str,
put_express_route_connection_parameters: "models.ExpressRouteConnection",
**kwargs
) -> "models.ExpressRouteConnection":
"""Creates a connection between an ExpressRoute gateway and an ExpressRoute circuit.
:param resource_group_name: The name of the resource group.
:type resource_group_name: str
:param express_route_gateway_name: The name of the ExpressRoute gateway.
:type express_route_gateway_name: str
:param connection_name: The name of the connection subresource.
:type connection_name: str
:param put_express_route_connection_parameters: Parameters required in an
ExpressRouteConnection PUT operation.
:type put_express_route_connection_parameters: ~azure.mgmt.network.v2018_10_01.models.ExpressRouteConnection
:keyword callable cls: A custom type or function that will be passed the direct response
:keyword str continuation_token: A continuation token to restart a poller from a saved state.
:keyword polling: True for ARMPolling, False for no polling, or a
polling object for 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: ExpressRouteConnection, or the result of cls(response)
:rtype: ~azure.mgmt.network.v2018_10_01.models.ExpressRouteConnection
:raises ~azure.core.exceptions.HttpResponseError:
"""
polling = kwargs.pop('polling', True) # type: Union[bool, AsyncPollingMethod]
cls = kwargs.pop('cls', None) # type: ClsType["models.ExpressRouteConnection"]
lro_delay = kwargs.pop(
'polling_interval',
self._config.polling_interval
)
cont_token = kwargs.pop('continuation_token', None) # type: Optional[str]
if cont_token is None:
raw_result = await self._create_or_update_initial(
resource_group_name=resource_group_name,
express_route_gateway_name=express_route_gateway_name,
connection_name=connection_name,
put_express_route_connection_parameters=put_express_route_connection_parameters,
cls=lambda x,y,z: x,
**kwargs
)
kwargs.pop('error_map', None)
kwargs.pop('content_type', None)
def get_long_running_output(pipeline_response):
deserialized = self._deserialize('ExpressRouteConnection', pipeline_response)
if cls:
return cls(pipeline_response, deserialized, {})
return deserialized
if polling is True: polling_method = AsyncARMPolling(lro_delay, **kwargs)
elif polling is False: polling_method = 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
)
else:
return AsyncLROPoller(self._client, raw_result, get_long_running_output, polling_method)
async def begin_walk_update_domain( # pylint: disable=inconsistent-return-statements
self,
resource_group_name: str,
cloud_service_name: str,
update_domain: int,
parameters: Optional["_models.UpdateDomain"] = None,
**kwargs: Any) -> AsyncLROPoller[None]:
"""Updates the role instances in the specified update domain.
:param resource_group_name: Name of the resource group.
:type resource_group_name: str
:param cloud_service_name: Name of the cloud service.
:type cloud_service_name: str
:param update_domain: Specifies an integer value that identifies the update domain. Update
domains are identified with a zero-based index: the first update domain has an ID of 0, the
second has an ID of 1, and so on.
:type update_domain: int
:param parameters: The update domain object. Default value is None.
:type parameters: ~azure.mgmt.compute.v2020_10_01_preview.models.UpdateDomain
:keyword callable cls: A custom type or function that will be passed the direct response
: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 None or the result of cls(response)
:rtype: ~azure.core.polling.AsyncLROPoller[None]
:raises: ~azure.core.exceptions.HttpResponseError
"""
api_version = kwargs.pop('api_version',
"2020-10-01-preview") # type: str
content_type = kwargs.pop('content_type',
"application/json") # type: Optional[str]
polling = kwargs.pop('polling',
True) # type: Union[bool, AsyncPollingMethod]
cls = kwargs.pop('cls', None) # type: ClsType[None]
lro_delay = kwargs.pop('polling_interval',
self._config.polling_interval)
cont_token = kwargs.pop('continuation_token',
None) # type: Optional[str]
if cont_token is None:
raw_result = await self._walk_update_domain_initial(
resource_group_name=resource_group_name,
cloud_service_name=cloud_service_name,
update_domain=update_domain,
parameters=parameters,
api_version=api_version,
content_type=content_type,
cls=lambda x, y, z: x,
**kwargs)
kwargs.pop('error_map', None)
def get_long_running_output(pipeline_response):
if cls:
return cls(pipeline_response, None, {})
if polling is True:
polling_method = AsyncARMPolling(lro_delay, **kwargs)
elif polling is False:
polling_method = 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)
async def begin_get_ike_sas(
self,
resource_group_name: str,
gateway_name: str,
connection_name: str,
link_connection_name: str,
**kwargs
) -> AsyncLROPoller[str]:
"""Lists IKE Security Associations for Vpn Site Link Connection in the specified resource group.
:param resource_group_name: The name of the resource group.
:type resource_group_name: str
:param gateway_name: The name of the gateway.
:type gateway_name: str
:param connection_name: The name of the vpn connection.
:type connection_name: str
:param link_connection_name: The name of the vpn link connection.
:type link_connection_name: str
:keyword callable cls: A custom type or function that will be passed the direct response
:keyword str continuation_token: A continuation token to restart a poller from a saved state.
:keyword polling: Pass in True if you'd like the AsyncARMPolling polling method,
False for no polling, or 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 str or the result of cls(response)
:rtype: ~azure.core.polling.AsyncLROPoller[str]
:raises ~azure.core.exceptions.HttpResponseError:
"""
polling = kwargs.pop('polling', True) # type: Union[bool, AsyncPollingMethod]
cls = kwargs.pop('cls', None) # type: ClsType[str]
lro_delay = kwargs.pop(
'polling_interval',
self._config.polling_interval
)
cont_token = kwargs.pop('continuation_token', None) # type: Optional[str]
if cont_token is None:
raw_result = await self._get_ike_sas_initial(
resource_group_name=resource_group_name,
gateway_name=gateway_name,
connection_name=connection_name,
link_connection_name=link_connection_name,
cls=lambda x,y,z: x,
**kwargs
)
kwargs.pop('error_map', None)
kwargs.pop('content_type', None)
def get_long_running_output(pipeline_response):
deserialized = self._deserialize('str', pipeline_response)
if cls:
return cls(pipeline_response, deserialized, {})
return deserialized
path_format_arguments = {
'subscriptionId': self._serialize.url("self._config.subscription_id", self._config.subscription_id, 'str'),
'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str'),
'gatewayName': self._serialize.url("gateway_name", gateway_name, 'str'),
'connectionName': self._serialize.url("connection_name", connection_name, 'str'),
'linkConnectionName': self._serialize.url("link_connection_name", link_connection_name, 'str'),
}
if polling is True: polling_method = AsyncARMPolling(lro_delay, lro_options={'final-state-via': 'location'}, path_format_arguments=path_format_arguments, **kwargs)
elif polling is False: polling_method = 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
)
else:
return AsyncLROPoller(self._client, raw_result, get_long_running_output, polling_method)
async def begin_delete(
self, resource_group_name: str, workspace_name: str,
linked_service_name: str,
**kwargs) -> AsyncLROPoller["_models.LinkedService"]:
"""Deletes a linked service instance.
:param resource_group_name: The name of the resource group. The name is case insensitive.
:type resource_group_name: str
:param workspace_name: The name of the workspace.
:type workspace_name: str
:param linked_service_name: Name of the linked service.
:type linked_service_name: str
:keyword callable cls: A custom type or function that will be passed the direct response
:keyword str continuation_token: A continuation token to restart a poller from a saved state.
:keyword polling: Pass in True if you'd like the AsyncARMPolling polling method,
False for no polling, or 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 LinkedService or the result of cls(response)
:rtype: ~azure.core.polling.AsyncLROPoller[~azure.mgmt.loganalytics.models.LinkedService]
:raises ~azure.core.exceptions.HttpResponseError:
"""
polling = kwargs.pop('polling',
True) # type: Union[bool, AsyncPollingMethod]
cls = kwargs.pop('cls', None) # type: ClsType["_models.LinkedService"]
lro_delay = kwargs.pop('polling_interval',
self._config.polling_interval)
cont_token = kwargs.pop('continuation_token',
None) # type: Optional[str]
if cont_token is None:
raw_result = await self._delete_initial(
resource_group_name=resource_group_name,
workspace_name=workspace_name,
linked_service_name=linked_service_name,
cls=lambda x, y, z: x,
**kwargs)
kwargs.pop('error_map', None)
kwargs.pop('content_type', None)
def get_long_running_output(pipeline_response):
deserialized = self._deserialize('LinkedService',
pipeline_response)
if cls:
return cls(pipeline_response, deserialized, {})
return deserialized
path_format_arguments = {
'resourceGroupName':
self._serialize.url("resource_group_name",
resource_group_name,
'str',
max_length=90,
min_length=1,
pattern=r'^[-\w\._\(\)]+$'),
'workspaceName':
self._serialize.url(
"workspace_name",
workspace_name,
'str',
max_length=63,
min_length=4,
pattern=r'^[A-Za-z0-9][A-Za-z0-9-]+[A-Za-z0-9]$'),
'linkedServiceName':
self._serialize.url("linked_service_name", linked_service_name,
'str'),
'subscriptionId':
self._serialize.url("self._config.subscription_id",
self._config.subscription_id,
'str',
min_length=1),
}
if polling is True:
polling_method = AsyncARMPolling(
lro_delay,
path_format_arguments=path_format_arguments,
**kwargs)
elif polling is False:
polling_method = 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)
else:
return AsyncLROPoller(self._client, raw_result,
get_long_running_output, polling_method)
async def begin_update(
self, resource_group_name: str, service_name: str, app_name: str,
binding_name: str, binding_resource: "_models.BindingResource",
**kwargs: Any) -> AsyncLROPoller["_models.BindingResource"]:
"""Operation to update an exiting Binding.
:param resource_group_name: The name of the resource group that contains the resource. You can
obtain this value from the Azure Resource Manager API or the portal.
:type resource_group_name: str
:param service_name: The name of the Service resource.
:type service_name: str
:param app_name: The name of the App resource.
:type app_name: str
:param binding_name: The name of the Binding resource.
:type binding_name: str
:param binding_resource: Parameters for the update operation.
:type binding_resource: ~azure.mgmt.appplatform.v2022_05_01_preview.models.BindingResource
:keyword callable cls: A custom type or function that will be passed the direct response
: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 BindingResource or the result of
cls(response)
:rtype:
~azure.core.polling.AsyncLROPoller[~azure.mgmt.appplatform.v2022_05_01_preview.models.BindingResource]
:raises: ~azure.core.exceptions.HttpResponseError
"""
api_version = kwargs.pop('api_version',
"2022-05-01-preview") # type: str
content_type = kwargs.pop('content_type',
"application/json") # type: Optional[str]
polling = kwargs.pop('polling',
True) # type: Union[bool, AsyncPollingMethod]
cls = kwargs.pop('cls',
None) # type: ClsType["_models.BindingResource"]
lro_delay = kwargs.pop('polling_interval',
self._config.polling_interval)
cont_token = kwargs.pop('continuation_token',
None) # type: Optional[str]
if cont_token is None:
raw_result = await self._update_initial(
resource_group_name=resource_group_name,
service_name=service_name,
app_name=app_name,
binding_name=binding_name,
binding_resource=binding_resource,
api_version=api_version,
content_type=content_type,
cls=lambda x, y, z: x,
**kwargs)
kwargs.pop('error_map', None)
def get_long_running_output(pipeline_response):
response = pipeline_response.http_response
deserialized = self._deserialize('BindingResource',
pipeline_response)
if cls:
return cls(pipeline_response, deserialized, {})
return deserialized
if polling is True:
polling_method = AsyncARMPolling(lro_delay, **kwargs)
elif polling is False:
polling_method = 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)
async def begin_create(
self, resource_group_name: str, network_watcher_name: str,
packet_capture_name: str, parameters: "_models.PacketCapture",
**kwargs: Any) -> AsyncLROPoller["_models.PacketCaptureResult"]:
"""Create and start a packet capture on the specified VM.
:param resource_group_name: The name of the resource group.
:type resource_group_name: str
:param network_watcher_name: The name of the network watcher.
:type network_watcher_name: str
:param packet_capture_name: The name of the packet capture session.
:type packet_capture_name: str
:param parameters: Parameters that define the create packet capture operation.
:type parameters: ~azure.mgmt.network.v2018_11_01.models.PacketCapture
:keyword callable cls: A custom type or function that will be passed the direct response
: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 PacketCaptureResult or the result of cls(response)
:rtype: ~azure.core.polling.AsyncLROPoller[~azure.mgmt.network.v2018_11_01.models.PacketCaptureResult]
:raises ~azure.core.exceptions.HttpResponseError:
"""
polling = kwargs.pop('polling',
True) # type: Union[bool, AsyncPollingMethod]
cls = kwargs.pop('cls',
None) # type: ClsType["_models.PacketCaptureResult"]
lro_delay = kwargs.pop('polling_interval',
self._config.polling_interval)
cont_token = kwargs.pop('continuation_token',
None) # type: Optional[str]
if cont_token is None:
raw_result = await self._create_initial(
resource_group_name=resource_group_name,
network_watcher_name=network_watcher_name,
packet_capture_name=packet_capture_name,
parameters=parameters,
cls=lambda x, y, z: x,
**kwargs)
kwargs.pop('error_map', None)
kwargs.pop('content_type', None)
def get_long_running_output(pipeline_response):
deserialized = self._deserialize('PacketCaptureResult',
pipeline_response)
if cls:
return cls(pipeline_response, deserialized, {})
return deserialized
path_format_arguments = {
'resourceGroupName':
self._serialize.url("resource_group_name", resource_group_name,
'str'),
'networkWatcherName':
self._serialize.url("network_watcher_name", network_watcher_name,
'str'),
'packetCaptureName':
self._serialize.url("packet_capture_name", packet_capture_name,
'str'),
'subscriptionId':
self._serialize.url("self._config.subscription_id",
self._config.subscription_id, 'str'),
}
if polling is True:
polling_method = AsyncARMPolling(
lro_delay,
path_format_arguments=path_format_arguments,
**kwargs)
elif polling is False:
polling_method = 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)
else:
return AsyncLROPoller(self._client, raw_result,
get_long_running_output, polling_method)
async def begin_create_or_update(
self, resource_group_name: str, private_cloud_name: str,
script_execution_name: str,
script_execution: "_models.ScriptExecution",
**kwargs: Any) -> AsyncLROPoller["_models.ScriptExecution"]:
"""Create or update a script execution in a private cloud.
Create or update a script execution in a private cloud.
:param resource_group_name: The name of the resource group. The name is case insensitive.
:type resource_group_name: str
:param private_cloud_name: The name of the private cloud.
:type private_cloud_name: str
:param script_execution_name: Name of the user-invoked script execution resource.
:type script_execution_name: str
:param script_execution: A script running in the private cloud.
:type script_execution: ~avs_client.models.ScriptExecution
:keyword callable cls: A custom type or function that will be passed the direct response
: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 ScriptExecution or the result of cls(response)
:rtype: ~azure.core.polling.AsyncLROPoller[~avs_client.models.ScriptExecution]
:raises ~azure.core.exceptions.HttpResponseError:
"""
polling = kwargs.pop('polling',
True) # type: Union[bool, AsyncPollingMethod]
cls = kwargs.pop('cls',
None) # type: ClsType["_models.ScriptExecution"]
lro_delay = kwargs.pop('polling_interval',
self._config.polling_interval)
cont_token = kwargs.pop('continuation_token',
None) # type: Optional[str]
if cont_token is None:
raw_result = await self._create_or_update_initial(
resource_group_name=resource_group_name,
private_cloud_name=private_cloud_name,
script_execution_name=script_execution_name,
script_execution=script_execution,
cls=lambda x, y, z: x,
**kwargs)
kwargs.pop('error_map', None)
kwargs.pop('content_type', None)
def get_long_running_output(pipeline_response):
deserialized = self._deserialize('ScriptExecution',
pipeline_response)
if cls:
return cls(pipeline_response, deserialized, {})
return deserialized
path_format_arguments = {
'subscriptionId':
self._serialize.url("self._config.subscription_id",
self._config.subscription_id,
'str',
min_length=1),
'resourceGroupName':
self._serialize.url("resource_group_name",
resource_group_name,
'str',
max_length=90,
min_length=1),
'privateCloudName':
self._serialize.url("private_cloud_name", private_cloud_name,
'str'),
'scriptExecutionName':
self._serialize.url("script_execution_name", script_execution_name,
'str'),
}
if polling is True:
polling_method = AsyncARMPolling(
lro_delay,
path_format_arguments=path_format_arguments,
**kwargs)
elif polling is False:
polling_method = 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)
else:
return AsyncLROPoller(self._client, raw_result,
get_long_running_output, polling_method)
async def begin_delete(
self,
resource_group_name: str,
network_profile_name: str,
**kwargs
) -> AsyncLROPoller[None]:
"""Deletes the specified network profile.
:param resource_group_name: The name of the resource group.
:type resource_group_name: str
:param network_profile_name: The name of the NetworkProfile.
:type network_profile_name: str
:keyword callable cls: A custom type or function that will be passed the direct response
:keyword str continuation_token: A continuation token to restart a poller from a saved state.
:keyword polling: True for ARMPolling, False for no polling, or a
polling object for 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 None or the result of cls(response)
:rtype: ~azure.core.polling.AsyncLROPoller[None]
:raises ~azure.core.exceptions.HttpResponseError:
"""
polling = kwargs.pop('polling', True) # type: Union[bool, AsyncPollingMethod]
cls = kwargs.pop('cls', None) # type: ClsType[None]
lro_delay = kwargs.pop(
'polling_interval',
self._config.polling_interval
)
cont_token = kwargs.pop('continuation_token', None) # type: Optional[str]
if cont_token is None:
raw_result = await self._delete_initial(
resource_group_name=resource_group_name,
network_profile_name=network_profile_name,
cls=lambda x,y,z: x,
**kwargs
)
kwargs.pop('error_map', None)
kwargs.pop('content_type', None)
def get_long_running_output(pipeline_response):
if cls:
return cls(pipeline_response, None, {})
path_format_arguments = {
'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str'),
'networkProfileName': self._serialize.url("network_profile_name", network_profile_name, 'str'),
'subscriptionId': self._serialize.url("self._config.subscription_id", self._config.subscription_id, 'str'),
}
if polling is True: polling_method = AsyncARMPolling(lro_delay, lro_options={'final-state-via': 'location'}, path_format_arguments=path_format_arguments, **kwargs)
elif polling is False: polling_method = 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
)
else:
return AsyncLROPoller(self._client, raw_result, get_long_running_output, polling_method)
async def begin_create_or_update(
self, resource_group_name: str, vm_scale_set_name: str,
vmss_extension_name: str,
extension_parameters: "models.VirtualMachineScaleSetExtension",
**kwargs
) -> AsyncLROPoller["models.VirtualMachineScaleSetExtension"]:
"""The operation to create or update an extension.
:param resource_group_name: The name of the resource group.
:type resource_group_name: str
:param vm_scale_set_name: The name of the VM scale set where the extension should be create or
updated.
:type vm_scale_set_name: str
:param vmss_extension_name: The name of the VM scale set extension.
:type vmss_extension_name: str
:param extension_parameters: Parameters supplied to the Create VM scale set Extension
operation.
:type extension_parameters: ~azure.mgmt.compute.v2017_03_30.models.VirtualMachineScaleSetExtension
:keyword callable cls: A custom type or function that will be passed the direct response
:keyword str continuation_token: A continuation token to restart a poller from a saved state.
:keyword polling: True for ARMPolling, False for no polling, or a
polling object for 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 VirtualMachineScaleSetExtension or the result of cls(response)
:rtype: ~azure.core.polling.AsyncLROPoller[~azure.mgmt.compute.v2017_03_30.models.VirtualMachineScaleSetExtension]
:raises ~azure.core.exceptions.HttpResponseError:
"""
polling = kwargs.pop('polling',
True) # type: Union[bool, AsyncPollingMethod]
cls = kwargs.pop(
'cls',
None) # type: ClsType["models.VirtualMachineScaleSetExtension"]
lro_delay = kwargs.pop('polling_interval',
self._config.polling_interval)
cont_token = kwargs.pop('continuation_token',
None) # type: Optional[str]
if cont_token is None:
raw_result = await self._create_or_update_initial(
resource_group_name=resource_group_name,
vm_scale_set_name=vm_scale_set_name,
vmss_extension_name=vmss_extension_name,
extension_parameters=extension_parameters,
cls=lambda x, y, z: x,
**kwargs)
kwargs.pop('error_map', None)
kwargs.pop('content_type', None)
def get_long_running_output(pipeline_response):
deserialized = self._deserialize('VirtualMachineScaleSetExtension',
pipeline_response)
if cls:
return cls(pipeline_response, deserialized, {})
return deserialized
if polling is True:
polling_method = AsyncARMPolling(lro_delay, **kwargs)
elif polling is False:
polling_method = 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)
else:
return AsyncLROPoller(self._client, raw_result,
get_long_running_output, polling_method)
async def begin_update_tags(
self, resource_group_name: str, express_route_gateway_name: str,
express_route_gateway_parameters: "_models.TagsObject",
**kwargs: Any) -> AsyncLROPoller["_models.ExpressRouteGateway"]:
"""Updates express route gateway tags.
:param resource_group_name: The resource group name of the ExpressRouteGateway.
:type resource_group_name: str
:param express_route_gateway_name: The name of the gateway.
:type express_route_gateway_name: str
:param express_route_gateway_parameters: Parameters supplied to update a virtual wan express
route gateway tags.
:type express_route_gateway_parameters: ~azure.mgmt.network.v2021_02_01.models.TagsObject
:keyword callable cls: A custom type or function that will be passed the direct response
: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 ExpressRouteGateway or the result of cls(response)
:rtype: ~azure.core.polling.AsyncLROPoller[~azure.mgmt.network.v2021_02_01.models.ExpressRouteGateway]
:raises ~azure.core.exceptions.HttpResponseError:
"""
polling = kwargs.pop('polling',
True) # type: Union[bool, AsyncPollingMethod]
cls = kwargs.pop('cls',
None) # type: ClsType["_models.ExpressRouteGateway"]
lro_delay = kwargs.pop('polling_interval',
self._config.polling_interval)
cont_token = kwargs.pop('continuation_token',
None) # type: Optional[str]
if cont_token is None:
raw_result = await self._update_tags_initial(
resource_group_name=resource_group_name,
express_route_gateway_name=express_route_gateway_name,
express_route_gateway_parameters=
express_route_gateway_parameters,
cls=lambda x, y, z: x,
**kwargs)
kwargs.pop('error_map', None)
kwargs.pop('content_type', None)
def get_long_running_output(pipeline_response):
deserialized = self._deserialize('ExpressRouteGateway',
pipeline_response)
if cls:
return cls(pipeline_response, deserialized, {})
return deserialized
path_format_arguments = {
'subscriptionId':
self._serialize.url("self._config.subscription_id",
self._config.subscription_id, 'str'),
'resourceGroupName':
self._serialize.url("resource_group_name", resource_group_name,
'str'),
'expressRouteGatewayName':
self._serialize.url("express_route_gateway_name",
express_route_gateway_name, 'str'),
}
if polling is True:
polling_method = AsyncARMPolling(
lro_delay,
lro_options={'final-state-via': 'azure-async-operation'},
path_format_arguments=path_format_arguments,
**kwargs)
elif polling is False:
polling_method = 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)
else:
return AsyncLROPoller(self._client, raw_result,
get_long_running_output, polling_method)
async def begin_create(
self, resource_group_name: str, registry_name: str,
pipeline_run_name: str,
pipeline_run_create_parameters: "_models.PipelineRun",
**kwargs: Any) -> AsyncLROPoller["_models.PipelineRun"]:
"""Creates a pipeline run for a container registry with the specified parameters.
:param resource_group_name: The name of the resource group to which the container registry
belongs.
:type resource_group_name: str
:param registry_name: The name of the container registry.
:type registry_name: str
:param pipeline_run_name: The name of the pipeline run.
:type pipeline_run_name: str
:param pipeline_run_create_parameters: The parameters for creating a pipeline run.
:type pipeline_run_create_parameters:
~azure.mgmt.containerregistry.v2020_11_01_preview.models.PipelineRun
:keyword callable cls: A custom type or function that will be passed the direct response
: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 PipelineRun or the result of
cls(response)
:rtype:
~azure.core.polling.AsyncLROPoller[~azure.mgmt.containerregistry.v2020_11_01_preview.models.PipelineRun]
:raises: ~azure.core.exceptions.HttpResponseError
"""
content_type = kwargs.pop('content_type',
"application/json") # type: Optional[str]
polling = kwargs.pop(
'polling',
True) # type: Union[bool, azure.core.polling.AsyncPollingMethod]
cls = kwargs.pop('cls', None) # type: ClsType["_models.PipelineRun"]
lro_delay = kwargs.pop('polling_interval',
self._config.polling_interval)
cont_token = kwargs.pop('continuation_token',
None) # type: Optional[str]
if cont_token is None:
raw_result = await self._create_initial(
resource_group_name=resource_group_name,
registry_name=registry_name,
pipeline_run_name=pipeline_run_name,
pipeline_run_create_parameters=pipeline_run_create_parameters,
content_type=content_type,
cls=lambda x, y, z: x,
**kwargs)
kwargs.pop('error_map', None)
def get_long_running_output(pipeline_response):
response = pipeline_response.http_response
deserialized = self._deserialize('PipelineRun', pipeline_response)
if cls:
return cls(pipeline_response, deserialized, {})
return deserialized
if polling is True:
polling_method = AsyncARMPolling(lro_delay, **kwargs)
elif polling is False:
polling_method = 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)
else:
return AsyncLROPoller(self._client, raw_result,
get_long_running_output, polling_method)
